@libraz/libcantus 1.3.0 → 1.4.0

package/dist/{chunk-GNVN4PPJ.js → chunk-FJFULJZE.js}

@@ -1,6 +1,7 @@
 import {
-  sortedNoteEvents
-} from "./chunk-PUKJP2Z5.js";
+  sortedNoteEvents,
+  soundingIndices
+} from "./chunk-TXFWSU5D.js";
 import {
   DORIAN_MASK,
   HARMONIC_MINOR_MASK,
@@ -12,7 +13,8 @@ import {
   MIXOLYDIAN_MASK,
   NATURAL_MINOR_MASK,
   PHRYGIAN_MASK,
-  appliedDominantTarget,
+  QUALITY_INTERVALS,
+  appliedChordTarget,
   chordFromSpan,
   chordPitchClasses,
   chordQualities,
@@ -20,7 +22,6 @@ import {
   chordToneSpellings,
   createsVerticalDissonance,
   diatonicTriad,
-  hasDominantSonority,
   hasMajorThird,
   heptatonicFrameOf,
   intervalAboveRoot,
@@ -34,8 +35,10 @@ import {
   isScaleTone,
   keyRelationBetween,
   keySignatureFifths,
+  keySpelling,
   majorKey,
   makeChord,
+  makeSpelledChord,
   minorKey,
   resolveKey,
   scaleOf,
@@ -45,10 +48,11 @@ import {
   spellChord,
   spellPitchClass,
   spelledKeyOf,
+  spellingAbove,
   toChordData,
   toKeyScale,
   tonicizableDegrees
-} from "./chunk-RFIBF2RR.js";
+} from "./chunk-H7FVMBUC.js";
 import {
   BEAT_EPS,
   InvalidInputError,
@@ -78,10 +82,12 @@ import {
   diatonicLetterOf,
   formatNote,
   isCompound,
+  isConsonantInterval,
   meterAt,
   metricGridUnit,
   metricWeight,
   midiToNote,
+  naturalPitchClassOf,
   parseInterval,
   pitchClassOf,
   pulseBeats,
@@ -90,7 +96,7 @@ import {
   toNoteData,
   transposeByInterval,
   transposeNote
-} from "./chunk-AGOVW7U6.js";
+} from "./chunk-YYVXRV3V.js";
 
 // src/analyze/detect/modes.ts
 var MODAL_CANDIDATES = Object.freeze([
@@ -204,6 +210,30 @@ function windowWeights(notes, windowStart, windowEnd, meter) {
   return { weights, totalWeight, maxWeight, lowestPitch };
 }
 
+// src/analyze/detect/internal.ts
+var MINOR_VARIANTS = [
+  { variant: "natural", mask: NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
+  { variant: "harmonic", mask: HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
+  { variant: "melodic", mask: MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
+];
+var MAJOR_VARIANTS = [
+  { variant: "major", mask: MAJOR_MASK, scaleName: "major" }
+];
+var SCALE_NAME_ORDER = [
+  "major",
+  "naturalMinor",
+  "harmonicMinor",
+  "melodicMinor",
+  "dorian",
+  "phrygian",
+  "lydian",
+  "mixolydian",
+  "locrian"
+];
+var EXPLAINED_RIVALS = 3;
+var SCORE_DIGITS = 2;
+var MAX_SCORE_DIGITS = 6;
+
 // src/analyze/detect/profiles.ts
 var KRUMHANSL_KESSLER_PROFILE = {
   major: [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88],
@@ -302,6 +332,11 @@ function profileScore(dist, vector, tonic) {
 }
 
 // src/analyze/detect/index.ts
+var CHORD_INPUT_KINDS = [
+  "auto",
+  "midi",
+  "pitchClass"
+];
 function uniquePitchClasses(pitches) {
   return [...new Set(pitches.map(pitchClassOf))].sort((a, b) => a - b);
 }
@@ -315,12 +350,13 @@ function assertPitches(pitches, name, budget = void 0) {
 function detectChord(pitches, opts = {}) {
   const asked = assertOptions(opts, "opts");
   assertPitches(pitches, "chord detection pitches");
+  const askedKind = assertOneOf(asked.input ?? "auto", CHORD_INPUT_KINDS, "input");
   if (asked.bassPc !== void 0) assertFiniteNumber(asked.bassPc, "bassPc");
   const input = uniquePitchClasses(pitches);
   if (input.length === 0) {
     return [];
   }
-  const inputKind = asked.input === void 0 || asked.input === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : asked.input;
+  const inputKind = askedKind === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : askedKind;
   const bassPc = asked.bassPc !== void 0 ? pitchClassOf(asked.bassPc) : inputKind === "midi" ? pitchClassOf(pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
   const inputSet = new Set(input);
   const matches = [];
@@ -339,6 +375,9 @@ function detectChord(pitches, opts = {}) {
       if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
         continue;
       }
+      if (tones.length - missingPcs.length < 2) {
+        continue;
+      }
       const extraPcs = input.filter((pc) => !toneSet.has(pc));
       const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => pitchClassOf(rootPc + iv) === bassPc);
       const inversion = bassPc === void 0 || bassIndex < 0 ? null : bassIndex;
@@ -387,31 +426,9 @@ function detectChordBest(pitches, opts = {}) {
   }
   return makeChord(best.rootPc, best.quality, best.bassPc);
 }
-var MINOR_VARIANTS = [
-  { variant: "natural", mask: NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
-  { variant: "harmonic", mask: HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
-  { variant: "melodic", mask: MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
-];
-var MAJOR_VARIANTS = [
-  { variant: "major", mask: MAJOR_MASK, scaleName: "major" }
-];
-var SCALE_NAME_ORDER = [
-  "major",
-  "naturalMinor",
-  "harmonicMinor",
-  "melodicMinor",
-  "dorian",
-  "phrygian",
-  "lydian",
-  "mixolydian",
-  "locrian"
-];
 function scaleNameRank(name) {
   return SCALE_NAME_ORDER.indexOf(name);
 }
-var EXPLAINED_RIVALS = 3;
-var SCORE_DIGITS = 2;
-var MAX_SCORE_DIGITS = 6;
 function quoteScores(rival, winner) {
   let digits = SCORE_DIGITS;
   while (digits < MAX_SCORE_DIGITS && rival.toFixed(digits) === winner.toFixed(digits)) {
@@ -629,13 +646,14 @@ var CHORD_SHAPE = {
   french: { rootAboveBass: 6, quality: "7b5", intervals: [0, 4, 6, 10] },
   german: { rootAboveBass: 0, quality: "dom7", intervals: [0, 4, 7, 10] }
 };
-var KIND_BY_SYMBOL = /* @__PURE__ */ new Map([
+var KIND_SYMBOLS = [
   ["It6", "italian"],
   ["Fr6", "french"],
   ["Ger6", "german"],
   // The German sixth's figures over its bass are 6/5; both spellings are in use.
   ["Ger65", "german"]
-]);
+];
+var KIND_BY_SYMBOL = new Map(KIND_SYMBOLS);
 var SYMBOL_BY_KIND = {
   italian: "It6",
   french: "Fr6",
@@ -660,14 +678,16 @@ function augmentedSixthOn(kind, keyLike) {
   const shape = CHORD_SHAPE[checked];
   const { scale: key, tonic } = resolveKey(keyLike);
   const bassPc = bassPcOf(key);
-  const chord = makeChord(pitchClassOf(bassPc + shape.rootAboveBass), shape.quality, bassPc);
-  chord.intervals = [...shape.intervals];
   const bass = transposeByInterval(tonic, BASS_INTERVAL);
   const tones = spelledInChordOrder(checked, tonic);
   const [root = bass] = tones;
-  chord.rootSpelling = bareSpelling(root);
-  chord.bassSpelling = bareSpelling(bass);
-  chord.toneSpellings = tones.map(bareSpelling);
+  const chord = makeSpelledChord(pitchClassOf(bassPc + shape.rootAboveBass), shape.quality, {
+    bassPc,
+    rootSpelling: bareSpelling(root),
+    bassSpelling: bareSpelling(bass),
+    toneSpellings: tones.map(bareSpelling)
+  });
+  chord.intervals = [...shape.intervals];
   return chord;
 }
 function kindOfPitchClasses(pcs, bass) {
@@ -1009,14 +1029,6 @@ function borrowedSource(chord, key) {
 function isTonicizableRoot(rootPc, key) {
   return tonicizableDegrees(key).some((degree) => degree.rootPc === pitchClassOf(rootPc));
 }
-function appliedTarget(chord, key) {
-  const dominant = hasDominantSonority(chord);
-  const leadingTone = LEADING_TONE_QUALITIES.has(chord.quality);
-  if (!dominant && !leadingTone) {
-    return null;
-  }
-  return appliedDominantTarget(chord.rootPc + (dominant ? 5 : 1), key);
-}
 function isAppliedDominant(chord, key) {
   if (isDiatonicChord(chord, key)) {
     return false;
@@ -1028,7 +1040,7 @@ function isAppliedDominant(chord, key) {
   return pointsAtTonicizableDegree(chord, key);
 }
 function pointsAtTonicizableDegree(chord, key) {
-  if (appliedTarget(chord, key) !== null) {
+  if (appliedChordTarget(chord, key) !== null) {
     return true;
   }
   return soundsDominantSeventh(chord) && isTonicizableRoot(pitchClassOf(chord.rootPc - 1), key);
@@ -1071,7 +1083,8 @@ function seventhQuality(base, halfDim) {
   }
   return base === "maj" ? "dom7" : "min7";
 }
-var INVERSION_FIGURES = /* @__PURE__ */ new Set(["6", "64", "65", "43", "42", "2", "7"]);
+var INVERSION_FIGURE_LIST = ["6", "64", "65", "43", "42", "2", "7"];
+var INVERSION_FIGURES = new Set(INVERSION_FIGURE_LIST);
 var ROMAN_STYLE = {
   maj: { lower: false, suffix: "" },
   min: { lower: true, suffix: "" },
@@ -1143,7 +1156,12 @@ function parseInversion(figures) {
   }
   return { inversion: 0, seventh: false };
 }
-function parseSimpleRoman(text, key) {
+function numeralRootSpelling(tonic, degreeNumber, rootPc) {
+  const spelling = spellingAbove(tonic, degreeNumber - 1, rootPc);
+  return Math.abs(spelling.alter) <= 2 ? spelling : void 0;
+}
+function parseSimpleRoman(text, resolved) {
+  const key = resolved.scale;
   const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
   if (!match) {
     throw new InvalidInputError(`Invalid Roman numeral: ${text}`);
@@ -1167,8 +1185,17 @@ function parseSimpleRoman(text, key) {
   );
   const rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && LEADING_TONE_QUALITIES.has(quality2) ? pitchClassOf(diatonicRootPc + 1) : diatonicRootPc;
   const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
+  const parsed = (quality2, inversion2) => {
+    const rootPc = rootForQuality(quality2);
+    return {
+      rootPc,
+      rootSpelling: numeralRootSpelling(resolved.tonic, degreeNumber, rootPc),
+      quality: quality2,
+      inversion: inversion2
+    };
+  };
   if (canonical !== void 0) {
-    return { rootPc: rootForQuality(canonical), quality: canonical, inversion: 0 };
+    return parsed(canonical, 0);
   }
   const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
   if (!parsedSuffix) {
@@ -1207,20 +1234,23 @@ function parseSimpleRoman(text, key) {
   } else {
     quality = base;
   }
-  return { rootPc: rootForQuality(quality), quality, inversion };
+  return parsed(quality, inversion);
 }
 var NEAPOLITAN_SIXTH = "N6";
 function chromaticSymbolChord(text, key) {
   if (text === NEAPOLITAN_SIXTH) {
     const rootPc = pitchClassOf(key.scale.rootPc + 1);
-    return makeChord(rootPc, "maj", pitchClassOf(rootPc + 4));
+    return makeSpelledChord(rootPc, "maj", {
+      bassPc: pitchClassOf(rootPc + 4),
+      rootSpelling: numeralRootSpelling(key.tonic, 2, rootPc)
+    });
   }
   return augmentedSixthFromSymbol(text, key);
 }
-function tonicizedKey(targetRoot, key) {
+function tonicizedKey(targetRoot, key, written) {
   return resolveKey({
     scale: majorKey(targetRoot),
-    tonic: spellPitchClass(targetRoot, key.tonic, key.scale)
+    tonic: written ?? spellPitchClass(targetRoot, key.tonic, key.scale)
   });
 }
 function augmentedSixthTarget(chord, key) {
@@ -1238,30 +1268,34 @@ function augmentedSixthTarget(chord, key) {
   return null;
 }
 function chordFromParsed(parsed) {
-  const chord = makeChord(parsed.rootPc, parsed.quality);
-  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = pitchClassOf(parsed.rootPc + (chord.intervals[parsed.inversion] ?? 0));
-  }
-  return chord;
+  const bassInterval = parsed.inversion > 0 ? QUALITY_INTERVALS[parsed.quality][parsed.inversion] : void 0;
+  return makeSpelledChord(parsed.rootPc, parsed.quality, {
+    bassPc: bassInterval === void 0 ? void 0 : pitchClassOf(parsed.rootPc + bassInterval),
+    rootSpelling: parsed.rootSpelling
+  });
 }
 function romanToChord(text, key) {
   const resolved = resolveKey(key);
-  const scale = resolved.scale;
+  if (typeof text !== "string") {
+    throw new InvalidInputError(
+      `Roman numeral must be a string; received ${describeRejected(text)}`
+    );
+  }
   const trimmed = text.trim().replace(/(\d)\/(?=\d)/g, "$1");
   const slash = trimmed.indexOf("/");
   if (slash >= 0) {
     const applied = trimmed.slice(0, slash);
     const target = trimmed.slice(slash + 1);
-    const targetRoot = parseSimpleRoman(target, scale).rootPc;
-    const localKey = tonicizedKey(targetRoot, resolved);
-    return chromaticSymbolChord(applied, localKey) ?? chordFromParsed(parseSimpleRoman(applied, localKey.scale));
+    const targetNumeral = parseSimpleRoman(target, resolved);
+    const localKey = tonicizedKey(targetNumeral.rootPc, resolved, targetNumeral.rootSpelling);
+    return chromaticSymbolChord(applied, localKey) ?? chordFromParsed(parseSimpleRoman(applied, localKey));
   }
-  return chromaticSymbolChord(trimmed, resolved) ?? chordFromParsed(parseSimpleRoman(trimmed, scale));
+  return chromaticSymbolChord(trimmed, resolved) ?? chordFromParsed(parseSimpleRoman(trimmed, resolved));
 }
 function romanStyle(quality) {
   return ROMAN_STYLE[quality];
 }
-function romanSpelling(rootPc, key) {
+function romanSpelling(rootPc, key, quality) {
   const tones = scaleTonesInDegreeOrder(romanReference(key));
   const diatonic = tones.indexOf(pitchClassOf(rootPc));
   if (diatonic >= 0) {
@@ -1273,7 +1307,7 @@ function romanSpelling(rootPc, key) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
-  for (let i = 0; i < tones.length; i += 1) {
+  for (let i = 0; i < tones.length && !LEADING_TONE_QUALITIES.has(quality); i += 1) {
     const degreeNumber2 = i + 1;
     if (degreeNumber2 === 1 || degreeNumber2 === 5) {
       continue;
@@ -1319,8 +1353,9 @@ function baseMarker(quality) {
 }
 var TRIAD_FIGURES = { 1: "6", 2: "64" };
 var SEVENTH_FIGURES = { 1: "65", 2: "43", 3: "42" };
-var TRIAD_FIGURE_QUALITIES = /* @__PURE__ */ new Set(["maj", "min", "dim", "aug"]);
-var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
+var TRIAD_FIGURE_QUALITY_NAMES = ["maj", "min", "dim", "aug"];
+var TRIAD_FIGURE_QUALITIES = new Set(TRIAD_FIGURE_QUALITY_NAMES);
+var SEVENTH_FIGURE_QUALITY_NAMES = [
   "maj7",
   "min7",
   "dom7",
@@ -1329,7 +1364,8 @@ var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
   "minMaj7",
   "aug7",
   "augMaj7"
-]);
+];
+var SEVENTH_FIGURE_QUALITIES = new Set(SEVENTH_FIGURE_QUALITY_NAMES);
 function numeralFor(degreeNumber, lower) {
   const glyph = ROMAN[degreeNumber - 1];
   if (glyph === void 0) {
@@ -1340,6 +1376,47 @@ function numeralFor(degreeNumber, lower) {
 function chordToRoman(chord, key, opts = {}) {
   return renderRoman(toChordData(chord), key, assertOptions(opts, "opts")).roman;
 }
+function readNumeral(chord, resolved, applied) {
+  const key = resolved.scale;
+  const written = writtenRoot(chord);
+  if (applied) {
+    const target = augmentedSixthTarget(chord, resolved) ?? (isAppliedDominant(chord, key) ? appliedChordTarget(chord, key) : null);
+    if (target !== null && leadsByLetter(chord, written, target, resolved)) {
+      return { kind: "applied", target };
+    }
+  }
+  return {
+    kind: "root",
+    ...writtenSpelling(chord.rootPc, written, resolved) ?? romanSpelling(chord.rootPc, key, chord.quality)
+  };
+}
+function writtenRoot(chord) {
+  const hint = chord.rootSpelling;
+  if (typeof hint !== "object" || hint === null || !Number.isInteger(hint.letter) || hint.letter < 0 || hint.letter > 6 || !Number.isInteger(hint.alter) || pitchClassOf(naturalPitchClassOf(hint.letter) + hint.alter) !== pitchClassOf(chord.rootPc)) {
+    return void 0;
+  }
+  return hint;
+}
+function writtenSpelling(rootPc, written, resolved) {
+  const tones = scaleTonesInDegreeOrder(romanReference(resolved.scale));
+  if (written === void 0 || tones.includes(pitchClassOf(rootPc))) {
+    return void 0;
+  }
+  const degreeNumber = diatonicLetterOf(written.letter - resolved.tonic.letter) + 1;
+  const degreePc = tones[degreeNumber - 1];
+  if (degreePc === void 0) {
+    return void 0;
+  }
+  const offset = pitchClassOf(rootPc - degreePc + 6) - 6;
+  return Math.abs(offset) > 1 ? void 0 : { degreeNumber, accidental: offset < 0 ? "b" : offset > 0 ? "#" : "" };
+}
+function leadsByLetter(chord, written, target, resolved) {
+  if (written === void 0 || !LEADING_TONE_QUALITIES.has(chord.quality)) {
+    return true;
+  }
+  const targetLetter = spellPitchClass(target.rootPc, resolved.tonic, resolved.scale).letter;
+  return diatonicLetterOf(targetLetter - written.letter) === 1;
+}
 function renderRoman(chord, keyLike, opts) {
   const resolved = resolveKey(keyLike);
   const key = resolved.scale;
@@ -1347,18 +1424,16 @@ function renderRoman(chord, keyLike, opts) {
   if (augmented !== null) {
     return { roman: augmented, derivation: { kind: "augmentedSixth" } };
   }
-  if (opts.applied === true) {
-    const target = augmentedSixthTarget(chord, resolved) ?? (isDiatonicChord(chord, key) ? null : appliedTarget(chord, key));
-    if (target !== null) {
-      const local = renderRoman(chord, tonicizedKey(target.rootPc, resolved), {}).roman;
-      const numeral = numeralFor(target.degreeNumber, target.lower);
-      return {
-        roman: `${local}/${numeral}`,
-        derivation: { kind: "applied", target: numeral }
-      };
-    }
+  const reading = readNumeral(chord, resolved, opts.applied === true);
+  if (reading.kind === "applied") {
+    const local = renderRoman(chord, tonicizedKey(reading.target.rootPc, resolved), {}).roman;
+    const numeral = numeralFor(reading.target.degreeNumber, reading.target.lower);
+    return {
+      roman: `${local}/${numeral}`,
+      derivation: { kind: "applied", target: numeral }
+    };
   }
-  const { degreeNumber, accidental: spelledAccidental } = romanSpelling(chord.rootPc, key);
+  const { degreeNumber, accidental: spelledAccidental } = reading;
   const { lower, suffix } = romanStyle(chord.quality);
   const cased = numeralFor(degreeNumber, lower);
   const accidental = seventhDegreeAccidental(spelledAccidental, degreeNumber, chord.quality, key);
@@ -1405,7 +1480,15 @@ function renderRoman(chord, keyLike, opts) {
     }
   };
 }
-var DEGREE_NAMES = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"];
+var DEGREE_NAMES = [
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh"
+];
 function describeDegree(degreeNumber, accidental, literal) {
   const name = DEGREE_NAMES[degreeNumber - 1] ?? `${degreeNumber}th`;
   if (accidental !== literal) {
@@ -1544,18 +1627,19 @@ function isMinorKey(key) {
   return isMinorScale(toKeyScale(key));
 }
 function functionOf(chord, key) {
-  return functionWithReason(toChordData(chord), toKeyScale(key)).function;
+  return functionWithReason(toChordData(chord), resolveKey(key)).function;
 }
 function degreeFunction(chord, key) {
   const functions = isMinorScale(key) ? MINOR_FUNCTION_BY_OFFSET : FUNCTION_BY_OFFSET;
   return functions[pitchClassOf(chord.rootPc - key.rootPc)] ?? "tonic";
 }
-function functionWithReason(chord, key) {
+function functionWithReason(chord, resolved) {
+  const key = resolved.scale;
   const offset = pitchClassOf(chord.rootPc - key.rootPc);
   if (isNeapolitanChordOf(chord, key)) {
     return { function: "subdominant", reason: "neapolitan" };
   }
-  if (augmentedSixthKindOf(chord, key) !== null) {
+  if (augmentedSixthKindOf(chord, resolved) !== null) {
     return { function: "subdominant", reason: "augmentedSixth" };
   }
   if (isAppliedDominant(chord, key)) {
@@ -1581,7 +1665,8 @@ function describeChord(fn, reason, roman, source) {
   const head = reason === "degree" ? `${capitalize(fn)}: ${roman} takes the ${fn} function of its degree in the key` : `${capitalize(fn)}: ${roman} is ${FUNCTION_REASON_PHRASE[reason]}`;
   return source === null || reason === "neapolitan" ? head : `${head}, ${BORROWED_SOURCE_PHRASE[source]}`;
 }
-function functionAlternatives(chord, key, reason, accepted) {
+function functionAlternatives(chord, resolved, reason, accepted) {
+  const key = resolved.scale;
   const out = [];
   if (reason === "degree") {
     if (pointsAtTonicizableDegree(chord, key) && isDiatonicChord(chord, key)) {
@@ -1599,7 +1684,7 @@ function functionAlternatives(chord, key, reason, accepted) {
       });
     }
   }
-  if (augmentedSixthKindOf(chord, key) === "german") {
+  if (augmentedSixthKindOf(chord, resolved) === "german") {
     out.push({
       label: "tritone substitute",
       reason: "The German sixth sounds a dominant seventh, but the lowered submediant under it fixes the reading as an augmented sixth"
@@ -1616,10 +1701,10 @@ function parallelKey(key) {
 function analyzeChord(chord, key, opts = {}) {
   const asked = assertOptions(opts, "opts");
   const data = toChordData(chord);
-  const scale = toKeyScale(key);
-  const source = borrowedSourceOf(data, scale);
-  const { function: fn, reason } = functionWithReason(data, scale);
-  const roman = renderRoman(data, scale, asked).roman;
+  const resolved = resolveKey(key);
+  const source = borrowedSourceOf(data, resolved.scale);
+  const { function: fn, reason } = functionWithReason(data, resolved);
+  const roman = renderRoman(data, resolved, asked).roman;
   return {
     function: fn,
     borrowed: source !== null,
@@ -1627,43 +1712,41 @@ function analyzeChord(chord, key, opts = {}) {
     roman,
     rationale: describeChord(fn, reason, roman, source),
     alternatives: asked.alternatives === true ? [
-      ...functionAlternatives(data, scale, reason, fn),
-      ...romanAlternatives(data, scale, asked)
+      ...functionAlternatives(data, resolved, reason, fn),
+      ...romanAlternatives(data, resolved, asked)
     ] : []
   };
 }
 function secondaryDominant(targetDegree, key) {
-  const scale = toKeyScale(key);
+  const resolved = resolveKey(key);
+  const scale = resolved.scale;
   const degreeCount = scaleTonesInDegreeOrder(scale).length;
   assertInteger(targetDegree, "targetDegree", 1, degreeCount);
   const targetRoot = degreeRootPc(targetDegree, scale);
-  return makeChord(pitchClassOf(targetRoot + 7), "dom7");
+  const rootSpelling = transposeByInterval(keySpelling(targetRoot, resolved), "P5");
+  return makeSpelledChord(pitchClassOf(targetRoot + 7), "dom7", { rootSpelling });
 }
 function secondaryDominantOf(target) {
   const data = toChordData(target);
   assertFiniteNumber(data.rootPc, "target chord rootPc");
-  const dominant = makeChord(pitchClassOf(data.rootPc + 7), "dom7");
-  if (data.rootSpelling !== void 0) {
-    const moved = transposeNote(data.rootSpelling, 7);
-    dominant.rootSpelling = { letter: moved.letter, alter: moved.alter };
-  }
-  return dominant;
+  const rootSpelling = data.rootSpelling === void 0 ? void 0 : transposeNote(data.rootSpelling, 7);
+  return makeSpelledChord(pitchClassOf(data.rootPc + 7), "dom7", { rootSpelling });
 }
 
 // src/analyze/functional/pivot.ts
 var HEPTATONIC_DEGREES = 7;
 function pivotChords(from, to) {
-  return pivotsBetween(toKeyScale(from), toKeyScale(to));
+  return pivotsBetween(resolveKey(from), resolveKey(to));
 }
 function pivotsBetween(from, to) {
-  if (scaleTonesInDegreeOrder(from).length !== HEPTATONIC_DEGREES) {
+  if (scaleTonesInDegreeOrder(from.scale).length !== HEPTATONIC_DEGREES) {
     return [];
   }
   const pivots = [];
   const seen = /* @__PURE__ */ new Set();
   for (let degree = 1; degree <= HEPTATONIC_DEGREES; degree += 1) {
     const chord = stackedTriad(degree, from);
-    if (chord === null || !isDiatonicChord(chord, to)) {
+    if (chord === null || !isDiatonicChord(chord, to.scale)) {
       continue;
     }
     const identity = `${chord.rootPc}:${chord.quality}`;
@@ -1714,6 +1797,14 @@ function firstSoundingBeat(notes, fallback = 0) {
   }
   return Number.isFinite(first) ? first : fallback;
 }
+function resolveSpanEnd(totalBeats, startBeat, soundingEnd, name) {
+  const given = totalBeats ?? null;
+  if (given === null) {
+    return Math.max(startBeat, soundingEnd);
+  }
+  assertRange(given, Math.min(0, startBeat), Number.MAX_SAFE_INTEGER, name);
+  return Math.max(startBeat, given);
+}
 function lastBarOf(meter, spanStart, spanEnd) {
   const firstBar = barIndexAt(spanStart, meter);
   const bar = barIndexAt(Math.max(spanStart, spanEnd), meter);
@@ -1795,6 +1886,16 @@ function gridOriginOf(firstOnset, slotBeats) {
 function gridForNotes(notes, slotBeats) {
   return gridOriginOf(firstSoundingBeat(notes), slotBeats);
 }
+function latestSoundingEnd(notes, fallback = 0) {
+  if (notes.length === 0) {
+    return fallback;
+  }
+  let end = Number.NEGATIVE_INFINITY;
+  for (const note of notes) {
+    end = Math.max(end, note.startBeat + note.durationBeat);
+  }
+  return end;
+}
 function barGridStart(firstOnset, meter) {
   return gridOriginOf(firstOnset, beatsPerBarAt(firstOnset, meter)).startBeat;
 }
@@ -2085,9 +2186,13 @@ function keyTimelineFromNotes(notes, opts = {}) {
   const budget = opts.budget;
   assertNoteEvents(notes, "key timeline notes", { allowNonPositiveDuration: true, budget });
   const sounding = notes.filter((note) => note.durationBeat > 0);
-  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const totalBeats = opts.totalBeats ?? lastEnd;
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
+  const totalBeats = opts.totalBeats ?? latestSoundingEnd(sounding);
+  assertRange(
+    totalBeats,
+    Math.min(0, firstSoundingBeat(sounding)),
+    Number.MAX_SAFE_INTEGER,
+    "key timeline totalBeats"
+  );
   const slotBeats = Math.min(minKeyBeats, expectedKeyBeats);
   const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
   const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - BEAT_EPS));
@@ -2223,9 +2328,10 @@ function detectModulations(chords, opts = {}) {
     opts.budget
   );
   const sorted = [...chords].filter((segment) => segment.endBeat > segment.startBeat).sort((a, b) => a.startBeat - b.startBeat);
-  const lastChordEnd = sorted.reduce((end, segment) => Math.max(end, segment.endBeat), 0);
+  const lastChordEnd = sorted.length === 0 ? 0 : sorted.reduce((end, segment) => Math.max(end, segment.endBeat), Number.NEGATIVE_INFINITY);
   const totalBeats = opts.totalBeats ?? lastChordEnd;
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
+  const lowest = totalBeats < 0 ? Math.min(0, sorted[0]?.startBeat ?? 0) : 0;
+  assertRange(totalBeats, lowest, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
   const ordered = sorted.map((segment) => ({ ...segment, endBeat: Math.min(segment.endBeat, totalBeats) })).filter((segment) => segment.endBeat > segment.startBeat);
   if (ordered.length === 0) {
     return [];
@@ -2422,7 +2528,7 @@ function prevailingKeyOf(regions) {
 // src/analyze/voice/index.ts
 function keyScaleAt(key) {
   if (typeof key === "function") {
-    return key;
+    return (beat) => toKeyScale(key(beat));
   }
   const scale = toKeyScale(key);
   return () => scale;
@@ -2451,7 +2557,8 @@ var TENSION_DEGREE_BY_INTERVAL = {
   8: 13,
   9: 13
 };
-var NATURAL_TENSION_INTERVALS = /* @__PURE__ */ new Set([2, 5, 9]);
+var NATURAL_TENSION_INTERVAL_LIST = [2, 5, 9];
+var NATURAL_TENSION_INTERVALS = new Set(NATURAL_TENSION_INTERVAL_LIST);
 function tensionDegree(ic) {
   return TENSION_DEGREE_BY_INTERVAL[ic];
 }
@@ -2466,11 +2573,22 @@ function isStep(a, b) {
   return d === 1 || d === 2;
 }
 var LEAP_SEMITONES = 3;
-function suspensionType(ic, delta) {
+function suspensionType(ic, delta, resolvedIc) {
+  const figure = suspendedFigure(ic, delta);
+  return figure !== null && SUSPENSION_RESOLUTIONS[figure].includes(resolvedIc) ? figure : null;
+}
+var SUSPENSION_RESOLUTIONS = {
+  "sus4-3": [3, 4],
+  "sus6-5": [7],
+  "sus7-6": [8, 9],
+  "sus9-8": [0],
+  "sus2-3": [3, 4]
+};
+function suspendedFigure(ic, delta) {
   if (delta > 0) {
     return ic === 1 || ic === 2 ? "sus2-3" : null;
   }
-  if (ic === 2) {
+  if (ic === 1 || ic === 2) {
     return "sus9-8";
   }
   if (ic === 10 || ic === 11) {
@@ -2484,6 +2602,18 @@ function suspensionType(ic, delta) {
   }
   return null;
 }
+function clashesWithChord(pitch, chord) {
+  if (!isConsonantInterval(intervalAboveBass(pitch, [], chord), true)) {
+    return true;
+  }
+  const tones = chord.intervals.map((interval) => chord.rootPc + interval);
+  if (chord.bassPc !== void 0) {
+    tones.push(chord.bassPc);
+  }
+  return tones.some(
+    (tone) => !isConsonantInterval(((pitchClassOf(pitch) - tone) % 12 + 12) % 12, false)
+  );
+}
 var STEP_RESOLUTION = 2;
 var NEAREST_CHORD_TONE_REACH = 12;
 function nearestChordTone(pitch, chord, maxDistance) {
@@ -2503,17 +2633,20 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
   assertFunction(otherVoicesAtBeat, "otherVoicesAtBeat");
   const keyAt = keyScaleAt(key);
   const result = [];
+  const sounding = soundingIndices(voice);
+  const line = new Map(sounding.map((index, position) => [index, position]));
   for (let i = 0; i < voice.length; i += 1) {
     const note = voice[i];
     if (!note) {
       continue;
     }
-    const prevNote = i > 0 ? voice[i - 1] : void 0;
-    const nextNote = i + 1 < voice.length ? voice[i + 1] : void 0;
-    const prevEnd = prevNote === void 0 ? Number.NEGATIVE_INFINITY : prevNote.startBeat + prevNote.durationBeat;
-    const noteEnd = note.startBeat + note.durationBeat;
-    const prev = prevNote !== void 0 && adjacent(prevEnd, note.startBeat) ? prevNote : void 0;
-    const next = nextNote !== void 0 && adjacent(noteEnd, nextNote.startBeat) ? nextNote : void 0;
+    const position = line.get(i);
+    const prevIndex = position === void 0 ? void 0 : sounding[position - 1];
+    const nextIndex = position === void 0 ? void 0 : sounding[position + 1];
+    const prevNote = prevIndex === void 0 ? void 0 : voice[prevIndex];
+    const nextNote = nextIndex === void 0 ? void 0 : voice[nextIndex];
+    const prev = prevNote !== void 0 && !sameInstant(prevNote.startBeat, note.startBeat) && adjacent(prevNote.startBeat + prevNote.durationBeat, note.startBeat) ? prevNote : void 0;
+    const next = nextNote !== void 0 && !sameInstant(nextNote.startBeat, note.startBeat) && adjacent(note.startBeat + note.durationBeat, nextNote.startBeat) ? nextNote : void 0;
     const chord = chordAtBeat2(note.startBeat);
     const labels = [];
     const member = isChordMember(note.pitch, chord);
@@ -2540,12 +2673,11 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       const prepared = prev.pitch === note.pitch && isChordMember(prev.pitch, prevChord);
       const resolves = isStep(next.pitch, note.pitch);
       const others = otherVoicesAtBeat(note.startBeat);
-      const verticallyDissonant = others.some(
-        (ov) => createsVerticalDissonance(note.pitch, ov.pitch, true)
-      );
+      const verticallyDissonant = others.length > 0 ? others.some((ov) => createsVerticalDissonance(note.pitch, ov.pitch, true)) : clashesWithChord(note.pitch, chord);
       if (prepared && verticallyDissonant && resolves) {
         const ic = intervalAboveBass(note.pitch, others, chord);
-        const type = suspensionType(ic, next.pitch - note.pitch);
+        const resolvedIc = intervalAboveBass(next.pitch, others, chord);
+        const type = suspensionType(ic, next.pitch - note.pitch, resolvedIc);
         if (type !== null) {
           labels.push({ kind: "suspension", type, resolveTo: next.pitch });
           handled = true;
@@ -2675,8 +2807,34 @@ function assertChordTimeline(timeline, name = "timeline") {
     assertFiniteNumber(segment.startBeat, `${name}.segments[${index}].startBeat`);
     assertFiniteNumber(segment.endBeat, `${name}.segments[${index}].endBeat`);
   }
+  assertSpansInOrder(segments, `${name}.segments`);
   return read;
 }
+function assertSpansInOrder(spans, name) {
+  for (let index = 0; index < spans.length; index += 1) {
+    const span = spans[index];
+    if (span === void 0) {
+      continue;
+    }
+    if (!(span.endBeat > span.startBeat)) {
+      throw new InvalidInputError(
+        `${name}[${index}] must end after it starts; received [${span.startBeat}, ${span.endBeat})`
+      );
+    }
+    const previous = spans[index - 1];
+    if (previous !== void 0 && span.startBeat < previous.endBeat) {
+      throw new InvalidInputError(
+        `${name}[${index}] must not start before ${name}[${index - 1}] ends; received ${span.startBeat} before ${previous.endBeat}`
+      );
+    }
+  }
+}
+function statedKeyRegions(key, startBeat, endBeat) {
+  if (!(endBeat > startBeat)) {
+    return [];
+  }
+  return [{ startBeat, endBeat, key, confidence: 1 }];
+}
 function chordTimelineFromChords(chords, totalBeats) {
   assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
   assertArray(chords, "chords");
@@ -2741,6 +2899,7 @@ var EXTRA_TONE_PENALTY = 0.6;
 var OMITTED_TONE_PENALTY = 0.15;
 var BASS_ROOT_STANDING = 0.95;
 var OCTAVE = 12;
+var CHORD_SEGMENTATIONS = ["dynamic", "grid"];
 function scoreMatch(match, weights, maxWeight, key, pedalPc) {
   const rootWeight = maxWeight > 0 ? (weights[match.rootPc] ?? 0) / maxWeight : 0;
   const rootStanding = match.inversion === 0 ? Math.max(rootWeight, BASS_ROOT_STANDING) : rootWeight;
@@ -2757,7 +2916,10 @@ function scoreMatch(match, weights, maxWeight, key, pedalPc) {
   score -= OMITTED_TONE_PENALTY * account.missing;
   return score;
 }
-var SLASH_UPPER_QUALITIES = /* @__PURE__ */ new Set(["maj", "min"]);
+var SLASH_UPPER_QUALITY_LIST = ["maj", "min"];
+var SLASH_UPPER_QUALITIES = new Set(
+  SLASH_UPPER_QUALITY_LIST
+);
 function isSlashReading(match, pedalPc) {
   return pedalPc !== null && match.inversion === null && match.missingPcs.length === 0 && match.extraPcs.length === 1 && match.extraPcs[0] === pedalPc && SLASH_UPPER_QUALITIES.has(match.quality);
 }
@@ -2789,6 +2951,30 @@ function bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) {
   }
   return highestBass <= upperFloor;
 }
+function windowBass(notes, windowStart, windowEnd, meters, harmonicRhythm) {
+  const counted = [];
+  let firstSounding = Number.POSITIVE_INFINITY;
+  for (const note of notes) {
+    const overlap = Math.min(note.startBeat + note.durationBeat, windowEnd) - Math.max(note.startBeat, windowStart);
+    if (overlap <= BEAT_EPS) {
+      continue;
+    }
+    const onsetInWindow = note.startBeat >= windowStart - BEAT_EPS && note.startBeat < windowEnd - BEAT_EPS;
+    if (noteWeight(note, overlap, onsetInWindow ? meters : void 0) <= BEAT_EPS) {
+      continue;
+    }
+    counted.push({ note, overlap });
+    firstSounding = Math.min(firstSounding, Math.max(note.startBeat, windowStart));
+  }
+  const half = (windowEnd - windowStart) / 2;
+  let bass = Number.POSITIVE_INFINITY;
+  for (const { note, overlap } of counted) {
+    if (note.startBeat <= firstSounding + BEAT_EPS || overlap > half || overlap >= harmonicRhythm - BEAT_EPS) {
+      bass = Math.min(bass, note.pitch);
+    }
+  }
+  return bass;
+}
 function chordConfidence(chord, weights, totalWeight, exact) {
   const tones = new Set(chordPitchClasses(chord));
   let chordWeight = 0;
@@ -2801,23 +2987,20 @@ function chordConfidence(chord, weights, totalWeight, exact) {
   const confidence = Math.min(1, Math.max(0, raw));
   return exact ? confidence : confidence * INEXACT_CONFIDENCE_FACTOR;
 }
-function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
-  const { weights, totalWeight, maxWeight, lowestPitch } = windowWeights(
-    notes,
-    windowStart,
-    windowEnd,
-    meters
-  );
+function analyzeWindow(notes, windowStart, windowEnd, meters, key, harmonicRhythm) {
+  const { weights, totalWeight, maxWeight } = windowWeights(notes, windowStart, windowEnd, meters);
   if (totalWeight <= BEAT_EPS) {
     return null;
   }
   const ranked = weights.map((weight, pc) => ({ pc, weight })).filter(({ weight }) => weight > 0).sort((a, b) => b.weight - a.weight || a.pc - b.pc);
-  const selected = ranked.filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO).slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
-  const bassPc = pitchClassOf(lowestPitch);
-  const hasBass = selected.includes(bassPc);
-  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
-  const pedalPc = hasBass && bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) ? bassPc : null;
-  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
+  const bassPc = pitchClassOf(windowBass(notes, windowStart, windowEnd, meters, harmonicRhythm));
+  const sounding = ranked.slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
+  const significant = ranked.filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO).slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
+  let detection = detectWindow(significant, bassPc, notes, windowStart, windowEnd);
+  if (detection.matches.length === 0 && significant.length < sounding.length) {
+    detection = detectWindow(sounding, bassPc, notes, windowStart, windowEnd);
+  }
+  const { selected, hasBass, pedalPc, matches } = detection;
   let bestMatch = null;
   let bestScore = Number.NEGATIVE_INFINITY;
   for (const match of matches) {
@@ -2834,10 +3017,26 @@ function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
       makeChord(bestMatch.rootPc, bestMatch.quality),
       pedalPc
     );
+    const explained = account.exact || isSlashReading(bestMatch, pedalPc);
     const reading = {
       chord: shared(chord),
-      confidence: chordConfidence(chord, weights, totalWeight, account.exact)
+      confidence: chordConfidence(chord, weights, totalWeight, explained)
     };
+    if (bestMatch.quality === SYMMETRIC_QUALITY) {
+      reading.rootings = chordPitchClasses(makeChord(bestMatch.rootPc, bestMatch.quality)).map(
+        (rootPc) => {
+          const rooted = makeChord(
+            rootPc,
+            bestMatch.quality,
+            hasBass && bassPc !== rootPc ? bassPc : void 0
+          );
+          return {
+            chord: shared(rooted),
+            confidence: chordConfidence(rooted, weights, totalWeight, explained)
+          };
+        }
+      );
+    }
     const augmented = hasBass ? augmentedSixthFromPitchClasses(selected, bassPc, key) : null;
     if (augmented !== null) {
       reading.augmented = {
@@ -2849,6 +3048,13 @@ function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
   }
   return null;
 }
+function detectWindow(selected, bassPc, notes, windowStart, windowEnd) {
+  const hasBass = selected.includes(bassPc);
+  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
+  const pedalPc = hasBass && bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) ? bassPc : null;
+  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
+  return { selected, hasBass, pedalPc, matches };
+}
 function shared(chord) {
   Object.freeze(chord.intervals);
   return Object.freeze(chord);
@@ -2875,6 +3081,29 @@ function resolvesOntoDominant(readings, index, key) {
   }
   return true;
 }
+var SYMMETRIC_QUALITY = "dim7";
+function settledDiminishedRoot(readings, index, key) {
+  const reading = readings[index];
+  const rootings = reading?.rootings;
+  if (!reading || rootings === void 0) {
+    return null;
+  }
+  const roots = rootings.map((rooting) => rooting.chord.rootPc);
+  const tones = chordPitchClasses(reading.chord).join();
+  for (let i = index + 1; i < readings.length; i += 1) {
+    const next = readings[i];
+    if (!next || chordPitchClasses(next.chord).join() === tones) {
+      continue;
+    }
+    const leading = pitchClassOf(next.chord.rootPc - 1);
+    if (roots.includes(leading)) {
+      return leading;
+    }
+    break;
+  }
+  const leadingTone = pitchClassOf(key.rootPc - 1);
+  return roots.includes(leadingTone) ? leadingTone : null;
+}
 function sameChord(a, b) {
   return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;
 }
@@ -3123,7 +3352,11 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
   const meters = resolveMeters(opts, "timeline meters");
   const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBarAt(0, meters);
   assertRange(harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
-  const segmentation = opts.segmentation ?? "dynamic";
+  const segmentation = assertOneOf(
+    opts.segmentation ?? "dynamic",
+    CHORD_SEGMENTATIONS,
+    "timeline segmentation"
+  );
   const gridUnit = metricGridUnit(meters);
   const minChordBeats = opts.minChordBeats ?? gridUnit;
   assertRange(minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
@@ -3135,9 +3368,13 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
   }
   assertNoteEvents(notes, "timeline notes", noteOptions);
   const sounding = sortedNoteEvents(notes.filter((note) => note.durationBeat > 0));
-  const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const totalBeats = opts.totalBeats ?? lastNoteEnd;
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  const totalBeats = opts.totalBeats ?? latestSoundingEnd(sounding);
+  assertRange(
+    totalBeats,
+    Math.min(0, firstSoundingBeat(sounding)),
+    Number.MAX_SAFE_INTEGER,
+    "timeline totalBeats"
+  );
   const slotBeats = segmentation === "grid" ? harmonicRhythm : slotBeatsWithin(gridUnit, minChordBeats, harmonicRhythm);
   const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
   const grid = { origin, slotBeats };
@@ -3148,14 +3385,7 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     "timeline windows",
     budget
   );
-  const keys = opts.key !== void 0 ? [
-    {
-      startBeat: musicStart,
-      endBeat: totalBeats,
-      key: resolveKey(opts.key),
-      confidence: 1
-    }
-  ] : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
+  const keys = opts.key !== void 0 ? statedKeyRegions(resolveKey(opts.key), musicStart, totalBeats) : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
   const prevailingKey = prevailingKeyOf(keys) ?? resolveKey(majorKey(0));
   const keyAt = keyLookup(keys, prevailingKey);
   const scaleAt = (beat) => scaleOf(keyAt(beat));
@@ -3211,12 +3441,27 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     const spanKeyWhole = keyAt(start);
     const id = windowId(start, end, spanKey);
     const cached = carried !== void 0 && spanIsClean(grid, span, dirtyFrom, dirtyTo) ? carried.windows.get(id) : void 0;
-    const inferred = cached !== void 0 ? cached : analyzeWindow(notesOfSpan(slotNotes, span, grid), start, end, meters, spanKeyWhole);
+    const inferred = cached !== void 0 ? cached : analyzeWindow(
+      notesOfSpan(slotNotes, span, grid),
+      start,
+      end,
+      meters,
+      spanKeyWhole,
+      harmonicRhythm
+    );
     windows.set(id, inferred);
     readings.push(inferred);
     readingKeys.push(spanKey);
     readingBounds.push({ start, end });
   }
+  for (let i = readings.length - 1; i >= 0; i -= 1) {
+    const spanKey = readingKeys[i];
+    const root = spanKey === void 0 ? null : settledDiminishedRoot(readings, i, spanKey);
+    const rooting = readings[i]?.rootings?.find((option) => option.chord.rootPc === root);
+    if (rooting !== void 0 && root !== readings[i]?.chord.rootPc) {
+      readings[i] = rooting;
+    }
+  }
   for (let i = 0; i < readings.length; i += 1) {
     const offered = readings[i]?.augmented;
     const spanKey = readingKeys[i];
@@ -3369,11 +3614,7 @@ function roundTo(value, digits) {
   return Math.round(value * scale) / scale;
 }
 function endBeatOf(notes) {
-  let end = 0;
-  for (const note of notes) {
-    end = Math.max(end, note.startBeat + note.durationBeat);
-  }
-  return end;
+  return latestSoundingEnd(notes);
 }
 function onsetSpan(notes) {
   if (notes.length < 2) {
@@ -3439,7 +3680,7 @@ function melodicContour(notes) {
       peakIndex: peak,
       troughIndex: trough,
       range,
-      rationale: `${share}% of the motion runs ${net > 0 ? "up" : "down"}, so the line is ${shape}`
+      rationale: `The net ${net > 0 ? "rise" : "fall"} is ${share}% of the motion, so the line is ${shape}`
     };
   }
   const peakPitch = line[peak]?.pitch ?? 0;
@@ -3460,7 +3701,7 @@ function melodicContour(notes) {
     peakIndex: peak,
     troughIndex: trough,
     range,
-    rationale: `Changes direction without settling either way (${share}% of the motion nets out), so the line is a wave`
+    rationale: `Changes direction without settling either way (the net movement is ${share}% of the motion), so the line is a wave`
   };
 }
 
@@ -3640,8 +3881,8 @@ function spellingOf(key) {
   return keySignatureFifths(key.tonic, key.scale) < 0 ? "flat" : "sharp";
 }
 function intervalBetween(from, to, key) {
-  const spelling = spellingOf(key);
-  return spelledInterval(midiToNote(from, spelling), midiToNote(to, spelling));
+  const start = midiToNote(from, spellingOf(key));
+  return spelledInterval(start, transposeNote(start, to - from));
 }
 function intervalName(interval) {
   return `${interval.descending && interval.semitones !== 0 ? "-" : ""}${interval.quality}${interval.number}`;
@@ -3771,11 +4012,12 @@ function relateMotifs(a, b, keyLike) {
       }
     }
   }
-  if (forward && shapes.includes("inversion")) {
+  const literalRetrograde = backward && shapes.includes("retrograde") && answer[0]?.pitch === model[model.length - 1]?.pitch;
+  if (forward && shapes.includes("inversion") && !(literalRetrograde && semitones !== 0)) {
     return {
       ...base,
       kind: "inversion",
-      rationale: "Inversion: every interval turned upside down about the first note" + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
+      rationale: `Inversion: every interval turned upside down${semitones === 0 ? " about the first note" : ""}` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
     };
   }
   if (backward && shapes.includes("retrograde")) {
@@ -3839,6 +4081,7 @@ function compareMelodies(a, b) {
   const right = orderedNotes(phraseNotes(b), "melody b");
   const leftIntervals = intervalsOf(left);
   const rightIntervals = intervalsOf(right);
+  assertGenerationBudget(leftIntervals.length * rightIntervals.length, "melody alignment");
   const pitchSimilarity = distanceToSimilarity(
     gradedEditDistance(leftIntervals, rightIntervals, intervalCost),
     leftIntervals.length,
@@ -3953,7 +4196,13 @@ function motifGraph(line, motifs, opts = {}) {
 
 // src/analyze/reduction/index.ts
 var REDUCTION_LEVELS = Object.freeze(["structural", "passing", "neighbor"]);
-var TONIC_ARRIVING = /* @__PURE__ */ new Set(["authentic", "plagal", "modal", "deceptive"]);
+var TONIC_ARRIVING_CADENCES = [
+  "authentic",
+  "plagal",
+  "modal",
+  "deceptive"
+];
+var TONIC_ARRIVING = new Set(TONIC_ARRIVING_CADENCES);
 function signedStep(fromPc, toPc) {
   return (pitchClassOf(toPc) - pitchClassOf(fromPc) + 18) % 12 - 6;
 }
@@ -4104,6 +4353,11 @@ function reduceProgression(timeline, key, opts = {}) {
   return result;
 }
 
+// src/analyze/reference/types.ts
+var REFERENCE_PROFILE_VERSION = 1;
+var PHRASE_OUTLINE_POINTS = 8;
+var MIDI_MAX = 127;
+
 // src/analyze/rhythm/internal.ts
 function isMultipleOf(value, unit) {
   if (unit <= 0) {
@@ -4122,9 +4376,15 @@ function rhythmLevel(beatInQuarters, meters) {
   const subUnit = pulse / (isCompound(ts) ? 3 : 2);
   return isMultipleOf(offset, subUnit) ? 1 : 0;
 }
+var IOI_MIN_EXPONENT = -4;
+var IOI_MAX_EXPONENT = 4;
+var IOI_EXPONENT_STEP = 0.5;
 function ioiBinIndex(ioi) {
-  const exponent = Math.min(4, Math.max(-4, Math.round(2 * Math.log2(ioi)) / 2));
-  return Math.round((exponent + 4) / 0.5);
+  const exponent = Math.min(
+    IOI_MAX_EXPONENT,
+    Math.max(IOI_MIN_EXPONENT, Math.round(2 * Math.log2(ioi)) / 2)
+  );
+  return Math.round((exponent - IOI_MIN_EXPONENT) / IOI_EXPONENT_STEP);
 }
 
 // src/analyze/rhythm/index.ts
@@ -4134,6 +4394,8 @@ var RHYTHM_OFF_GRID_TOLERANCE = 1 / 32;
 var RHYTHM_IOI_BINS = Object.freeze(
   Array.from({ length: 17 }, (_, i) => 2 ** (-4 + i * 0.5))
 );
+var BUDGET_SLOTS_PER_BAR = 48;
+var RHYTHM_LEVEL_COUNT = 6;
 function emptyAnalysis() {
   return {
     startBeat: 0,
@@ -4142,7 +4404,7 @@ function emptyAnalysis() {
     onsets: 0,
     onsetDensity: 0,
     barOnsets: [],
-    onsetLevels: new Array(6).fill(0),
+    onsetLevels: new Array(RHYTHM_LEVEL_COUNT).fill(0),
     barPositions: [],
     interOnsetShares: new Array(RHYTHM_IOI_BINS.length).fill(0),
     restRatio: 0,
@@ -4177,13 +4439,47 @@ function snapOnset(onset, meters) {
 function tsKey(ts) {
   return ts.grouping === void 0 ? `${ts.numerator}/${ts.denominator}` : `${ts.numerator}/${ts.denominator}:${ts.grouping.join("+")}`;
 }
-function barGridBeats(bar, meters) {
+function pulseKey(bar, index) {
+  return `${bar}/${index}`;
+}
+function otherDivisionPulses(snapped, meters) {
+  const pulses = /* @__PURE__ */ new Set();
+  for (const onset of snapped) {
+    const pulse = pulseBeats(onset.ts);
+    const offset = onset.snapped - onset.barStart;
+    const index = Math.floor(offset / pulse + BEAT_EPS);
+    const within = offset - index * pulse;
+    const [used, other] = isCompound(onset.ts) ? [3, 2] : [2, 3];
+    if (isMultipleOf(within, pulse / other) && !isMultipleOf(within, pulse / used)) {
+      pulses.add(pulseKey(barIndexAt(onset.beat, meters), index));
+    }
+  }
+  return pulses;
+}
+function barGridPoints(bar, meters, otherPulses) {
   const barStart = barPositionToBeat({ bar, beat: 0 }, meters);
   const ts = meterAt(barStart, meters);
   const barLength = beatsPerBarAt(barStart, meters);
-  const subUnit = pulseBeats(ts) / (isCompound(ts) ? 3 : 2);
+  const pulse = pulseBeats(ts);
+  const [used, other] = isCompound(ts) ? [3, 2] : [2, 3];
+  const subUnit = pulse / used;
   const steps = Math.max(1, Math.round(barLength / subUnit));
-  return Array.from({ length: steps }, (_, k) => barStart + k * subUnit);
+  const points = [];
+  for (let k = 0; k < steps; k += 1) {
+    const index = Math.floor(k * subUnit / pulse + BEAT_EPS);
+    if (k % used === 0 || !otherPulses.has(pulseKey(bar, index))) {
+      const beat = barStart + k * subUnit;
+      points.push({ beat, level: rhythmLevel(beat, meters) });
+    }
+  }
+  for (let index = 0; index * pulse < steps * subUnit - BEAT_EPS; index += 1) {
+    if (otherPulses.has(pulseKey(bar, index))) {
+      for (let m = 1; m < other; m += 1) {
+        points.push({ beat: barStart + index * pulse + m * pulse / other, level: 1 });
+      }
+    }
+  }
+  return points.sort((a, b) => a.beat - b.beat);
 }
 function restRatioOf(sounding, windowStart, windowEnd) {
   const span = windowEnd - windowStart;
@@ -4219,11 +4515,12 @@ function syncopationOf(snapped, startBeat, endBeat, meters) {
   }
   const firstBar = barIndexAt(startBeat, meters);
   const lastBar = barIndexAt(endBeat, meters);
+  const otherPulses = otherDivisionPulses(snapped, meters);
   const points = [];
   for (let bar = firstBar; bar <= lastBar; bar += 1) {
-    for (const beat of barGridBeats(bar, meters)) {
-      if (beat > startBeat + BEAT_EPS && beat <= endBeat + BEAT_EPS) {
-        points.push({ beat, level: rhythmLevel(beat, meters) });
+    for (const point of barGridPoints(bar, meters, otherPulses)) {
+      if (point.beat > startBeat + BEAT_EPS && point.beat <= endBeat + BEAT_EPS) {
+        points.push(point);
       }
     }
   }
@@ -4243,36 +4540,44 @@ function syncopationOf(snapped, startBeat, endBeat, meters) {
     while (ptr < points.length && (points[ptr]?.beat ?? Number.POSITIVE_INFINITY) <= onset.snapped + BEAT_EPS) {
       ptr += 1;
     }
+    const here = ptr > 0 ? points[ptr - 1] : void 0;
+    const onsetLevel = here !== void 0 && Math.abs(here.beat - onset.snapped) < BEAT_EPS ? Math.max(onset.level, here.level) : onset.level;
     let scan = ptr;
     let maxLevel = 0;
     while (scan < points.length && (points[scan]?.beat ?? Number.POSITIVE_INFINITY) < windowEnd - BEAT_EPS) {
       maxLevel = Math.max(maxLevel, points[scan]?.level ?? 0);
       scan += 1;
     }
-    if (maxLevel > onset.level) {
-      numerator += maxLevel - onset.level;
+    if (maxLevel > onsetLevel) {
+      numerator += maxLevel - onsetLevel;
     }
     ptr = scan;
   }
   return numerator / normalizer;
 }
 function analyzeRhythm(notes, opts = {}) {
+  return rhythmOver(notes, opts, void 0);
+}
+function rhythmOver(notes, opts, windowStart) {
   const meters = resolveMeters(opts, "rhythm meters");
   assertNoteEvents(notes, "rhythm notes", { allowNonPositiveDuration: true, budget: opts.budget });
   const sounding = notes.filter((note) => note.durationBeat > 0);
+  const startBeat = windowStart ?? barGridStart(firstSoundingBeat(sounding), meters);
+  const endBeat = resolveSpanEnd(
+    opts.totalBeats,
+    startBeat,
+    latestSoundingEnd(sounding),
+    "rhythm totalBeats"
+  );
   if (sounding.length === 0) {
     return emptyAnalysis();
   }
-  const firstOnset = sounding.reduce(
-    (min, n) => Math.min(min, n.startBeat),
-    Number.POSITIVE_INFINITY
-  );
-  const startBeat = barGridStart(firstOnset, meters);
-  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const endBeat = Math.max(startBeat, opts.totalBeats ?? lastEnd);
-  assertRange(endBeat, 0, Number.MAX_SAFE_INTEGER, "rhythm totalBeats");
   const bars = barSpanOf(startBeat, endBeat, meters);
-  assertGenerationBudget(Math.ceil(bars) * 48, "rhythm analysis slots", opts.budget);
+  assertGenerationBudget(
+    Math.ceil(bars) * BUDGET_SLOTS_PER_BAR,
+    "rhythm analysis slots",
+    opts.budget
+  );
   const onsets = foldOnsets(sounding);
   const snapped = onsets.map((onset) => snapOnset(onset, meters));
   const onsetDensity = bars > 0 ? onsets.length / bars : 0;
@@ -4284,7 +4589,7 @@ function analyzeRhythm(notes, opts = {}) {
       barOnsets[index] = (barOnsets[index] ?? 0) + 1;
     }
   }
-  const onsetLevels = new Array(6).fill(0);
+  const onsetLevels = new Array(RHYTHM_LEVEL_COUNT).fill(0);
   let offGridCount = 0;
   for (const onset of snapped) {
     onsetLevels[onset.level] = (onsetLevels[onset.level] ?? 0) + 1;
@@ -4357,9 +4662,6 @@ function analyzeRhythm(notes, opts = {}) {
   };
 }
 
-// src/analyze/reference/types.ts
-var REFERENCE_PROFILE_VERSION = 1;
-
 // src/analyze/reference/validate.ts
 var MASS_TOLERANCE = 1e-9;
 function assertString(value, name) {
@@ -4427,7 +4729,7 @@ function assertRhythmAnalysis(value, name) {
       `${name}.barOnsets[${index}]`
     );
   }
-  assertMassDistribution(read.onsetLevels, 6, `${name}.onsetLevels`, onsets === 0);
+  assertMassDistribution(read.onsetLevels, RHYTHM_LEVEL_COUNT, `${name}.onsetLevels`, onsets === 0);
   const barPositions = assertArray(read.barPositions, `${name}.barPositions`);
   for (let index = 0; index < barPositions.length; index += 1) {
     assertBarPositionProfile(barPositions[index], `${name}.barPositions[${index}]`);
@@ -4468,12 +4770,14 @@ function assertReferencePhraseMelody(value, name) {
   assertOneOf(read.shape, MELODIC_CONTOUR_SHAPES, `${name}.shape`);
   assertMidiPitch(read.low, `${name}.low`);
   assertMidiPitch(read.high, `${name}.high`);
-  assertRange(read.mean, 0, 127, `${name}.mean`);
-  assertRange(read.peakPitch, 0, 127, `${name}.peakPitch`);
+  assertRange(read.mean, 0, MIDI_MAX, `${name}.mean`);
+  assertRange(read.peakPitch, 0, MIDI_MAX, `${name}.peakPitch`);
   assertRange(read.peakPosition, 0, 1, `${name}.peakPosition`);
   const outline = assertArray(read.outline, `${name}.outline`);
-  if (outline.length !== 8) {
-    throw new InvalidInputError(`${name}.outline must have length 8; received ${outline.length}`);
+  if (outline.length !== PHRASE_OUTLINE_POINTS) {
+    throw new InvalidInputError(
+      `${name}.outline must have length ${PHRASE_OUTLINE_POINTS}; received ${outline.length}`
+    );
   }
   for (let index = 0; index < outline.length; index += 1) {
     assertFiniteNumber(outline[index], `${name}.outline[${index}]`);
@@ -4482,11 +4786,13 @@ function assertReferencePhraseMelody(value, name) {
   assertRange(read.restRatio, 0, 1, `${name}.restRatio`);
   return read;
 }
-function assertReferencePhrase(value, name, sectionCount, nodeCount) {
+function assertReferencePhrase(value, name, span, sectionCount, nodeCount) {
   const read = assertRecord(value, name);
   const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
   const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
   assertSpanOrder(startBeat, endBeat, name);
+  assertRange(startBeat, span.startBeat, span.endBeat, `${name}.startBeat`);
+  assertRange(endBeat, span.startBeat, span.endBeat, `${name}.endBeat`);
   assertRange(read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
   assertNullable(
     read.section,
@@ -4507,7 +4813,7 @@ function assertReferencePhrase(value, name, sectionCount, nodeCount) {
   }
   return read;
 }
-function assertReferenceForm(value, name, nodeCount) {
+function assertReferenceForm(value, name, span, nodeCount) {
   const read = assertRecord(value, name);
   const hypermeter = assertRecord(
     read.hypermeter,
@@ -4521,7 +4827,13 @@ function assertReferenceForm(value, name, nodeCount) {
   }
   const phrases = assertArray(read.phrases, `${name}.phrases`);
   for (let index = 0; index < phrases.length; index += 1) {
-    assertReferencePhrase(phrases[index], `${name}.phrases[${index}]`, sections.length, nodeCount);
+    assertReferencePhrase(
+      phrases[index],
+      `${name}.phrases[${index}]`,
+      span,
+      sections.length,
+      nodeCount
+    );
   }
   return read;
 }
@@ -4661,9 +4973,9 @@ function assertReferenceMotif(value, name) {
     low = Math.min(low, pitch);
     high = Math.max(high, pitch);
   }
-  if (high - low > 127) {
+  if (high - low > MIDI_MAX) {
     throw new InvalidInputError(
-      `${name}.intervals must span at most 127 semitones; received ${high - low}`
+      `${name}.intervals must span at most ${MIDI_MAX} semitones; received ${high - low}`
     );
   }
   const rhythm = assertArray(read.rhythm, `${name}.rhythm`);
@@ -4694,7 +5006,7 @@ function assertReferenceMelody(value, name) {
     const register = assertRecord(v, n);
     assertMidiPitch(register.low, `${n}.low`);
     assertMidiPitch(register.high, `${n}.high`);
-    assertRange(register.mean, 0, 127, `${n}.mean`);
+    assertRange(register.mean, 0, MIDI_MAX, `${n}.mean`);
     return register;
   });
   assertNullable(read.shape, `${name}.shape`, (v, n) => assertOneOf(v, MELODIC_CONTOUR_SHAPES, n));
@@ -4725,7 +5037,7 @@ function assertReferenceProfile(value, name = "reference profile") {
   assertRange(span.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.span.bars`);
   assertMeterMap(read.meters, `${name}.meters`);
   const melody = assertReferenceMelody(read.melody, `${name}.melody`);
-  assertReferenceForm(read.form, `${name}.form`, melody.graph.nodes.length);
+  assertReferenceForm(read.form, `${name}.form`, { startBeat, endBeat }, melody.graph.nodes.length);
   assertReferenceHarmony(read.harmony, `${name}.harmony`);
   return read;
 }
@@ -4742,11 +5054,12 @@ var PEAK_POSITION_WEIGHT = 0.5;
 var FAMILY_SIZE_BINS = 5;
 var DEPTH_BINS = 4;
 var NAMED_CHORDS = ["Ger", "It", "Fr", "N"];
-var PITCH_PRESERVING = /* @__PURE__ */ new Set([
+var PITCH_PRESERVING_KINDS = [
   "repetition",
   "augmentation",
   "diminution"
-]);
+];
+var PITCH_PRESERVING = new Set(PITCH_PRESERVING_KINDS);
 var CELL_START_PITCH = 60;
 function whenBoth(hasA, hasB, measure) {
   if (!hasA && !hasB) {
@@ -4899,7 +5212,7 @@ function cellNotes(motif) {
     low = Math.min(low, offset);
     high = Math.max(high, offset);
   }
-  let pitch = Math.min(127 - high, Math.max(-low, CELL_START_PITCH));
+  let pitch = Math.min(MIDI_MAX - high, Math.max(-low, CELL_START_PITCH));
   let beat = 0;
   for (let i = 0; i <= motif.intervals.length; i += 1) {
     const step = motif.rhythm[i] ?? 1;
@@ -5073,8 +5386,8 @@ function phraseMelody(line, startBeat, endBeat, lineMean, meters, budget) {
   }
   const length = endBeat - startBeat;
   const outline = [];
-  for (let k = 0; k < 8; k += 1) {
-    const at = startBeat + (k + 0.5) * length / 8;
+  for (let k = 0; k < PHRASE_OUTLINE_POINTS; k += 1) {
+    const at = startBeat + (k + 0.5) * length / PHRASE_OUTLINE_POINTS;
     let held = first;
     for (const note of inside) {
       if (note.startBeat > at + BEAT_EPS) {
@@ -5084,7 +5397,7 @@ function phraseMelody(line, startBeat, endBeat, lineMean, meters, budget) {
     }
     outline.push(held.pitch - lineMean);
   }
-  const rhythm = analyzeRhythm(inside, { meters, totalBeats: endBeat, budget });
+  const rhythm = rhythmOver(inside, { meters, totalBeats: endBeat, budget }, startBeat);
   return {
     shape: melodicContour(inside).shape,
     low,
@@ -5110,6 +5423,16 @@ export {
   detectKey,
   detectKeyFromNotes,
   detectKeyBest,
+  barSpanOf,
+  clamp01,
+  floorMod,
+  firstSoundingBeat,
+  resolveSpanEnd,
+  lastBarOf,
+  sliceBars,
+  weightSimilarity,
+  harmonicNovelty,
+  combineEvidence,
   augmentedSixthChord,
   augmentedSixthKind,
   augmentedSixthFromPitchClasses,
@@ -5130,16 +5453,8 @@ export {
   secondaryDominant,
   secondaryDominantOf,
   pivotChords,
-  barSpanOf,
-  clamp01,
-  floorMod,
-  firstSoundingBeat,
-  lastBarOf,
-  sliceBars,
-  weightSimilarity,
-  harmonicNovelty,
-  combineEvidence,
   gridForNotes,
+  latestSoundingEnd,
   barGridStart,
   keyTimelineFromNotes,
   detectModulations,
@@ -5149,6 +5464,8 @@ export {
   toVoiceNotes,
   analyzeVoice,
   assertChordTimeline,
+  assertSpansInOrder,
+  statedKeyRegions,
   chordTimelineFromChords,
   chordAtBeat,
   segmentStartingAt,
@@ -5169,6 +5486,7 @@ export {
   motifGraph,
   REDUCTION_LEVELS,
   reduceProgression,
+  REFERENCE_PROFILE_VERSION,
   sectionSequenceSimilarity,
   phraseLengthSimilarity,
   progressionSimilarity,
@@ -5187,9 +5505,9 @@ export {
   ioiBinIndex,
   RHYTHM_IOI_BINS,
   analyzeRhythm,
-  REFERENCE_PROFILE_VERSION,
+  rhythmOver,
   assertReferenceProfile,
   weightedMean,
   phraseMelody
 };
-//# sourceMappingURL=chunk-GNVN4PPJ.js.map
+//# sourceMappingURL=chunk-FJFULJZE.js.map