@libraz/libcantus 1.0.1 → 1.2.0

package/dist/{chunk-H3VORETI.js → chunk-M5RYMAFI.js}

@@ -1,5 +1,6 @@
 import {
-  NAMED_SCALES,
+  appliedDominantTarget,
+  assertChord,
   chordPitchClasses,
   chordQualities,
   chordToneRole,
@@ -11,29 +12,39 @@ import {
   createsVoiceOverlap,
   exceedsSpacing,
   formatChordSymbol,
+  hasDominantSonority,
   isAugmentedMelodicInterval,
+  isDescendingStep,
   isForbiddenMelodicLeap,
+  isFrustratedLeadingTone,
+  isFunctioningLeadingTone,
   isLeadingToneResolution,
+  isNeapolitanChordOf,
+  leadingTonePcOf,
   makeChord,
-  namedScaleMask,
   noteNames,
-  requireScaleMask,
+  resolveKey,
   scaleTonesInDegreeOrder,
+  seventhPcOf,
   simpleIntervalNumber,
   spellChord,
   spellPitch,
+  spellPitchClass,
   spellScale,
-  spelledKeyOf,
   toChordData,
   toKeyScale
-} from "./chunk-INHVXP6Z.js";
+} from "./chunk-RFIBF2RR.js";
 import {
+  BEAT_EPS,
   InvalidInputError,
   NoSolutionError,
+  assertArray,
   assertFiniteNumber,
   assertGenerationBudget,
   assertInteger,
+  assertOptions,
   assertPositiveInt,
+  describeRejected,
   diatonicLetterOf,
   formatNote,
   noteToMidi,
@@ -44,7 +55,7 @@ import {
   toNoteData,
   toSpelledInterval,
   transposeByInterval
-} from "./chunk-VTI6FOLB.js";
+} from "./chunk-AGOVW7U6.js";
 
 // src/theory/transposition/index.ts
 var TRANSPOSING_INSTRUMENTS = Object.freeze({
@@ -74,12 +85,16 @@ var TRANSPOSING_INSTRUMENTS = Object.freeze({
   contrabassoon: "-P8",
   guitar: "-P8"
 });
+var PROFILE_NAME_ALIASES = Object.freeze({
+  "guitar (drop D)": "guitar"
+});
 function instrumentTransposition(instrument) {
   if (typeof instrument !== "string") {
     return toSpelledInterval(instrument);
   }
-  if (Object.hasOwn(TRANSPOSING_INSTRUMENTS, instrument)) {
-    return parseInterval(TRANSPOSING_INSTRUMENTS[instrument]);
+  const name = Object.hasOwn(PROFILE_NAME_ALIASES, instrument) ? PROFILE_NAME_ALIASES[instrument] : instrument;
+  if (Object.hasOwn(TRANSPOSING_INSTRUMENTS, name)) {
+    return parseInterval(TRANSPOSING_INSTRUMENTS[name]);
   }
   try {
     return parseInterval(instrument);
@@ -93,16 +108,13 @@ function instrumentTransposition(instrument) {
   }
 }
 function reversedInterval(step) {
-  const reversed = {
+  return {
     number: step.number,
     quality: step.quality,
     // Negating a zero span yields -0, which compares unequal to 0 under Object.is.
-    semitones: step.semitones === 0 ? 0 : -step.semitones
+    semitones: step.semitones === 0 ? 0 : -step.semitones,
+    descending: !step.descending
   };
-  if (!(step.descending ?? step.semitones < 0)) {
-    reversed.descending = true;
-  }
-  return reversed;
 }
 function toSoundingPitch(note, instrument) {
   return transposeByInterval(toNoteData(note), instrumentTransposition(instrument));
@@ -114,311 +126,6 @@ function toWrittenPitch(note, instrument) {
   );
 }
 
-// src/theory/chordscale/index.ts
-function popcount12(mask) {
-  let count = 0;
-  for (let n = 0; n < 12; n += 1) {
-    count += mask >> n & 1;
-  }
-  return count;
-}
-function maskHasPitchClass(mask, scaleRootPc, pc) {
-  const offset = pitchClassOf(pc - scaleRootPc);
-  return (mask >> offset & 1) === 1;
-}
-function scaleMatchesChord(chordPcs, scaleMask, scaleRootPc) {
-  for (const pc of chordPcs) {
-    if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {
-      return false;
-    }
-  }
-  return true;
-}
-var ALIASED_SCALE_NAMES = /* @__PURE__ */ new Set(["major", "naturalMinor"]);
-var HEPTATONIC_SIZE = 7;
-var SCALE_PREFERENCE = [
-  "ionian",
-  "major",
-  "mixolydian",
-  "dorian",
-  "lydian",
-  "aeolian",
-  "naturalMinor",
-  "phrygian",
-  "locrian"
-];
-var IDIOMATIC_SCALES = {
-  aug: ["wholeTone"],
-  m7b5: ["locrian"],
-  // The diminished scale played over a diminished seventh is the whole-half
-  // octatonic. Its half-whole rotation belongs to the dominant it colours: over
-  // a diminished seventh every one of its non-chord tones lands a semitone
-  // above a chord tone, so it offers no tension at all.
-  dim7: ["octatonicWholeHalf"],
-  minMaj7: ["melodicMinor"]
-};
-function conventionalRank(name) {
-  const index = SCALE_PREFERENCE.indexOf(name);
-  return index < 0 ? SCALE_PREFERENCE.length : index;
-}
-function idiomaticRank(chord, name) {
-  const choices = IDIOMATIC_SCALES[chord.quality];
-  if (choices === void 0) {
-    return 0;
-  }
-  const index = choices.indexOf(name);
-  return index < 0 ? choices.length + 1 : index;
-}
-function isAlteredDominant(chord, scaleName) {
-  return chord.quality === "dom7" && scaleName === "altered";
-}
-function chordScales(chord) {
-  const data = toChordData(chord);
-  const chordPcs = chordPitchClasses(data);
-  const rootPc = pitchClassOf(data.rootPc);
-  const ranked = [];
-  const seenMasks = /* @__PURE__ */ new Set();
-  for (const name of Object.keys(NAMED_SCALES)) {
-    if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
-      continue;
-    }
-    const mask = namedScaleMask(name);
-    if (mask === void 0 || seenMasks.has(mask)) {
-      continue;
-    }
-    seenMasks.add(mask);
-    if (scaleMatchesChord(chordPcs, mask, rootPc) || isAlteredDominant(data, name)) {
-      const size = popcount12(mask);
-      ranked.push({
-        name,
-        extra: size - chordPcs.length,
-        size,
-        avoid: avoidNotes(data, name).length
-      });
-    }
-  }
-  if (ranked.length === 0) {
-    if (NAMED_SCALES.chromatic !== void 0) {
-      return [{ name: "chromatic", rootPc }];
-    }
-    return [];
-  }
-  const preferHeptatonic = chordPcs.length <= 3;
-  ranked.sort((a, b) => {
-    const idiomaticA = idiomaticRank(data, a.name);
-    const idiomaticB = idiomaticRank(data, b.name);
-    if (idiomaticA !== idiomaticB) {
-      return idiomaticA - idiomaticB;
-    }
-    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;
-    }
-    const rankA = conventionalRank(a.name);
-    const rankB = conventionalRank(b.name);
-    if (rankA !== rankB) {
-      return rankA - rankB;
-    }
-    if (a.avoid !== b.avoid) {
-      return a.avoid - b.avoid;
-    }
-    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-  });
-  return ranked.map((entry) => ({ name: entry.name, rootPc }));
-}
-function suspendedTone(chordPcs, rootPc) {
-  const sounds = (semitones) => chordPcs.includes(pitchClassOf(rootPc + semitones));
-  if (sounds(3) || sounds(4)) {
-    return void 0;
-  }
-  if (sounds(5)) {
-    return pitchClassOf(rootPc + 5);
-  }
-  if (sounds(2)) {
-    return pitchClassOf(rootPc + 2);
-  }
-  return void 0;
-}
-function avoidNotes(chord, scaleName, opts = {}) {
-  const mask = requireScaleMask(scaleName);
-  const data = toChordData(chord);
-  const rootPc = pitchClassOf(data.rootPc);
-  const chordPcs = chordPitchClasses(data);
-  const alteredDominant = isAlteredDominant(data, scaleName);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const suspended = suspendedTone(chordPcs, rootPc);
-  const displacedThird = suspended === void 0 ? void 0 : pitchClassOf(suspended - 1);
-  const melodic = opts.use === "melodic";
-  const semitoneAboveRoot = pitchClassOf(rootPc + 1);
-  const avoid = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
-      continue;
-    }
-    if (melodic && pc !== semitoneAboveRoot) {
-      continue;
-    }
-    if (!alteredDominant && (chordSet.has(pitchClassOf(pc - 1)) || pc === displacedThird)) {
-      avoid.push(pc);
-    }
-  }
-  return avoid.sort((a, b) => a - b);
-}
-var MINOR_RESOLUTION_TENSIONS = [1, 3, 8];
-function resolvesToMinorTonic(chord, chordPcs, target) {
-  if (target === void 0) {
-    return false;
-  }
-  const rootPc = pitchClassOf(chord.rootPc);
-  const sounds = (semitones) => chordPcs.includes(pitchClassOf(rootPc + semitones));
-  if (!sounds(4) || !sounds(10)) {
-    return false;
-  }
-  const targetRootPc = pitchClassOf(target.rootPc);
-  if (targetRootPc !== pitchClassOf(rootPc + 5)) {
-    return false;
-  }
-  return chordPitchClasses(target).includes(pitchClassOf(targetRootPc + 3));
-}
-function availableTensions(chord, scaleName, opts = {}) {
-  const mask = requireScaleMask(scaleName);
-  const data = toChordData(chord);
-  const rootPc = pitchClassOf(data.rootPc);
-  const chordPcs = chordPitchClasses(data);
-  const alteredDominant = isAlteredDominant(data, scaleName);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoidSet = alteredDominant ? /* @__PURE__ */ new Set() : new Set(avoidNotes(data, scaleName));
-  const functional = resolvesToMinorTonic(
-    data,
-    chordPcs,
-    opts.resolvesTo === void 0 ? void 0 : toChordData(opts.resolvesTo)
-  ) ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => pitchClassOf(rootPc + semitones))) : void 0;
-  const tensions = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
-      continue;
-    }
-    if (avoidSet.has(pc) && functional?.has(pc) !== true) {
-      continue;
-    }
-    tensions.push(pc);
-  }
-  return tensions.sort((a, b) => a - b);
-}
-function chordScaleReport(chord, limit) {
-  if (limit !== void 0) {
-    assertPositiveInt(limit, "chord-scale report limit");
-  }
-  const data = toChordData(chord);
-  const matches = chordScales(data);
-  const chosen = limit === void 0 ? matches : matches.slice(0, limit);
-  return chosen.map((match) => {
-    const harmonic = avoidNotes(data, match.name);
-    const melodic = new Set(avoidNotes(data, match.name, { use: "melodic" }));
-    return {
-      name: match.name,
-      rootPc: match.rootPc,
-      avoid: harmonic.filter((pc) => melodic.has(pc)),
-      passing: harmonic.filter((pc) => !melodic.has(pc)),
-      tensions: availableTensions(data, match.name)
-    };
-  });
-}
-var RANK_PENALTY = 0.01;
-function scalePitchClassSet(name, rootPc) {
-  const mask = namedScaleMask(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(pitchClassOf(rootPc + n));
-    }
-  }
-  return pcs;
-}
-function symmetricDifferenceSize(a, b) {
-  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;
-}
-function scalesForChanges(chords) {
-  assertGenerationBudget(chords.length, "chord-scale changes");
-  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 = [first.map((_, j) => j * RANK_PENALTY)];
-  const back = [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 = [];
-    const stageBack = [];
-    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] ?? /* @__PURE__ */ new Set(),
-          curSets[j] ?? /* @__PURE__ */ 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 = 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 };
-  });
-}
-
 // src/theory/figured-bass/index.ts
 var MIN_FIGURE_NUMBER = 2;
 var MAX_FIGURE_NUMBER = 9;
@@ -433,7 +140,7 @@ var DOUBLE_ACCIDENTALS = {
 var SINGLE_ACCIDENTALS = {
   "#": "sharp",
   "\u266F": "sharp",
-  "+": "sharp",
+  "+": "raised",
   b: "flat",
   "\u266D": "flat",
   n: "natural",
@@ -441,31 +148,28 @@ var SINGLE_ACCIDENTALS = {
 };
 var FIGURE_SEPARATORS = /* @__PURE__ */ new Set([" ", "	", ",", "/"]);
 var MOTION_MARKS = /* @__PURE__ */ new Set(["-", "\u2013"]);
-var ACCIDENTAL_GLYPHS = {
-  1: "#",
-  2: "##",
-  "-1": "b",
-  "-2": "bb"
-};
+var PRINTED_ACCIDENTALS = [
+  ["natural", "n", 0],
+  ["sharp", "#", 1],
+  ["doubleSharp", "##", 2],
+  ["flat", "b", -1],
+  ["doubleFlat", "bb", -2]
+];
+var PRINTED_ALTERS = new Map(
+  PRINTED_ACCIDENTALS.map(([accidental, , alter]) => [accidental, alter])
+);
+var ACCIDENTAL_GLYPHS = new Map(
+  PRINTED_ACCIDENTALS.map(([, glyph, alter]) => [alter, glyph])
+);
 function invalidFigures(figures, detail) {
-  return new InvalidInputError(`figured bass ${JSON.stringify(figures)} ${detail}`);
+  return new InvalidInputError(`figured bass ${describeRejected(figures)} ${detail}`);
 }
 function alteredBy(diatonicAlter, accidental) {
-  switch (accidental) {
-    case "sharp":
-      return diatonicAlter + 1;
-    case "doubleSharp":
-      return diatonicAlter + 2;
-    case "flat":
-      return diatonicAlter - 1;
-    case "doubleFlat":
-      return diatonicAlter - 2;
-    // A natural sign names the natural note, whatever the key would have given.
-    case "natural":
-      return 0;
-    default:
-      return diatonicAlter;
+  const printed = PRINTED_ALTERS.get(accidental);
+  if (printed !== void 0) {
+    return printed;
   }
+  return accidental === "raised" ? diatonicAlter + 1 : diatonicAlter;
 }
 function readFigure(text, start) {
   let index = start;
@@ -575,12 +279,12 @@ function tertianQualityIndex() {
 }
 var TERTIAN_QUALITIES = tertianQualityIndex();
 function keyLetterAlters(key) {
-  const size = scaleTonesInDegreeOrder(key).length;
+  const size = scaleTonesInDegreeOrder(key.scale).length;
   if (size !== 7) {
     throw new InvalidInputError(`figured bass requires a heptatonic key (received ${size} tones)`);
   }
   const alters = [];
-  for (const note of spellScale(spelledKeyOf(key).tonic, key)) {
+  for (const note of spellScale(key.tonic, key.scale)) {
     alters[diatonicLetterOf(note.letter)] = note.alter;
   }
   return alters;
@@ -610,7 +314,7 @@ function realizeSonority(bass, resolved, text, alters) {
     const tone = tones.find((candidate) => diatonicLetterOf(candidate.letter - root.letter) === step * 2);
     if (tone === void 0) {
       throw new NoSolutionError(
-        `figured bass ${JSON.stringify(text)} sounds ${noteNames(tones).join(" ")}, which does not stack in thirds`
+        `figured bass ${describeRejected(text)} sounds ${noteNames(tones).join(" ")}, which does not stack in thirds`
       );
     }
     stack.push(pitchClassOf(noteToPitchClass(tone) - rootPc));
@@ -618,7 +322,7 @@ function realizeSonority(bass, resolved, text, alters) {
   const quality = TERTIAN_QUALITIES.get(stack.join(","));
   if (quality === void 0) {
     throw new NoSolutionError(
-      `figured bass ${JSON.stringify(text)} sounds ${noteNames(tones).join(" ")}, which no chord quality names`
+      `figured bass ${describeRejected(text)} sounds ${noteNames(tones).join(" ")}, which no chord quality names`
     );
   }
   const chord = makeChord(rootPc, quality, noteToPitchClass(bass));
@@ -631,8 +335,7 @@ function figuredBassRealization(bass, figures, key) {
     throw new InvalidInputError(`figured bass must be a string; received ${typeof figures}`);
   }
   const bassData = toNoteData(bass);
-  const scale = toKeyScale(key);
-  const alters = keyLetterAlters(scale);
+  const alters = keyLetterAlters(resolveKey(key));
   noteToPitchClass(bassData);
   const bassNote = bareNote(bassData);
   const text = figures.trim();
@@ -655,9 +358,9 @@ function realizeFiguredBass(bass, figures, key) {
 }
 function figuredBassOf(chord, key) {
   const data = toChordData(chord);
-  const scale = toKeyScale(key);
-  const alters = keyLetterAlters(scale);
-  const tones = spellChord(data, spelledKeyOf(scale).tonic, scale);
+  const resolved = resolveKey(key);
+  const alters = keyLetterAlters(resolved);
+  const tones = spellChord(data, resolved.tonic, resolved.scale);
   const bassPc = pitchClassOf(data.bassPc ?? data.rootPc);
   const bass = tones.find((tone) => noteToPitchClass(tone) === bassPc);
   if (bass === void 0) {
@@ -679,20 +382,17 @@ function figuredBassOf(chord, key) {
   }
   const accidentals = /* @__PURE__ */ new Map();
   for (const [number, tone] of written) {
-    const alteration = tone.alter - (alters[diatonicLetterOf(tone.letter)] ?? 0);
-    if (alteration === 0) {
+    if (tone.alter === (alters[diatonicLetterOf(tone.letter)] ?? 0)) {
       continue;
     }
-    const glyph = ACCIDENTAL_GLYPHS[alteration];
+    const glyph = ACCIDENTAL_GLYPHS.get(tone.alter);
     if (glyph === void 0) {
-      throw new NoSolutionError(
-        `no figure names an interval altered by ${alteration} semitones from the key`
-      );
+      throw new NoSolutionError(`no accidental writes a note altered by ${tone.alter} semitones`);
     }
     accidentals.set(number, glyph);
   }
   const figures = [.../* @__PURE__ */ new Set([...digits, ...accidentals.keys()])].sort((a, b) => b - a).map((number) => `${accidentals.get(number) ?? ""}${number}`).join("");
-  assertRealizesAs(bass, figures, scale, tones);
+  assertRealizesAs(bass, figures, resolved, tones);
   return figures;
 }
 function pitchClassesOf(notes) {
@@ -700,7 +400,7 @@ function pitchClassesOf(notes) {
 }
 function assertRealizesAs(bass, figures, key, tones) {
   const noFigures = (detail) => new NoSolutionError(
-    `no figured bass names ${noteNames(tones).join(" ")} over ${noteNames([bass])[0]}: the figures ${JSON.stringify(figures)} ${detail}`
+    `no figured bass names ${noteNames(tones).join(" ")} over ${noteNames([bass])[0]}: the figures ${describeRejected(figures)} ${detail}`
   );
   let realized;
   try {
@@ -715,29 +415,112 @@ function assertRealizesAs(bass, figures, key, tones) {
   }
 }
 
-// src/theory/voicing/tendency.ts
-function leadingTonePcOf(key) {
-  return pitchClassOf(key.rootPc - 1);
+// src/theory/partwriting/cross-relation.ts
+function resolvesAsAppliedDominant(chord, next, key) {
+  if (next === void 0 || !hasDominantSonority(chord)) {
+    return false;
+  }
+  const target = appliedDominantTarget(chord.rootPc + 5, key);
+  return target !== null && pitchClassOf(next.rootPc) === target.rootPc;
 }
-var LEADING_TONE_QUALITIES = /* @__PURE__ */ new Set(["dim", "dim7", "m7b5"]);
-function isFunctioningLeadingTone(chord, key) {
-  const role = chordToneRole(leadingTonePcOf(key), chord);
-  if (role === "third") {
-    return pitchClassOf(chord.rootPc) === pitchClassOf(key.rootPc + 7);
+function soundsAugmentedSixth(moment, key) {
+  const bass = moment.notes[0];
+  if (bass === void 0 || noteToPitchClass(bass) !== pitchClassOf(key.rootPc + 8)) {
+    return false;
   }
-  if (role === "root") {
-    return LEADING_TONE_QUALITIES.has(chord.quality);
+  return moment.notes.some((note, voice) => {
+    if (voice === 0) {
+      return false;
+    }
+    const interval = spelledInterval(bass, note);
+    return (interval.number - 1) % 7 + 1 === 6 && pitchClassOf(interval.semitones) === 10;
+  });
+}
+function isChromaticHarmony(moment, next, key) {
+  return resolvesAsAppliedDominant(moment.chord, next, key) || isNeapolitanChordOf(moment.chord, key) || soundsAugmentedSixth(moment, key);
+}
+function approachedByStep(before, moment, voice) {
+  const earlier = before?.[voice];
+  const later = moment[voice];
+  if (earlier === void 0 || later === void 0) {
+    return false;
   }
-  return false;
+  return spelledInterval(earlier, later).number === 2;
+}
+function isOuterVoice(voice, notes) {
+  return voice === 0 || voice === notes.length - 1;
 }
-function seventhPcOf(chord) {
-  for (const interval of chord.intervals) {
-    const pc = pitchClassOf(chord.rootPc + interval);
-    if (chordToneRole(pc, chord) === "seventh") {
-      return pc;
+function crossRelations(from, to, key, context = {}) {
+  const found = [];
+  const chromatic = isChromaticHarmony(from, to.chord, key) || isChromaticHarmony(to, context.after, key);
+  if (chromatic) {
+    return found;
+  }
+  const reported = /* @__PURE__ */ new Set();
+  for (let first = 0; first < from.notes.length; first += 1) {
+    for (let second = 0; second < to.notes.length; second += 1) {
+      if (first === second) {
+        continue;
+      }
+      const earlier = from.notes[first];
+      const later = to.notes[second];
+      if (earlier === void 0 || later === void 0) {
+        continue;
+      }
+      const letter = diatonicLetterOf(earlier.letter);
+      if (letter !== diatonicLetterOf(later.letter) || earlier.alter === later.alter) {
+        continue;
+      }
+      if (approachedByStep(context.before, from.notes, first) || approachedByStep(from.notes, to.notes, second) || !isOuterVoice(first, from.notes) && !isOuterVoice(second, to.notes)) {
+        continue;
+      }
+      const pair = `${letter}:${Math.min(first, second)}:${Math.max(first, second)}`;
+      if (reported.has(pair)) {
+        continue;
+      }
+      reported.add(pair);
+      found.push({ earlierVoice: first, laterVoice: second, earlier, later });
     }
   }
-  return void 0;
+  return found;
+}
+
+// src/theory/voicing/tendency.ts
+function spellingTable(keyLike, chord) {
+  const { tonic, scale: key } = resolveKey(keyLike);
+  const notes = [];
+  const bases = [];
+  for (let pc = 0; pc < 12; pc += 1) {
+    const note = chord === void 0 ? spellPitchClass(pc, tonic, key) : spellPitchClass(pc, tonic, key, { chord });
+    notes.push(note);
+    bases.push(noteToMidi({ letter: note.letter, alter: note.alter, octave: 0 }));
+  }
+  return { notes, bases };
+}
+function spelledAt(table, pitch) {
+  const pc = pitchClassOf(pitch);
+  const note = table.notes[pc];
+  const base = table.bases[pc];
+  if (note === void 0 || base === void 0) {
+    return void 0;
+  }
+  return { letter: note.letter, alter: note.alter, octave: (pitch - base) / 12 };
+}
+function movesByAugmentedInterval(from, fromPitch, to, toPitch) {
+  const earlier = spelledAt(from, fromPitch);
+  const later = spelledAt(to, toPitch);
+  if (earlier === void 0 || later === void 0) {
+    return false;
+  }
+  return isAugmentedMelodicInterval(earlier, later);
+}
+function movesByDescendingStep(from, fromPitch, to, toPitch) {
+  const earlier = spelledAt(from, fromPitch);
+  const later = spelledAt(to, toPitch);
+  if (earlier === void 0 || later === void 0) {
+    return false;
+  }
+  return isDescendingStep(spelledInterval(earlier, later));
 }
 
 // src/theory/voicing/internal.ts
@@ -750,8 +533,11 @@ var UNISON_PENALTY = 100;
 var LEADING_TONE_DOUBLING_PENALTY = 200;
 var RESOLUTION_PENALTY = 200;
 var DEFAULT_MAX_CANDIDATES = 4e3;
+var MAX_LOOKAHEAD_PAIRS = 1e6;
 var SEARCH_NODES_PER_CANDIDATE = 16;
-var HIDDEN_PERFECT_PENALTY = 6;
+var HIDDEN_PERFECT_PENALTY = 100;
+var CROSS_RELATION_PENALTY = HIDDEN_PERFECT_PENALTY;
+var AUGMENTED_MELODIC_PENALTY = VIOLATION_PENALTY;
 var INITIAL_CANDIDATE_CAPACITY = 512;
 function createCandidateBuffer() {
   return { pitches: new Int32Array(0), count: 0, voices: 0 };
@@ -881,11 +667,12 @@ function resolutionTables(prevChord, nextChord, key) {
     seventhPc: seventhPcOf(prevChord) ?? -1,
     leadingTonePc: key !== void 0 && isFunctioningLeadingTone(prevChord, key) ? leadingTonePcOf(key) : -1,
     tonicPc: key === void 0 ? -1 : pitchClassOf(key.rootPc),
-    nextHas
+    nextHas,
+    nextChord
   };
 }
-function resolutionViolations(tables, prev, prevOffset, cur, curOffset, voices) {
-  const { seventhPc, leadingTonePc, tonicPc, nextHas } = tables;
+function resolutionViolations(tables, spelling, prev, prevOffset, cur, curOffset, voices) {
+  const { seventhPc, leadingTonePc, tonicPc, nextHas, nextChord } = tables;
   let count = 0;
   for (let voice = 0; voice < voices; voice += 1) {
     const from = prev[prevOffset + voice];
@@ -895,10 +682,12 @@ function resolutionViolations(tables, prev, prevOffset, cur, curOffset, voices)
     }
     const fromPc = pitchClassOf(from);
     const motion = to - from;
-    if (fromPc === seventhPc && nextHas[fromPc] === 0 && motion !== -1 && motion !== -2) {
+    const resolved = spelling === void 0 ? motion === -1 || motion === -2 : movesByDescendingStep(spelling.from, from, spelling.to, to);
+    if (fromPc === seventhPc && nextHas[fromPc] === 0 && !resolved) {
       count += 1;
     }
-    if (fromPc === leadingTonePc && tonicPc >= 0 && nextHas[tonicPc] === 1 && nextHas[fromPc] === 0 && motion !== 1) {
+    const inner = voice > 0 && voice < voices - 1;
+    if (fromPc === leadingTonePc && tonicPc >= 0 && nextHas[tonicPc] === 1 && nextHas[fromPc] === 0 && motion !== 1 && !(inner && isFrustratedLeadingTone(from, to, nextChord))) {
       count += 1;
     }
   }
@@ -914,16 +703,76 @@ function leadingCost(prev, prevOffset, cur, curOffset, voices) {
     }
     total += Math.abs(b - a);
   }
-  if (voices >= 2) {
-    const bassPrev = prev[prevOffset];
-    const bassCur = cur[curOffset];
-    const sopPrev = prev[prevOffset + voices - 1];
-    const sopCur = cur[curOffset + voices - 1];
-    if (bassPrev !== void 0 && bassCur !== void 0 && sopPrev !== void 0 && sopCur !== void 0 && createsHiddenParallelPerfect(bassPrev, bassCur, sopPrev, sopCur)) {
-      total += HIDDEN_PERFECT_PENALTY;
+  return total;
+}
+function createsOuterHiddenPerfect(prev, prevOffset, cur, curOffset, voices) {
+  if (voices < 2) {
+    return false;
+  }
+  const bassPrev = prev[prevOffset];
+  const bassCur = cur[curOffset];
+  const sopPrev = prev[prevOffset + voices - 1];
+  const sopCur = cur[curOffset + voices - 1];
+  if (bassPrev === void 0 || bassCur === void 0 || sopPrev === void 0 || sopCur === void 0) {
+    return false;
+  }
+  return createsHiddenParallelPerfect(sopPrev, sopCur, bassPrev, bassCur);
+}
+function augmentedMelodicCount(spelling, prev, prevOffset, cur, curOffset, voices) {
+  let count = 0;
+  for (let voice = 0; voice < voices; voice += 1) {
+    const from = prev[prevOffset + voice];
+    const to = cur[curOffset + voice];
+    if (from === void 0 || to === void 0) {
+      continue;
+    }
+    if (movesByAugmentedInterval(spelling.from, from, spelling.to, to)) {
+      count += 1;
     }
   }
-  return total;
+  return count;
+}
+function spellRow(table, pitches, offset, voices) {
+  const notes = [];
+  for (let voice = 0; voice < voices; voice += 1) {
+    const pitch = pitches[offset + voice];
+    const note = pitch === void 0 ? void 0 : spelledAt(table, pitch);
+    if (note !== void 0) {
+      notes.push(note);
+    }
+  }
+  return notes;
+}
+function contradictsALetter(spelling, prev, prevOffset, cur, curOffset, voices) {
+  for (let voice = 0; voice < voices; voice += 1) {
+    const from = prev[prevOffset + voice];
+    const earlier = from === void 0 ? void 0 : spelling.from.notes[pitchClassOf(from)];
+    if (earlier === void 0) {
+      continue;
+    }
+    for (let other = 0; other < voices; other += 1) {
+      if (other === voice) {
+        continue;
+      }
+      const to = cur[curOffset + other];
+      const later = to === void 0 ? void 0 : spelling.to.notes[pitchClassOf(to)];
+      if (later !== void 0 && earlier.alter !== later.alter && diatonicLetterOf(earlier.letter) === diatonicLetterOf(later.letter)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function crossRelationCount(spelling, tables, prev, prevOffset, cur, curOffset, voices) {
+  if (!contradictsALetter(spelling, prev, prevOffset, cur, curOffset, voices)) {
+    return 0;
+  }
+  return crossRelations(
+    { notes: spellRow(spelling.from, prev, prevOffset, voices), chord: tables.fromChord },
+    { notes: spellRow(spelling.to, cur, curOffset, voices), chord: tables.toChord },
+    tables.key,
+    { after: tables.afterChord }
+  ).length;
 }
 function violationCount(prev, prevOffset, cur, curOffset, voices) {
   let count = 0;
@@ -948,6 +797,24 @@ function violationCount(prev, prevOffset, cur, curOffset, voices) {
   }
   return count;
 }
+function moveScoring(prevChord, chord, key, nextChord) {
+  return {
+    structure: structuralTables(chord, key?.scale),
+    resolution: prevChord === void 0 ? void 0 : resolutionTables(prevChord, chord, key?.scale),
+    spelling: key === void 0 ? void 0 : { from: spellingTable(key, prevChord), to: spellingTable(key, chord) },
+    crossRelation: prevChord === void 0 || key === void 0 ? void 0 : { fromChord: prevChord, toChord: chord, afterChord: nextChord, key: key.scale }
+  };
+}
+function violationWeight(scoring, prev, prevOffset, cur, curOffset, voices) {
+  const { resolution, spelling, crossRelation } = scoring;
+  const unresolved = resolution === void 0 ? 0 : resolutionViolations(resolution, spelling, prev, prevOffset, cur, curOffset, voices);
+  const augmented = spelling === void 0 ? 0 : augmentedMelodicCount(spelling, prev, prevOffset, cur, curOffset, voices);
+  const contradictions = spelling === void 0 || crossRelation === void 0 ? 0 : crossRelationCount(spelling, crossRelation, prev, prevOffset, cur, curOffset, voices);
+  return VIOLATION_PENALTY * violationCount(prev, prevOffset, cur, curOffset, voices) + RESOLUTION_PENALTY * unresolved + AUGMENTED_MELODIC_PENALTY * augmented + CROSS_RELATION_PENALTY * contradictions + (createsOuterHiddenPerfect(prev, prevOffset, cur, curOffset, voices) ? HIDDEN_PERFECT_PENALTY : 0);
+}
+function moveScore(scoring, prev, prevOffset, cur, curOffset, voices) {
+  return structuralPenalty(scoring.structure, cur, curOffset, voices) + leadingCost(prev, prevOffset, cur, curOffset, voices) + violationWeight(scoring, prev, prevOffset, cur, curOffset, voices);
+}
 
 // src/theory/voicing/satb.ts
 var SATB_RANGES = Object.freeze([
@@ -960,6 +827,7 @@ var DERIVED_LOW = 40;
 var DERIVED_HIGH = 79;
 var DERIVED_SPAN = 19;
 function resolveRanges(opts) {
+  assertOptions(opts, "opts");
   if (opts?.ranges !== void 0) {
     if (opts.ranges.length === 0) {
       throw new InvalidInputError("ranges must contain at least one voice range");
@@ -1004,8 +872,8 @@ function resolveMaxSpacing(opts) {
   }
   return maxSpacing;
 }
-function resolveKey(opts) {
-  return opts?.key === void 0 ? void 0 : toKeyScale(opts.key);
+function resolvedKeyOf(opts) {
+  return opts?.key === void 0 ? void 0 : resolveKey(opts.key);
 }
 function resolvePreviousChord(opts) {
   return opts?.previousChord === void 0 ? void 0 : toChordData(opts.previousChord);
@@ -1015,26 +883,30 @@ function resolveMaxCandidates(opts) {
   assertPositiveInt(opts.maxCandidates, "maxCandidates", 1e6);
   return opts.maxCandidates;
 }
+function centeringPenalty(ranges, pitches, offset, voices) {
+  let penalty = 0;
+  for (let voice = 0; voice < voices; voice += 1) {
+    const pitch = pitches[offset + voice];
+    const range = ranges[voice];
+    if (pitch === void 0 || range === void 0) {
+      continue;
+    }
+    penalty += Math.abs(pitch - (range.min + range.max) / 2);
+  }
+  return penalty;
+}
 function voiceChord(chord, opts) {
   const data = toChordData(chord);
   const ranges = resolveRanges(opts);
   const maxSpacing = resolveMaxSpacing(opts);
   const candidates = enumerateVoicings(data, ranges, maxSpacing, resolveMaxCandidates(opts));
-  const tables = structuralTables(data, resolveKey(opts));
+  const { structure } = moveScoring(void 0, data, resolvedKeyOf(opts));
   const { pitches, voices } = candidates;
   let bestOffset = -1;
   let bestScore = Number.POSITIVE_INFINITY;
   for (let index = 0; index < candidates.count; index += 1) {
     const offset = index * voices;
-    let score = structuralPenalty(tables, pitches, offset, voices);
-    for (let i = 0; i < voices; i += 1) {
-      const pitch = pitches[offset + i];
-      const range = ranges[i];
-      if (pitch === void 0 || range === void 0) {
-        continue;
-      }
-      score += Math.abs(pitch - (range.min + range.max) / 2);
-    }
+    const score = structuralPenalty(structure, pitches, offset, voices) + centeringPenalty(ranges, pitches, offset, voices);
     if (score < bestScore) {
       bestScore = score;
       bestOffset = offset;
@@ -1063,42 +935,66 @@ function locate(index, chord, work) {
     throw error;
   }
 }
+function successorWeight(next, cur, curOffset, voices) {
+  const { candidates, scoring } = next;
+  const { pitches } = candidates;
+  let bestScore = Number.POSITIVE_INFINITY;
+  let bestWeight = 0;
+  for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+    const offset = candidate * voices;
+    const weight = violationWeight(scoring, cur, curOffset, pitches, offset, voices);
+    const score = weight + structuralPenalty(scoring.structure, pitches, offset, voices) + leadingCost(cur, curOffset, pitches, offset, voices);
+    if (score < bestScore) {
+      bestScore = score;
+      bestWeight = weight;
+    }
+  }
+  return bestWeight;
+}
 function voiceProgression(chords, opts) {
-  assertGenerationBudget(chords.length, "voiced progression chords", opts?.budget);
-  const data = chords.map((chord) => toChordData(chord));
-  const key = resolveKey(opts);
+  const progression = assertArray(chords, "chords");
+  assertGenerationBudget(progression.length, "voiced progression chords", opts?.budget);
+  const data = progression.map((chord) => toChordData(chord));
+  const key = resolvedKeyOf(opts);
   const ranges = resolveRanges(opts);
   const maxSpacing = resolveMaxSpacing(opts);
   const maxCandidates = resolveMaxCandidates(opts);
   const result = [];
-  const buffer = createCandidateBuffer();
+  const first = data[0];
+  if (first === void 0) {
+    return result;
+  }
+  let current = locate(
+    0,
+    first,
+    () => enumerateVoicings(first, ranges, maxSpacing, maxCandidates, createCandidateBuffer())
+  );
+  let spare = createCandidateBuffer();
+  let scoring = moveScoring(void 0, first, key);
   let prev;
-  let prevChord;
-  for (let index = 0; index < data.length; index += 1) {
-    const chord = data[index];
-    if (chord === void 0) {
-      continue;
-    }
-    if (prev === void 0) {
-      prev = locate(index, chord, () => voiceChord(chord, opts));
-      prevChord = chord;
-      result.push(prev);
-      continue;
-    }
-    const candidates = locate(
-      index,
-      chord,
-      () => enumerateVoicings(chord, ranges, maxSpacing, maxCandidates, buffer)
-    );
-    const { pitches, voices } = candidates;
-    const structure = structuralTables(chord, key);
-    const resolution = prevChord === void 0 ? void 0 : resolutionTables(prevChord, chord, key);
+  for (const [index, chord] of data.entries()) {
+    const nextChord = data[index + 1];
+    const lookahead = nextChord === void 0 ? void 0 : {
+      candidates: locate(
+        index + 1,
+        nextChord,
+        () => enumerateVoicings(nextChord, ranges, maxSpacing, maxCandidates, spare)
+      ),
+      // The chord after the one being reached goes in too: it is what
+      // says whether the chromatic tone the next chord introduces is the
+      // one an applied dominant is written with.
+      scoring: moveScoring(chord, nextChord, key, data[index + 2])
+    };
+    const { pitches, voices, count } = current;
+    const weighed = lookahead !== void 0 && count * lookahead.candidates.count <= MAX_LOOKAHEAD_PAIRS ? lookahead : void 0;
     let bestOffset = -1;
     let bestScore = Number.POSITIVE_INFINITY;
-    for (let candidate = 0; candidate < candidates.count; candidate += 1) {
+    for (let candidate = 0; candidate < count; candidate += 1) {
       const offset = candidate * voices;
-      const unresolved = resolution === void 0 ? 0 : resolutionViolations(resolution, prev, 0, pitches, offset, voices);
-      const score = structuralPenalty(structure, pitches, offset, voices) + leadingCost(prev, 0, pitches, offset, voices) + VIOLATION_PENALTY * violationCount(prev, 0, pitches, offset, voices) + RESOLUTION_PENALTY * unresolved;
+      let score = prev === void 0 ? structuralPenalty(scoring.structure, pitches, offset, voices) + centeringPenalty(ranges, pitches, offset, voices) : moveScore(scoring, prev, 0, pitches, offset, voices);
+      if (weighed !== void 0) {
+        score += successorWeight(weighed, pitches, offset, voices);
+      }
       if (score < bestScore) {
         bestScore = score;
         bestOffset = offset;
@@ -1110,28 +1006,41 @@ function voiceProgression(chords, opts) {
     const best = [...pitches.subarray(bestOffset, bestOffset + voices)];
     result.push(best);
     prev = best;
-    prevChord = chord;
+    if (lookahead !== void 0) {
+      spare = current;
+      current = lookahead.candidates;
+      scoring = lookahead.scoring;
+    }
   }
   return result;
 }
 
 // src/theory/voicing/leading.ts
+function assertVoicing(pitches, name) {
+  const voices = assertArray(pitches, name);
+  for (let index = 0; index < voices.length; index += 1) {
+    assertFiniteNumber(voices[index] ?? Number.NaN, `${name}[${index}]`);
+  }
+  return voices;
+}
 function voiceLeadingCost(from, to) {
-  if (from.length !== to.length) {
+  const previous = assertVoicing(from, "from");
+  const next = assertVoicing(to, "to");
+  if (previous.length !== next.length) {
     return Number.POSITIVE_INFINITY;
   }
-  return leadingCost(from, 0, to, 0, from.length);
+  return leadingCost(previous, 0, next, 0, previous.length);
 }
 function nextVoicing(current, chord, opts) {
+  assertOptions(opts, "opts");
+  assertVoicing(current, "current");
   const data = toChordData(chord);
   const derived = opts?.ranges === void 0 && opts?.voices === void 0;
   if (derived) {
     if (current.length === 0) {
       throw new InvalidInputError("current must contain at least one pitch");
     }
-    for (let index = 0; index < current.length; index += 1) {
-      assertFiniteNumber(current[index] ?? Number.NaN, `current[${index}]`);
-    }
+    assertVoicing(current, "current");
   }
   const ranges = derived ? resolveRanges({
     ranges: current.map((pitch) => {
@@ -1139,9 +1048,7 @@ function nextVoicing(current, chord, opts) {
       return { min: Math.max(0, centre - 12), max: Math.min(127, centre + 12) };
     })
   }) : resolveRanges(opts);
-  for (let index = 0; index < current.length; index += 1) {
-    assertFiniteNumber(current[index] ?? Number.NaN, `current[${index}]`);
-  }
+  assertVoicing(current, "current");
   if (current.length < ranges.length) {
     throw new InvalidInputError(
       `current has ${current.length} voices but the requested ranges require ${ranges.length}`
@@ -1153,16 +1060,14 @@ function nextVoicing(current, chord, opts) {
   });
   const maxSpacing = resolveMaxSpacing(opts);
   const candidates = enumerateVoicings(data, ranges, maxSpacing, resolveMaxCandidates(opts));
-  const key = resolveKey(opts);
-  const previousChord = resolvePreviousChord(opts);
-  const structure = structuralTables(data, key);
-  const resolution = previousChord === void 0 ? void 0 : resolutionTables(previousChord, data, key);
+  const key = resolvedKeyOf(opts);
+  const scoring = moveScoring(resolvePreviousChord(opts), data, key);
   const { pitches, voices } = candidates;
   let bestOffset = -1;
   let bestScore = Number.POSITIVE_INFINITY;
   for (let candidate = 0; candidate < candidates.count; candidate += 1) {
     const offset = candidate * voices;
-    const score = structuralPenalty(structure, pitches, offset, voices) + leadingCost(source, 0, pitches, offset, voices) + VIOLATION_PENALTY * violationCount(source, 0, pitches, offset, voices) + RESOLUTION_PENALTY * (resolution === void 0 ? 0 : resolutionViolations(resolution, source, 0, pitches, offset, voices));
+    const score = moveScore(scoring, source, 0, pitches, offset, voices);
     if (score < bestScore) {
       bestScore = score;
       bestOffset = offset;
@@ -1176,6 +1081,12 @@ function nextVoicing(current, chord, opts) {
 
 // src/theory/voicing/styled.ts
 var DEFAULT_STYLE_OCTAVE = 4;
+function dropPositionFromTop(style) {
+  if (style === "drop2") {
+    return 2;
+  }
+  return style === "drop3" ? 3 : 0;
+}
 function dedupePcs(pcs) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -1202,7 +1113,9 @@ function nearestPc(target, pcs) {
   }
   return best;
 }
-function voiceChordStyled(chord, opts) {
+function voiceChordStyled(given, opts) {
+  assertOptions(opts, "opts");
+  const chord = toChordData(given);
   const style = opts?.style ?? "close";
   const octave = opts?.octave ?? DEFAULT_STYLE_OCTAVE;
   assertInteger(octave, "styled voicing octave", -10, 10);
@@ -1215,6 +1128,7 @@ function voiceChordStyled(chord, opts) {
   const omitRoot = style === "rootless" || opts?.rootless === true;
   let order = dedupePcs(chord.intervals.map((interval) => pitchClassOf(chord.rootPc + interval)));
   const bassIndex = order.indexOf(bassPc);
+  const bassIsChordTone = bassIndex >= 0;
   if (bassIndex > 0) {
     order = [...order.slice(bassIndex), ...order.slice(0, bassIndex)];
   } else if (bassIndex < 0) {
@@ -1239,6 +1153,15 @@ function voiceChordStyled(chord, opts) {
     const targetIndex = order.indexOf(target);
     order = [...order.slice(targetIndex + 1), ...order.slice(0, targetIndex + 1)];
   }
+  const dropFromTop = dropPositionFromTop(style);
+  const dropsToNamedBass = dropFromTop > 0 && bassIsChordTone && chord.bassPc !== void 0 && order.length > dropFromTop;
+  if (dropsToNamedBass) {
+    const bassAt = order.indexOf(bassPc);
+    if (bassAt >= 0) {
+      const shift = ((bassAt - (order.length - dropFromTop)) % order.length + order.length) % order.length;
+      order = [...order.slice(shift), ...order.slice(0, shift)];
+    }
+  }
   const stack = [];
   let prev;
   for (const pc of order) {
@@ -1253,10 +1176,10 @@ function voiceChordStyled(chord, opts) {
     }
     stack.push(prev);
   }
-  if (style === "drop2" && stack.length >= 2) {
-    stack[stack.length - 2] = (stack[stack.length - 2] ?? 0) - 12;
-  } else if (style === "drop3" && stack.length >= 3) {
-    stack[stack.length - 3] = (stack[stack.length - 3] ?? 0) - 12;
+  const stackedFloor = bassIsChordTone ? 0 : 1;
+  if (dropFromTop > 0 && stack.length - dropFromTop > stackedFloor) {
+    const dropIndex = stack.length - dropFromTop;
+    stack[dropIndex] = (stack[dropIndex] ?? 0) - 12;
   }
   if (chord.bassPc !== void 0) {
     const bassIndexInStack = stack.findIndex((pitch) => pitchClassOf(pitch) === bassPc);
@@ -1290,17 +1213,26 @@ var INTERVAL_WORDS = [
   "fifth",
   "sixth",
   "seventh",
-  "octave"
+  "octave",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth"
 ];
 function intervalWord(numberValue) {
-  return INTERVAL_WORDS[numberValue - 1] ?? "interval";
+  return INTERVAL_WORDS[numberValue - 1] ?? `${numberValue}th`;
+}
+function intervalArticle(word) {
+  return /^[aeiou]/.test(word) ? "an" : "a";
 }
 function violation(kind, voices, fromIndex, toIndex, rationale) {
   return { kind, voices, fromIndex, toIndex, rationale };
 }
 
 // src/theory/partwriting/species.ts
-var EPS = 1e-9;
 var SPECIES_RATIO = { 1: 1, 2: 2, 3: 4, 4: 2, 5: 0 };
 var SPECIES_NUMBERS = Object.keys(SPECIES_RATIO).map(Number);
 var MIN_FLORID_VALUE = 0.125;
@@ -1324,7 +1256,7 @@ function direction(interval) {
 function sameNote(a, b) {
   return a.letter === b.letter && a.alter === b.alter && a.octave === b.octave;
 }
-function isPassedThrough(entries, position) {
+function isPassedThrough(entries, position, species) {
   const previous = entries[position - 1];
   const current = entries[position];
   const next = entries[position + 1];
@@ -1336,9 +1268,10 @@ function isPassedThrough(entries, position) {
   if (!isStep(incoming) || !isStep(outgoing)) {
     return false;
   }
-  const passing = direction(incoming) === direction(outgoing);
-  const neighbour = sameNote(previous.note, next.note);
-  return passing || neighbour;
+  if (direction(incoming) === direction(outgoing)) {
+    return true;
+  }
+  return sameNote(previous.note, next.note) && (species === 3 || species === 5);
 }
 function isThird(interval) {
   return interval.number === 3;
@@ -1399,7 +1332,7 @@ function licenceFor(species, downbeat) {
   }
   return downbeat ? "none" : "passing";
 }
-function verticalViolations(entries, position, species, counterpointAbove) {
+function verticalViolations(entries, position, species, counterpointAbove, crossed) {
   const entry = entries[position];
   if (entry === void 0) {
     return [];
@@ -1407,7 +1340,8 @@ function verticalViolations(entries, position, species, counterpointAbove) {
   const found = [];
   const upper = counterpointAbove ? entry.note : entry.against;
   const lower = counterpointAbove ? entry.against : entry.note;
-  if (createsVoiceCrossing(upper, lower)) {
+  if (!crossed.has(entry.index) && createsVoiceCrossing(upper, lower)) {
+    crossed.add(entry.index);
     found.push(
       violation(
         "voiceCrossing",
@@ -1422,7 +1356,7 @@ function verticalViolations(entries, position, species, counterpointAbove) {
     return found;
   }
   const licence = licenceFor(species, entry.downbeat);
-  if (licence === "passing" && (isPassedThrough(entries, position) || isFiguredDissonance(entries, position, species))) {
+  if (licence === "passing" && (isPassedThrough(entries, position, species) || isFiguredDissonance(entries, position, species))) {
     return found;
   }
   if (licence === "suspension") {
@@ -1471,6 +1405,17 @@ function suspensionViolations(entries, position) {
       )
     ];
   }
+  if (next.consonance === 2 /* Dissonance */) {
+    return [
+      violation(
+        "unresolvedSuspension",
+        [0, 1],
+        entry.index,
+        next.index,
+        `The suspension falls onto a ${next.interval.quality}${next.interval.number}, which is no resolution`
+      )
+    ];
+  }
   return [];
 }
 function melodicViolations(from, to) {
@@ -1607,7 +1552,7 @@ function leapAnswerViolations(moves) {
         [1],
         leap.from.index,
         answer.to.index,
-        `The leap of ${word === "octave" ? "an" : "a"} ${word} is not answered by a step the other way`
+        `The leap of ${intervalArticle(word)} ${word} is not answered by a step the other way`
       )
     );
   }
@@ -1673,6 +1618,11 @@ function melodicShapeViolations(entries, species) {
   ];
   return found.sort((left, right) => left.fromIndex - right.fromIndex);
 }
+function inTimeOrder(violations) {
+  return [...violations].sort(
+    (left, right) => left.fromIndex - right.fromIndex || left.toIndex - right.toIndex
+  );
+}
 function motionViolations(from, to, counterpointAbove) {
   const found = [];
   const upperPrev = counterpointAbove ? from.note : from.against;
@@ -1691,14 +1641,14 @@ function motionViolations(from, to, counterpointAbove) {
       )
     );
   }
-  if (createsHiddenParallelPerfect(upperPrev, upperCur, lowerPrev, lowerCur)) {
+  if (createsHiddenParallelPerfect(upperPrev, upperCur, lowerPrev, lowerCur, "twoVoice")) {
     found.push(
       violation(
         "hiddenPerfect",
         [0, 1],
         from.index,
         to.index,
-        "The voices leap into a perfect interval by similar motion"
+        "The voices move into a perfect interval by similar motion"
       )
     );
   }
@@ -1796,14 +1746,14 @@ function resolveDurations(counterpoint, measures, species, opts) {
     }
     for (const duration of given) {
       const units = duration / MIN_FLORID_VALUE;
-      if (!(duration > 0) || duration > 1 || Math.abs(units - Math.round(units)) > EPS) {
+      if (!(duration > 0) || duration > 1 || Math.abs(units - Math.round(units)) > BEAT_EPS) {
         return {
           problem: `A note lasts ${duration} of a measure, which this style does not write`
         };
       }
     }
     const total = given.reduce((sum, duration) => sum + duration, 0);
-    if (Math.abs(total - measures) > EPS) {
+    if (Math.abs(total - measures) > BEAT_EPS) {
       return { problem: `The counterpoint fills ${total} of the ${measures} measures` };
     }
     return { durations: [...given] };
@@ -1831,23 +1781,32 @@ function buildEntries(cantusFirmus, counterpoint, durations, counterpointAbove)
     if (note === void 0) {
       continue;
     }
-    const againstIndex = Math.min(Math.floor(onset + EPS), cantusFirmus.length - 1);
-    const against = cantusFirmus[againstIndex];
-    if (against === void 0) {
-      continue;
+    const struckOver = Math.min(Math.floor(onset + BEAT_EPS), cantusFirmus.length - 1);
+    const lastOver = Math.min(
+      Math.max(Math.ceil(onset + duration - BEAT_EPS) - 1, struckOver),
+      cantusFirmus.length - 1
+    );
+    for (let againstIndex = struckOver; againstIndex <= lastOver; againstIndex += 1) {
+      const against = cantusFirmus[againstIndex];
+      if (against === void 0) {
+        continue;
+      }
+      const held = againstIndex > struckOver;
+      const begins = held ? againstIndex : onset;
+      const interval = counterpointAbove ? spelledInterval(against, note) : spelledInterval(note, against);
+      entries.push({
+        note,
+        index,
+        onset: begins,
+        duration: onset + duration - begins,
+        held,
+        against,
+        againstIndex,
+        downbeat: Math.abs(begins - Math.round(begins)) < BEAT_EPS,
+        interval,
+        consonance: classifySpelledInterval(interval)
+      });
     }
-    const interval = counterpointAbove ? spelledInterval(against, note) : spelledInterval(note, against);
-    entries.push({
-      note,
-      index,
-      onset,
-      duration,
-      against,
-      againstIndex,
-      downbeat: Math.abs(onset - Math.round(onset)) < EPS,
-      interval,
-      consonance: classifySpelledInterval(interval)
-    });
     onset += duration;
   }
   return entries;
@@ -1866,40 +1825,50 @@ function motionPairs(entries) {
   }
   return pairs;
 }
-function checkSpecies(cantusFirmus, counterpoint, species, mode, opts) {
+function checkSpecies(cantusFirmus, counterpoint, species, modeLike, opts) {
+  assertArray(cantusFirmus, "cantus firmus");
+  assertArray(counterpoint, "counterpoint");
+  const asked = assertOptions(opts, "opts");
+  const mode = toKeyScale(modeLike);
   if (!SPECIES_NUMBERS.includes(species)) {
     throw new InvalidInputError(
-      `species must be one of ${SPECIES_NUMBERS.join(", ")}; received ${JSON.stringify(species)}`
+      `species must be one of ${SPECIES_NUMBERS.join(", ")}; received ${describeRejected(species)}`
     );
   }
   if (cantusFirmus.length === 0 || counterpoint.length === 0) {
     throw new InvalidInputError("checkSpecies needs both a cantus firmus and a counterpoint");
   }
-  const resolved = resolveDurations(counterpoint, cantusFirmus.length, species, opts);
+  const resolved = resolveDurations(counterpoint, cantusFirmus.length, species, asked);
   if ("problem" in resolved) {
-    return [violation("wrongRhythmicRatio", [1], 0, counterpoint.length - 1, resolved.problem)];
+    return inTimeOrder([
+      violation("wrongRhythmicRatio", [1], 0, counterpoint.length - 1, resolved.problem)
+    ]);
   }
-  const counterpointAbove = opts?.counterpointAbove ?? meanPitch(counterpoint) >= meanPitch(cantusFirmus);
+  const counterpointAbove = asked.counterpointAbove ?? meanPitch(counterpoint) >= meanPitch(cantusFirmus);
   const entries = buildEntries(cantusFirmus, counterpoint, resolved.durations, counterpointAbove);
+  const struck = entries.filter((entry) => !entry.held);
   const violations = [];
+  const crossed = /* @__PURE__ */ new Set();
   for (let position = 0; position < entries.length; position += 1) {
-    violations.push(...verticalViolations(entries, position, species, counterpointAbove));
-    const previous = entries[position - 1];
-    const current = entries[position];
+    violations.push(...verticalViolations(entries, position, species, counterpointAbove, crossed));
+  }
+  for (let position = 1; position < struck.length; position += 1) {
+    const previous = struck[position - 1];
+    const current = struck[position];
     if (previous !== void 0 && current !== void 0) {
       violations.push(...melodicViolations(previous, current));
     }
   }
-  violations.push(...melodicShapeViolations(entries, species));
-  for (const [from, to] of motionPairs(entries)) {
-    const previous = entries[from];
-    const current = entries[to];
+  violations.push(...melodicShapeViolations(struck, species));
+  for (const [from, to] of motionPairs(struck)) {
+    const previous = struck[from];
+    const current = struck[to];
     if (previous !== void 0 && current !== void 0) {
       violations.push(...motionViolations(previous, current, counterpointAbove));
     }
   }
-  violations.push(...cadenceViolations(entries, mode, counterpointAbove));
-  return violations;
+  violations.push(...cadenceViolations(struck, mode, counterpointAbove));
+  return inTimeOrder(violations);
 }
 
 // src/theory/partwriting/index.ts
@@ -1912,9 +1881,6 @@ function midiOf(note, index, voice) {
   }
   return noteToMidi(note);
 }
-function isDescendingStep(interval) {
-  return interval.number === 2 && (interval.semitones === -1 || interval.semitones === -2);
-}
 function verticalViolations2(moment, ranges, maxSpacing) {
   const found = [];
   const { pitches, index } = moment;
@@ -2011,95 +1977,23 @@ function pairViolations(transition) {
         [0, voices - 1],
         from.index,
         to.index,
-        "The outer voices leap into a perfect interval by similar motion"
+        "The outer voices reach a perfect interval by similar motion, the upper one by leap"
       )
     );
   }
   return found;
 }
-function inKey(pc, key) {
-  return (key.modeMask12 >> pitchClassOf(pc - key.rootPc) & 1) === 1;
-}
-function isDominantSonority(chord) {
-  const has = (semitones) => chord.intervals.some((interval) => pitchClassOf(interval) === semitones);
-  return chord.quality === "maj" || has(4) && has(10);
-}
-function isAppliedDominant(chord, next, key) {
-  if (next === void 0 || !isDominantSonority(chord)) {
-    return false;
-  }
-  const target = pitchClassOf(chord.rootPc + 5);
-  return target !== pitchClassOf(key.rootPc) && inKey(target, key) && pitchClassOf(next.rootPc) === target;
-}
-function isNeapolitan(chord, key) {
-  return chord.quality === "maj" && pitchClassOf(chord.rootPc - key.rootPc) === 1;
-}
-function soundsAugmentedSixth(moment, key) {
-  const bass = moment.notes[0];
-  if (bass === void 0 || noteToPitchClass(bass) !== pitchClassOf(key.rootPc + 8)) {
-    return false;
-  }
-  return moment.notes.some((note, voice) => {
-    if (voice === 0) {
-      return false;
-    }
-    const interval = spelledInterval(bass, note);
-    return (interval.number - 1) % 7 + 1 === 6 && pitchClassOf(interval.semitones) === 10;
-  });
-}
-function isChromaticHarmony(moment, next, key) {
-  return isAppliedDominant(moment.chord, next, key) || isNeapolitan(moment.chord, key) || soundsAugmentedSixth(moment, key);
-}
-function approachedByStep(before, moment, voice) {
-  const earlier = before?.notes[voice];
-  const later = moment.notes[voice];
-  if (earlier === void 0 || later === void 0) {
-    return false;
-  }
-  return spelledInterval(earlier, later).number === 2;
-}
-function isOuterVoice(voice, moment) {
-  return voice === 0 || voice === moment.notes.length - 1;
-}
 function crossRelationViolations(transition) {
-  const found = [];
   const { from, to, key, before, after } = transition;
-  const chromatic = isChromaticHarmony(from, to.chord, key) || isChromaticHarmony(to, after?.chord, key);
-  const reported = /* @__PURE__ */ new Set();
-  for (let first = 0; first < from.notes.length; first += 1) {
-    for (let second = 0; second < to.notes.length; second += 1) {
-      if (first === second) {
-        continue;
-      }
-      const earlier = from.notes[first];
-      const later = to.notes[second];
-      if (earlier === void 0 || later === void 0) {
-        continue;
-      }
-      const letter = diatonicLetterOf(earlier.letter);
-      if (letter !== diatonicLetterOf(later.letter) || earlier.alter === later.alter) {
-        continue;
-      }
-      if (chromatic || approachedByStep(before, from, first) || approachedByStep(from, to, second) || !isOuterVoice(first, from) && !isOuterVoice(second, to)) {
-        continue;
-      }
-      const pair = `${letter}:${Math.min(first, second)}:${Math.max(first, second)}`;
-      if (reported.has(pair)) {
-        continue;
-      }
-      reported.add(pair);
-      found.push(
-        violation(
-          "crossRelation",
-          [first, second],
-          from.index,
-          to.index,
-          `${formatNote(bare(earlier))} is contradicted by ${formatNote(bare(later))} in another voice`
-        )
-      );
-    }
-  }
-  return found;
+  return crossRelations(from, to, key, { before: before?.notes, after: after?.chord }).map(
+    (clash) => violation(
+      "crossRelation",
+      [clash.earlierVoice, clash.laterVoice],
+      from.index,
+      to.index,
+      `${formatNote(bare(clash.earlier))} is contradicted by ${formatNote(bare(clash.later))} in another voice`
+    )
+  );
 }
 function melodicViolations2(transition) {
   const found = [];
@@ -2141,7 +2035,8 @@ function melodicViolations2(transition) {
         )
       );
     }
-    if (earlierPc === leadingTonePc && isFunctioningLeadingTone(from.chord, key) && nextPcs.has(tonicPc) && !nextPcs.has(earlierPc) && !isLeadingToneResolution(earlierPitch, laterPitch, key)) {
+    const inner = !isOuterVoice(voice, from.notes) && !isOuterVoice(voice, to.notes);
+    if (earlierPc === leadingTonePc && isFunctioningLeadingTone(from.chord, key) && nextPcs.has(tonicPc) && !nextPcs.has(earlierPc) && !isLeadingToneResolution(earlierPitch, laterPitch, key) && !(inner && isFrustratedLeadingTone(earlierPitch, laterPitch, to.chord))) {
       found.push(
         violation(
           "unresolvedLeadingTone",
@@ -2156,22 +2051,28 @@ function melodicViolations2(transition) {
   return found;
 }
 function spellVoicing(voicing, chord, key) {
-  const { tonic } = spelledKeyOf(key);
-  return voicing.map((pitch) => spellPitch(pitch, tonic, key, { chordRoot: chord.rootPc }));
-}
-function checkPartWriting(voicings, chords, key, opts) {
+  assertArray(voicing, "voicing");
+  assertChord(chord);
+  const { tonic, scale } = resolveKey(key);
+  return voicing.map((pitch) => spellPitch(pitch, tonic, scale, { chord }));
+}
+function checkPartWriting(voicings, chords, keyLike, opts) {
+  assertArray(voicings, "voicings");
+  assertArray(chords, "chords");
+  const asked = assertOptions(opts, "opts");
+  const key = toKeyScale(keyLike);
   if (voicings.length !== chords.length) {
     throw new InvalidInputError(
       `checkPartWriting needs one chord per voicing; received ${voicings.length} voicings and ${chords.length} chords`
     );
   }
-  const maxSpacing = resolveMaxSpacing(opts);
+  const maxSpacing = resolveMaxSpacing(asked);
   const voiceCount = voicings.reduce((widest, voicing) => Math.max(widest, voicing.length), 0);
   let ranges;
-  if (opts?.ranges === void 0) {
+  if (asked.ranges === void 0) {
     ranges = voiceCount === 4 ? SATB_RANGES : void 0;
   } else {
-    ranges = resolveRanges(opts);
+    ranges = resolveRanges(asked);
     if (ranges.length < voiceCount) {
       throw new InvalidInputError(
         `checkPartWriting needs one range per voice; received ${ranges.length} ranges for ${voiceCount} voices`
@@ -2221,12 +2122,6 @@ export {
   instrumentTransposition,
   toSoundingPitch,
   toWrittenPitch,
-  scaleMatchesChord,
-  chordScales,
-  avoidNotes,
-  availableTensions,
-  chordScaleReport,
-  scalesForChanges,
   figuredBassRealization,
   realizeFiguredBass,
   figuredBassOf,
@@ -2240,4 +2135,4 @@ export {
   spellVoicing,
   checkPartWriting
 };
-//# sourceMappingURL=chunk-H3VORETI.js.map
+//# sourceMappingURL=chunk-M5RYMAFI.js.map