@libraz/libcantus 1.1.0 → 1.2.0

package/dist/{chunk-R7B5N2JK.cjs → chunk-PM4XJE2Y.cjs}

@@ -9,7 +9,7 @@
 
 
 
-var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
+var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
@@ -19,17 +19,17 @@ var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
-var _chunkXKSO2V5Icjs = require('./chunk-XKSO2V5I.cjs');
+var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
 
 // src/theory/chordscale/index.ts
 function requireChordScaleMask(name, label = "scale") {
-  const canonical = _chunkYPB3A3EYcjs.resolveScaleName.call(void 0, name);
-  if (canonical !== void 0 && !Object.hasOwn(_chunkYPB3A3EYcjs.NAMED_SCALES, canonical)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+  const canonical = _chunk3R3QVKY5cjs.resolveScaleName.call(void 0, name);
+  if (canonical !== void 0 && !Object.hasOwn(_chunk3R3QVKY5cjs.NAMED_SCALES, canonical)) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
       `${label} must name a scale chord-scale theory ranks; ${String(name)} is a world scale`
     );
   }
-  return _chunkYPB3A3EYcjs.requireScaleMask.call(void 0, name, label);
+  return _chunk3R3QVKY5cjs.requireScaleMask.call(void 0, name, label);
 }
 function popcount12(mask) {
   let count = 0;
@@ -39,15 +39,15 @@ function popcount12(mask) {
   return count;
 }
 function maskHasPitchClass(mask, scaleRootPc, pc) {
-  const offset = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pc - scaleRootPc);
+  const offset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pc - scaleRootPc);
   return (mask >> offset & 1) === 1;
 }
 function scaleMatchesChord(chordPcs, scaleMask, scaleRootPc) {
-  _chunkYPB3A3EYcjs.assertModeMask.call(void 0, scaleMask, "scaleMask");
-  _chunkXKSO2V5Icjs.assertPitchClass.call(void 0, scaleRootPc, "scaleRootPc");
-  const pcs = _chunkXKSO2V5Icjs.assertArray.call(void 0, chordPcs, "chord pitch classes");
+  _chunk3R3QVKY5cjs.assertModeMask.call(void 0, scaleMask, "scaleMask");
+  _chunkS5BKZZGMcjs.assertPitchClass.call(void 0, scaleRootPc, "scaleRootPc");
+  const pcs = _chunkS5BKZZGMcjs.assertArray.call(void 0, chordPcs, "chord pitch classes");
   for (let index = 0; index < pcs.length; index += 1) {
-    const pc = _chunkXKSO2V5Icjs.assertPitchClass.call(void 0, _nullishCoalesce(pcs[index], () => ( Number.NaN)), `chord pitch classes[${index}]`);
+    const pc = _chunkS5BKZZGMcjs.assertPitchClass.call(void 0, _nullishCoalesce(pcs[index], () => ( Number.NaN)), `chord pitch classes[${index}]`);
     if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {
       return false;
     }
@@ -93,16 +93,16 @@ function isAlteredDominant(chord, scaleName) {
   return chord.quality === "dom7" && scaleName === "altered";
 }
 function chordScales(chord) {
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const chordPcs = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, data);
-  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, data.rootPc);
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const chordPcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, data);
+  const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc);
   const ranked = [];
   const seenMasks = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(_chunkYPB3A3EYcjs.NAMED_SCALES)) {
+  for (const name of Object.keys(_chunk3R3QVKY5cjs.NAMED_SCALES)) {
     if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
       continue;
     }
-    const mask = _chunkYPB3A3EYcjs.namedScaleMask.call(void 0, name);
+    const mask = _chunk3R3QVKY5cjs.namedScaleMask.call(void 0, name);
     if (mask === void 0 || seenMasks.has(mask)) {
       continue;
     }
@@ -118,7 +118,7 @@ function chordScales(chord) {
     }
   }
   if (ranked.length === 0) {
-    if (_chunkYPB3A3EYcjs.NAMED_SCALES.chromatic !== void 0) {
+    if (_chunk3R3QVKY5cjs.NAMED_SCALES.chromatic !== void 0) {
       return [{ name: "chromatic", rootPc }];
     }
     return [];
@@ -149,19 +149,19 @@ function chordScales(chord) {
   return ranked.map((entry) => ({ name: entry.name, rootPc }));
 }
 function avoidNotes(chord, scaleName, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
   const mask = requireChordScaleMask(scaleName);
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, data.rootPc);
-  const chordPcs = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, data);
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc);
+  const chordPcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, data);
   const alteredDominant = isAlteredDominant(data, scaleName);
   if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
     return [];
   }
   const chordSet = new Set(chordPcs);
-  const displaced = new Set(_chunkYPB3A3EYcjs.displacedThirds.call(void 0, data));
+  const displaced = new Set(_chunk3R3QVKY5cjs.displacedThirds.call(void 0, data));
   const melodic = asked.use === "melodic";
-  const semitoneAboveRoot = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + 1);
+  const semitoneAboveRoot = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 1);
   const avoid = [];
   for (let pc = 0; pc < 12; pc += 1) {
     if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
@@ -170,7 +170,7 @@ function avoidNotes(chord, scaleName, opts = {}) {
     if (melodic && pc !== semitoneAboveRoot) {
       continue;
     }
-    if (!alteredDominant && (chordSet.has(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pc - 1)) || displaced.has(pc))) {
+    if (!alteredDominant && (chordSet.has(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pc - 1)) || displaced.has(pc))) {
       avoid.push(pc);
     }
   }
@@ -181,23 +181,23 @@ function resolvesToMinorTonic(chord, chordPcs, target) {
   if (target === void 0) {
     return false;
   }
-  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc);
-  const sounds = (semitones) => chordPcs.includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + semitones));
+  const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc);
+  const sounds = (semitones) => chordPcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + semitones));
   if (!sounds(4) || !sounds(10)) {
     return false;
   }
-  const targetRootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, target.rootPc);
-  if (targetRootPc !== _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + 5)) {
+  const targetRootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, target.rootPc);
+  if (targetRootPc !== _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 5)) {
     return false;
   }
-  return _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, target).includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, targetRootPc + 3));
+  return _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, target).includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, targetRootPc + 3));
 }
 function availableTensions(chord, scaleName, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
   const mask = requireChordScaleMask(scaleName);
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, data.rootPc);
-  const chordPcs = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, data);
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc);
+  const chordPcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, data);
   const alteredDominant = isAlteredDominant(data, scaleName);
   if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
     return [];
@@ -207,8 +207,8 @@ function availableTensions(chord, scaleName, opts = {}) {
   const functional = resolvesToMinorTonic(
     data,
     chordPcs,
-    asked.resolvesTo === void 0 ? void 0 : _chunkYPB3A3EYcjs.toChordData.call(void 0, asked.resolvesTo)
-  ) ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + semitones))) : void 0;
+    asked.resolvesTo === void 0 ? void 0 : _chunk3R3QVKY5cjs.toChordData.call(void 0, asked.resolvesTo)
+  ) ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + semitones))) : void 0;
   const tensions = [];
   for (let pc = 0; pc < 12; pc += 1) {
     if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
@@ -223,9 +223,9 @@ function availableTensions(chord, scaleName, opts = {}) {
 }
 function chordScaleReport(chord, limit) {
   if (limit !== void 0) {
-    _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, limit, "chord-scale report limit");
+    _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, limit, "chord-scale report limit");
   }
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
   const matches = chordScales(data);
   const chosen = limit === void 0 ? matches : matches.slice(0, limit);
   return chosen.map((match) => {
@@ -242,14 +242,14 @@ function chordScaleReport(chord, limit) {
 }
 var RANK_PENALTY = 0.01;
 function scalePitchClassSet(name, rootPc) {
-  const mask = _chunkYPB3A3EYcjs.namedScaleMask.call(void 0, name);
+  const mask = _chunk3R3QVKY5cjs.namedScaleMask.call(void 0, name);
   const pcs = /* @__PURE__ */ new Set();
   if (mask === void 0) {
     return pcs;
   }
   for (let n = 0; n < 12; n += 1) {
     if ((mask >> n & 1) === 1) {
-      pcs.add(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + n));
+      pcs.add(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + n));
     }
   }
   return pcs;
@@ -269,8 +269,8 @@ function symmetricDifferenceSize(a, b) {
   return count;
 }
 function scalesForChanges(chords) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, chords, "chord-scale changes");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, chords.length, "chord-scale changes");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "chord-scale changes");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, chords.length, "chord-scale changes");
   if (chords.length === 0) {
     return [];
   }
@@ -330,12 +330,12 @@ function scalesForChanges(chords) {
 
 // src/theory/harmony/index.ts
 function roleOf(pitch, chord, chordId = 0) {
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, chordId, "chordId");
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const interval = (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch) - _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, data.rootPc) + 12) % 12;
-  const slot = _chunkYPB3A3EYcjs.thirdSlotOf.call(void 0, data);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, chordId, "chordId");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const interval = (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc) + 12) % 12;
+  const slot = _chunk3R3QVKY5cjs.thirdSlotOf.call(void 0, data);
   const isSuspendedTone = slot.kind === "suspension" && interval === slot.interval;
-  const chordRole = _chunkYPB3A3EYcjs.chordToneRole.call(void 0, pitch, data);
+  const chordRole = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, pitch, data);
   let role;
   let lock;
   if (isSuspendedTone) {
@@ -360,4 +360,4 @@ function roleOf(pitch, chord, chordId = 0) {
 
 
 exports.scaleMatchesChord = scaleMatchesChord; exports.chordScales = chordScales; exports.avoidNotes = avoidNotes; exports.availableTensions = availableTensions; exports.chordScaleReport = chordScaleReport; exports.scalesForChanges = scalesForChanges; exports.roleOf = roleOf;
-//# sourceMappingURL=chunk-R7B5N2JK.cjs.map
+//# sourceMappingURL=chunk-PM4XJE2Y.cjs.map

package/dist/{chunk-R7B5N2JK.cjs.map → chunk-PM4XJE2Y.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-R7B5N2JK.cjs","../src/theory/chordscale/index.ts","../src/theory/harmony/index.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACaA,SAAS,qBAAA,CAAsB,IAAA,EAAsB,MAAA,EAAQ,OAAA,EAAiB;AAC5E,EAAA,MAAM,UAAA,EAAY,gDAAA,IAAqB,CAAA;AACvC,EAAA,GAAA,CAAI,UAAA,IAAc,KAAA,EAAA,GAAa,CAAC,MAAA,CAAO,MAAA,CAAO,8BAAA,EAAc,SAAS,CAAA,EAAG;AACtE,IAAA,MAAM,IAAI,wCAAA;AAAA,MACR,CAAA,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACM,EAAA;AACJ,EAAA;AACE,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACA,EAAA;AACF;AAYO;AAOL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAkBM;AAGA;AASA;AACJ,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACF;AAGM;AACC,EAAA;AACL,EAAA;AAAgB;AAAA;AAAA;AAAA;AAKhB,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACF;AAOA;AACE,EAAA;AACF;AA6CO;AACL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AAAY,QAAA;AACV,QAAA;AACuB,QAAA;AACvB,QAAA;AAED,MAAA;AACH,IAAA;AACF,EAAA;AACI,EAAA;AAGF,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AAKA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACD,EAAA;AACD,EAAA;AACF;AAwDO;AAKL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AAKA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAWM;AAGN;AAKM,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AA+CO;AAKL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AAEE,EAAA;AAEJ,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAqCO;AACD,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACD,EAAA;AACH;AAgBM;AAGN;AACE,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACM,EAAA;AACJ,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAqBO;AACL,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AAAmC,IAAA;AAEnC,EAAA;AAEA,EAAA;AACA,EAAA;AACA,EAAA;AAEA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACE,QAAA;AAAmB,2BAAA;AACM,2BAAA;AACD,QAAA;AAExB,QAAA;AACA,QAAA;AACE,UAAA;AACA,UAAA;AAAW,QAAA;AAEf,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACG,IAAA;AACH,IAAA;AACF,EAAA;AAEA,EAAA;AACI,EAAA;AACJ,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AAEA,EAAA;AACI,EAAA;AACJ,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AAEA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACD,EAAA;AACH;AD5UO;AACA;AExQA;AAGL,EAAA;AACA,EAAA;AACA,EAAA;AAIA,EAAA;AACA,EAAA;AACA,EAAA;AACI,EAAA;AACA,EAAA;AACA,EAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACF;AFqQO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/libcantus/libcantus/dist/chunk-R7B5N2JK.cjs","sourcesContent":[null,"import { InvalidInputError } from '../../core/errors/index.js';\nimport { pitchClassOf as pitchClass } from '../../core/pitch/index.js';\nimport {\n  assertArray,\n  assertGenerationBudget,\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';\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 */\nconst ALIASED_SCALE_NAMES = new Set(['major', 'naturalMinor']);\n\n/** Number of tones in a heptatonic (seven-note) scale. */\nconst HEPTATONIC_SIZE = 7;\n\n/**\n * 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 */\nconst 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. */\nconst 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 * An ordinary dominant seventh may use altered colors while retaining its\n * perfect fifth in the voicing; the `7alt` quality makes that alteration\n * explicit, but lead sheets commonly write the shorter `7` here.\n */\nfunction isAlteredDominant(chord: Chord, scaleName: string): boolean {\n  return chord.quality === 'dom7' && scaleName === 'altered';\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: { name: string; extra: number; size: number; avoid: number }[] = [];\n  const seenMasks = new Set<number>();\n  for (const name of Object.keys(NAMED_SCALES)) {\n    if (name === 'chromatic' || ALIASED_SCALE_NAMES.has(name)) {\n      continue;\n    }\n    const mask = 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: avoidNotes(data, name).length,\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.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 in full — 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.\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 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  // 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 melodic = asked.use === 'melodic';\n  const semitoneAboveRoot = pitchClass(rootPc + 1);\n  const avoid: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {\n      continue;\n    }\n    if (melodic && pc !== semitoneAboveRoot) {\n      continue;\n    }\n    if (!alteredDominant && (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, each of them sits a semitone above a chord\n * tone and is an avoid note. Heard as the dominant of a minor key they are the\n * key's own tones, and standard practice, so the function the chord serves is\n * what decides.\n */\nconst 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 flat ninth, sharp ninth and\n * flat thirteenth, which read on their own would each be an avoid note. 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 b13 and b9 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 */\nconst RANK_PENALTY = 0.01;\n\n/** Build the pitch-class set of a named scale rooted on `rootPc`. */\nfunction scalePitchClassSet(name: string, rootPc: number): Set<number> {\n  const mask = 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"]}
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-PM4XJE2Y.cjs","../src/theory/chordscale/index.ts","../src/theory/harmony/index.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACaA,SAAS,qBAAA,CAAsB,IAAA,EAAsB,MAAA,EAAQ,OAAA,EAAiB;AAC5E,EAAA,MAAM,UAAA,EAAY,gDAAA,IAAqB,CAAA;AACvC,EAAA,GAAA,CAAI,UAAA,IAAc,KAAA,EAAA,GAAa,CAAC,MAAA,CAAO,MAAA,CAAO,8BAAA,EAAc,SAAS,CAAA,EAAG;AACtE,IAAA,MAAM,IAAI,wCAAA;AAAA,MACR,CAAA,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACM,EAAA;AACJ,EAAA;AACE,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACA,EAAA;AACF;AAYO;AAOL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAkBM;AAGA;AASA;AACJ,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACF;AAGM;AACC,EAAA;AACL,EAAA;AAAgB;AAAA;AAAA;AAAA;AAKhB,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACA,EAAA;AACF;AAGA;AACE,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACF;AAOA;AACE,EAAA;AACF;AA6CO;AACL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AAAY,QAAA;AACV,QAAA;AACuB,QAAA;AACvB,QAAA;AAED,MAAA;AACH,IAAA;AACF,EAAA;AACI,EAAA;AAGF,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AAKA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACD,EAAA;AACD,EAAA;AACF;AAwDO;AAKL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AAKA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAWM;AAGN;AAKM,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AA+CO;AAKL,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACK,EAAA;AACH,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AAEE,EAAA;AAEJ,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAqCO;AACD,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACD,EAAA;AACH;AAgBM;AAGN;AACE,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAGA;AACM,EAAA;AACJ,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACF;AAqBO;AACL,EAAA;AACA,EAAA;AACI,EAAA;AACF,IAAA;AACF,EAAA;AACA,EAAA;AACA,EAAA;AAAmC,IAAA;AAEnC,EAAA;AAEA,EAAA;AACA,EAAA;AACA,EAAA;AAEA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACE,QAAA;AAAmB,2BAAA;AACM,2BAAA;AACD,QAAA;AAExB,QAAA;AACA,QAAA;AACE,UAAA;AACA,UAAA;AAAW,QAAA;AAEf,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACG,IAAA;AACH,IAAA;AACF,EAAA;AAEA,EAAA;AACI,EAAA;AACJ,EAAA;AACE,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AAEA,EAAA;AACI,EAAA;AACJ,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AAEA,EAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACD,EAAA;AACH;AD5UO;AACA;AExQA;AAGL,EAAA;AACA,EAAA;AACA,EAAA;AAIA,EAAA;AACA,EAAA;AACA,EAAA;AACI,EAAA;AACA,EAAA;AACA,EAAA;AACF,IAAA;AACA,IAAA;AACF,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AACE,IAAA;AACA,IAAA;AACF,EAAA;AACA,EAAA;AACF;AFqQO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/libcantus/libcantus/dist/chunk-PM4XJE2Y.cjs","sourcesContent":[null,"import { InvalidInputError } from '../../core/errors/index.js';\nimport { pitchClassOf as pitchClass } from '../../core/pitch/index.js';\nimport {\n  assertArray,\n  assertGenerationBudget,\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';\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 */\nconst ALIASED_SCALE_NAMES = new Set(['major', 'naturalMinor']);\n\n/** Number of tones in a heptatonic (seven-note) scale. */\nconst HEPTATONIC_SIZE = 7;\n\n/**\n * 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 */\nconst 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. */\nconst 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 * An ordinary dominant seventh may use altered colors while retaining its\n * perfect fifth in the voicing; the `7alt` quality makes that alteration\n * explicit, but lead sheets commonly write the shorter `7` here.\n */\nfunction isAlteredDominant(chord: Chord, scaleName: string): boolean {\n  return chord.quality === 'dom7' && scaleName === 'altered';\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: { name: string; extra: number; size: number; avoid: number }[] = [];\n  const seenMasks = new Set<number>();\n  for (const name of Object.keys(NAMED_SCALES)) {\n    if (name === 'chromatic' || ALIASED_SCALE_NAMES.has(name)) {\n      continue;\n    }\n    const mask = 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: avoidNotes(data, name).length,\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.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 in full — 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.\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 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  // 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 melodic = asked.use === 'melodic';\n  const semitoneAboveRoot = pitchClass(rootPc + 1);\n  const avoid: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {\n      continue;\n    }\n    if (melodic && pc !== semitoneAboveRoot) {\n      continue;\n    }\n    if (!alteredDominant && (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, each of them sits a semitone above a chord\n * tone and is an avoid note. Heard as the dominant of a minor key they are the\n * key's own tones, and standard practice, so the function the chord serves is\n * what decides.\n */\nconst 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 flat ninth, sharp ninth and\n * flat thirteenth, which read on their own would each be an avoid note. 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 b13 and b9 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 */\nconst RANK_PENALTY = 0.01;\n\n/** Build the pitch-class set of a named scale rooted on `rootPc`. */\nfunction scalePitchClassSet(name: string, rootPc: number): Set<number> {\n  const mask = 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"]}

package/dist/{chunk-7GOKQJTQ.js → chunk-PUKJP2Z5.js}

@@ -3,7 +3,7 @@ import {
   assertFiniteNumber,
   assertNoteEvents,
   assertOptions
-} from "./chunk-PQL7E5F6.js";
+} from "./chunk-AGOVW7U6.js";
 
 // src/core/event-index/index.ts
 function upperBound(values, beat) {
@@ -142,4 +142,4 @@ export {
   sortedNoteEvents,
   createNoteEventIndex
 };
-//# sourceMappingURL=chunk-7GOKQJTQ.js.map
+//# sourceMappingURL=chunk-PUKJP2Z5.js.map

package/dist/{chunk-R5VUXQMP.js → chunk-Q6LFSAKV.js}

@@ -8,7 +8,7 @@ import {
   isDiatonic,
   isMinorKey,
   parallelKey
-} from "./chunk-VLE5R7PF.js";
+} from "./chunk-H2KJHBW4.js";
 import {
   LIMBS,
   canSound,
@@ -19,14 +19,14 @@ import {
   instrumentRange,
   resolveAlgorithmVersion,
   toStringedProfile
-} from "./chunk-X6RJAHII.js";
+} from "./chunk-7KG3RTYS.js";
 import {
   createNoteEventIndex
-} from "./chunk-7GOKQJTQ.js";
+} from "./chunk-PUKJP2Z5.js";
 import {
   chordScales,
   roleOf
-} from "./chunk-H66ARFU5.js";
+} from "./chunk-NB25P3EH.js";
 import {
   chordPitchClasses,
   chordQualities,
@@ -58,7 +58,7 @@ import {
   toChordData,
   toKeyScale,
   tonicizableDegrees
-} from "./chunk-FPBZFNCD.js";
+} from "./chunk-RFIBF2RR.js";
 import {
   ARTICULATIONS,
   BEAT_EPS,
@@ -95,7 +95,7 @@ import {
   toMeterData,
   toSpelledInterval,
   transposeNote
-} from "./chunk-PQL7E5F6.js";
+} from "./chunk-AGOVW7U6.js";
 
 // src/generate/context/draw.ts
 var DRAW_METHODS = ["at", "prob", "range", "float"];
@@ -5618,4 +5618,4 @@ export {
   generateRhythm,
   rhythmDensity
 };
-//# sourceMappingURL=chunk-R5VUXQMP.js.map
+//# sourceMappingURL=chunk-Q6LFSAKV.js.map

package/dist/{chunk-FPBZFNCD.js → chunk-RFIBF2RR.js}

@@ -33,7 +33,7 @@ import {
   tryParseKeyName,
   tryParseNote,
   unwrapParse
-} from "./chunk-PQL7E5F6.js";
+} from "./chunk-AGOVW7U6.js";
 
 // src/theory/scale/masks.ts
 function maskFromOffsets(offsets) {
@@ -2514,7 +2514,8 @@ function stepResolution(pitch, chord) {
 function evaluateSafety(q, opts = {}) {
   assertSafetyContext(q);
   assertMidiPitch(q.candidatePitch, "candidatePitch");
-  return evaluateInternal(q, assertOptions(opts, "opts").suggestions ?? true);
+  const options = assertOptions(opts, "opts");
+  return evaluateInternal(q, options.suggestions ?? true, options.partners ?? false);
 }
 function assertSafetyContext(q) {
   assertRecord(q, "safety query");
@@ -2538,7 +2539,7 @@ function assertSafetyContext(q) {
     }
   }
 }
-function evaluateInternal(q, collectSuggestions) {
+function evaluateInternal(q, collectSuggestions, collectPartners) {
   let reasons = 0;
   let level = 0 /* Safe */;
   let resolveTo;
@@ -2609,41 +2610,58 @@ function evaluateInternal(q, collectSuggestions) {
       reasons |= 512 /* MajorSeventh */;
     }
   }
+  let bass = pitch;
+  let top = pitch;
+  for (const ov of q.otherVoices) {
+    bass = Math.min(bass, ov.pitch);
+    top = Math.max(top, ov.pitch);
+  }
+  const pairReasons = collectPartners ? new Array(q.otherVoices.length).fill(0) : void 0;
+  const flagPair = (index, flag) => {
+    reasons |= flag;
+    if (pairReasons !== void 0) {
+      pairReasons[index] = (pairReasons[index] ?? 0) | flag;
+    }
+  };
   if (q.strongBeat) {
-    const twoVoice = q.otherVoices.length === 1;
     const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
+    for (const [index, ov] of q.otherVoices.entries()) {
+      const againstBass = pitch === bass || ov.pitch === bass;
+      if (!createsVerticalDissonance(pitch, ov.pitch, againstBass)) {
         continue;
       }
       if (chord && isStructuralChordDissonance(pitch, ov.pitch, chord)) {
         continue;
       }
-      reasons |= 1024 /* VerticalDissonance */;
+      if (chord && q.profile === "pop" && pitchClassOf(Math.abs(pitch - ov.pitch)) === 5 && isChordMember(pitch, chord) && isChordMember(ov.pitch, chord)) {
+        continue;
+      }
+      flagPair(index, 1024 /* VerticalDissonance */);
       raise(2 /* Dissonant */);
-      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
-        reasons |= 16384 /* Suspension */;
+      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, againstBass)) {
+        flagPair(index, 16384 /* Suspension */);
       }
     }
   }
   if (q.prevPitch !== void 0) {
     const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
+    for (const [index, ov] of q.otherVoices.entries()) {
       if (ov.prevPitch === void 0) {
         continue;
       }
       if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 2048 /* ParallelPerfect */;
+        flagPair(index, 2048 /* ParallelPerfect */);
         raise(parallelSeverity);
       }
-      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 4096 /* HiddenParallel */;
+      const outerPair = pitch === top && ov.pitch === bass || pitch === bass && ov.pitch === top;
+      if (outerPair && createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
+        flagPair(index, 4096 /* HiddenParallel */);
         raise(parallelSeverity);
       }
       const crossedNow = pitch - ov.pitch;
       const crossedPrev = prev - ov.prevPitch;
       if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
-        reasons |= 8192 /* VoiceCrossing */;
+        flagPair(index, 8192 /* VoiceCrossing */);
         raise(parallelSeverity);
       }
     }
@@ -2659,6 +2677,17 @@ function evaluateInternal(q, collectSuggestions) {
       result.suggestions = suggestions;
     }
   }
+  if (pairReasons !== void 0) {
+    const partners = [];
+    pairReasons.forEach((pair, index) => {
+      if (pair !== 0) {
+        partners.push({ index, reasons: pair });
+      }
+    });
+    if (partners.length > 0) {
+      result.partners = partners;
+    }
+  }
   return result;
 }
 function findSafeNearby(q, candidate) {
@@ -2668,7 +2697,7 @@ function findSafeNearby(q, candidate) {
       if (p < 0 || p > 127) {
         continue;
       }
-      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
+      if (evaluateInternal({ ...q, candidatePitch: p }, false, false).safety === 0 /* Safe */) {
         out.push(p);
         if (out.length >= MAX_SUGGESTIONS) {
           return out;
@@ -2692,7 +2721,7 @@ var REASON_TEXT = [
   [2048 /* ParallelPerfect */, "Parallel perfect interval with another voice"],
   [4096 /* HiddenParallel */, "Hidden perfect interval by similar motion"],
   [8192 /* VoiceCrossing */, "Crosses another voice"],
-  [128 /* LargeLeap */, "Leap wider than the profile allows"],
+  [128 /* LargeLeap */, "Forbidden melodic leap \u2014 a seventh or wider than an octave"],
   [32768 /* NeedsResolution */, "Dissonance awaiting a stepwise resolution"],
   [2 /* Tension */, "Chord tension"],
   [8 /* ScaleTone */, "Scale tone, not in the chord"],
@@ -2737,7 +2766,7 @@ function enumerateSafePitches(q, pitchLow, pitchHigh) {
   const low = Math.max(pitchLow, q.vocalLow ?? pitchLow);
   const high = Math.min(pitchHigh, q.vocalHigh ?? pitchHigh);
   for (let pitch = high; pitch >= low; pitch -= 1) {
-    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
+    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false, false);
     if (result.safety === 2 /* Dissonant */) {
       continue;
     }
@@ -3794,4 +3823,4 @@ export {
   isDescendingStep,
   isFrustratedLeadingTone
 };
-//# sourceMappingURL=chunk-FPBZFNCD.js.map
+//# sourceMappingURL=chunk-RFIBF2RR.js.map