@libraz/libcantus 1.2.0 → 1.4.0

package/dist/{chunk-H2KJHBW4.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,
@@ -33,8 +34,11 @@ import {
   isNeapolitanChordOf,
   isScaleTone,
   keyRelationBetween,
+  keySignatureFifths,
+  keySpelling,
   majorKey,
   makeChord,
+  makeSpelledChord,
   minorKey,
   resolveKey,
   scaleOf,
@@ -44,10 +48,11 @@ import {
   spellChord,
   spellPitchClass,
   spelledKeyOf,
+  spellingAbove,
   toChordData,
   toKeyScale,
   tonicizableDegrees
-} from "./chunk-RFIBF2RR.js";
+} from "./chunk-H7FVMBUC.js";
 import {
   BEAT_EPS,
   InvalidInputError,
@@ -55,29 +60,43 @@ import {
   allocateChoiceTable,
   assertArray,
   assertFiniteNumber,
+  assertFlag,
   assertFunction,
   assertGenerationBudget,
   assertInteger,
+  assertMeterMap,
   assertMidiPitch,
   assertNoteEvents,
   assertOneOf,
   assertOptions,
+  assertPositiveInt,
   assertRange,
   assertRecord,
+  assertTimeSignature,
   barIndexAt,
   barPositionToBeat,
+  barStartBeat,
+  beatsPerBar,
   beatsPerBarAt,
+  describeRejected,
   diatonicLetterOf,
   formatNote,
+  isCompound,
+  isConsonantInterval,
+  meterAt,
   metricGridUnit,
   metricWeight,
+  midiToNote,
+  naturalPitchClassOf,
   parseInterval,
   pitchClassOf,
+  pulseBeats,
   resolveMeters,
+  spelledInterval,
   toNoteData,
   transposeByInterval,
   transposeNote
-} from "./chunk-AGOVW7U6.js";
+} from "./chunk-YYVXRV3V.js";
 
 // src/analyze/detect/modes.ts
 var MODAL_CANDIDATES = Object.freeze([
@@ -191,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],
@@ -289,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);
 }
@@ -302,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 = [];
@@ -326,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;
@@ -374,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)) {
@@ -616,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",
@@ -647,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) {
@@ -779,6 +812,14 @@ function outerPitches(voicing) {
 function bassPcOf2(chord, voicedBass) {
   return pitchClassOf(voicedBass ?? chord.bassPc ?? chord.rootPc);
 }
+var CADENCE_TYPES = Object.freeze([
+  "authentic",
+  "plagal",
+  "half",
+  "deceptive",
+  "phrygian",
+  "modal"
+]);
 function cadenceType(from, to, key, fromBassPc, toBassPc) {
   const tonic = pitchClassOf(key.rootPc);
   const fromOffset = pitchClassOf(from.rootPc - tonic);
@@ -988,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;
@@ -1007,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);
@@ -1050,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: "" },
@@ -1122,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}`);
@@ -1146,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) {
@@ -1186,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) {
@@ -1217,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) {
@@ -1252,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;
@@ -1298,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",
@@ -1308,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) {
@@ -1319,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;
@@ -1326,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);
@@ -1384,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) {
@@ -1466,6 +1570,7 @@ function capitalize(text) {
 }
 
 // src/analyze/functional/function.ts
+var HARMONIC_FUNCTIONS = Object.freeze(["tonic", "subdominant", "dominant"]);
 var FUNCTION_BY_OFFSET = [
   "tonic",
   // 0  I
@@ -1522,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)) {
@@ -1559,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)) {
@@ -1577,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"
@@ -1594,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,
@@ -1605,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}`;
@@ -1669,6 +1774,16 @@ function stackedTriad(degree, key) {
 }
 
 // src/analyze/form/internal.ts
+function barSpanOf(startBeat, endBeat, meter) {
+  const firstBar = barIndexAt(startBeat, meter);
+  const lastBar = barIndexAt(endBeat, meter);
+  const partOf = (beat, bar) => {
+    const barStart = barPositionToBeat({ bar, beat: 0 }, meter);
+    const barLength = beatsPerBarAt(barStart, meter);
+    return barLength > 0 ? (beat - barStart) / barLength : 0;
+  };
+  return lastBar - firstBar + partOf(endBeat, lastBar) - partOf(startBeat, firstBar);
+}
 function clamp01(value) {
   return Math.min(1, Math.max(0, value));
 }
@@ -1682,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);
@@ -1763,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;
 }
@@ -2053,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));
@@ -2191,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 [];
@@ -2390,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;
@@ -2419,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];
 }
@@ -2434,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) {
@@ -2452,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) {
@@ -2471,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);
@@ -2508,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;
@@ -2643,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");
@@ -2709,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;
@@ -2725,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);
 }
@@ -2757,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;
@@ -2769,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) {
@@ -2802,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 = {
@@ -2817,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);
@@ -2843,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;
 }
@@ -3091,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");
@@ -3103,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 };
@@ -3116,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));
@@ -3179,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];
@@ -3267,63 +3544,1970 @@ function detectCadences(timeline, key) {
   return hits;
 }
 
-export {
-  HUMANIZE_ADJACENCY,
-  sameInstant,
-  adjacent,
-  hasEnded,
-  windowWeights,
-  MODAL_SCALE_NAMES,
-  detectChord,
-  detectChordBest,
-  detectKey,
-  detectKeyFromNotes,
-  detectKeyBest,
-  augmentedSixthChord,
-  augmentedSixthKind,
-  augmentedSixthFromPitchClasses,
-  spellAugmentedSixth,
-  isCadentialSixFour,
-  detectCadence,
-  isBorrowedChord,
-  borrowedSource,
-  isAppliedDominant,
-  romanToChord,
-  chordToRoman,
-  explainRoman,
-  isMinorKey,
-  functionOf,
-  isDiatonic,
-  parallelKey,
-  analyzeChord,
-  secondaryDominant,
-  secondaryDominantOf,
-  pivotChords,
-  clamp01,
-  floorMod,
-  firstSoundingBeat,
-  lastBarOf,
-  sliceBars,
-  weightSimilarity,
-  harmonicNovelty,
-  combineEvidence,
+// src/analyze/melody/internal.ts
+var RHYTHM_GRID = 64;
+function phraseNotes(phrase) {
+  if (Array.isArray(phrase)) {
+    return phrase;
+  }
+  return assertRecord(phrase, "melodic phrase").notes;
+}
+function orderedNotes(notes, name, budget) {
+  assertNoteEvents(notes, name, { allowNonPositiveDuration: true, budget });
+  const sounding = notes.filter((note) => note.durationBeat > 0).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
+  const line = [];
+  for (const note of sounding) {
+    const previous = line[line.length - 1];
+    if (previous !== void 0 && Math.abs(note.startBeat - previous.startBeat) <= BEAT_EPS) {
+      line[line.length - 1] = note;
+      continue;
+    }
+    line.push(note);
+  }
+  return line;
+}
+function intervalsOf(notes) {
+  const out = [];
+  for (let i = 1; i < notes.length; i += 1) {
+    out.push((notes[i]?.pitch ?? 0) - (notes[i - 1]?.pitch ?? 0));
+  }
+  return out;
+}
+function onsetGaps(notes) {
+  const out = [];
+  for (let i = 1; i < notes.length; i += 1) {
+    out.push((notes[i]?.startBeat ?? 0) - (notes[i - 1]?.startBeat ?? 0));
+  }
+  return out;
+}
+function retrogradeGaps(notes) {
+  const out = [];
+  for (let i = notes.length - 1; i >= 1; i -= 1) {
+    const later = notes[i];
+    const earlier = notes[i - 1];
+    out.push(
+      (later?.startBeat ?? 0) + (later?.durationBeat ?? 0) - ((earlier?.startBeat ?? 0) + (earlier?.durationBeat ?? 0))
+    );
+  }
+  return out;
+}
+function rhythmProfile(gaps) {
+  const unit = gaps[0] ?? 0;
+  if (!(unit > BEAT_EPS)) {
+    return gaps.length === 0 ? [] : null;
+  }
+  return gaps.map((gap) => Math.round(gap / unit * RHYTHM_GRID) / RHYTHM_GRID);
+}
+function sameNumbers(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i += 1) {
+    if (Math.abs((a[i] ?? 0) - (b[i] ?? 0)) > BEAT_EPS) {
+      return false;
+    }
+  }
+  return true;
+}
+function roundTo(value, digits) {
+  const scale = 10 ** digits;
+  return Math.round(value * scale) / scale;
+}
+function endBeatOf(notes) {
+  return latestSoundingEnd(notes);
+}
+function onsetSpan(notes) {
+  if (notes.length < 2) {
+    return 0;
+  }
+  return (notes[notes.length - 1]?.startBeat ?? 0) - (notes[0]?.startBeat ?? 0);
+}
+
+// src/analyze/melody/contour.ts
+var DIRECTIONAL_SHARE = 0.75;
+var MELODIC_CONTOUR_SHAPES = Object.freeze([
+  "arch",
+  "ascending",
+  "descending",
+  "wave",
+  "static"
+]);
+function extremes(notes) {
+  if (notes.length === 0) {
+    return { peak: -1, trough: -1 };
+  }
+  let peak = 0;
+  let trough = 0;
+  for (let i = 1; i < notes.length; i += 1) {
+    if ((notes[i]?.pitch ?? 0) > (notes[peak]?.pitch ?? 0)) {
+      peak = i;
+    }
+    if ((notes[i]?.pitch ?? 0) < (notes[trough]?.pitch ?? 0)) {
+      trough = i;
+    }
+  }
+  return { peak, trough };
+}
+function melodicContour(notes) {
+  const line = orderedNotes(phraseNotes(notes), "contour notes");
+  const intervals = intervalsOf(line);
+  const directions = intervals.map(
+    (step) => step > 0 ? "up" : step < 0 ? "down" : "same"
+  );
+  const { peak, trough } = extremes(line);
+  const range = (line[peak]?.pitch ?? 0) - (line[trough]?.pitch ?? 0);
+  const motion = intervals.reduce((sum, step) => sum + Math.abs(step), 0);
+  if (motion === 0) {
+    return {
+      directions,
+      shape: "static",
+      peakIndex: peak,
+      troughIndex: trough,
+      range: 0,
+      rationale: line.length < 2 ? "Too short to have a direction, so the line is static" : "Every note at the same pitch, so the line is static"
+    };
+  }
+  const first = line[0]?.pitch ?? 0;
+  const last = line[line.length - 1]?.pitch ?? 0;
+  const net = last - first;
+  const directness = Math.abs(net) / motion;
+  const share = Math.round(directness * 100);
+  if (directness >= DIRECTIONAL_SHARE) {
+    const shape = net > 0 ? "ascending" : "descending";
+    return {
+      directions,
+      shape,
+      peakIndex: peak,
+      troughIndex: trough,
+      range,
+      rationale: `The net ${net > 0 ? "rise" : "fall"} is ${share}% of the motion, so the line is ${shape}`
+    };
+  }
+  const peakPitch = line[peak]?.pitch ?? 0;
+  const archMotion = peakPitch - first + (peakPitch - last);
+  if (peak > 0 && peak < line.length - 1 && archMotion >= DIRECTIONAL_SHARE * motion) {
+    return {
+      directions,
+      shape: "arch",
+      peakIndex: peak,
+      troughIndex: trough,
+      range,
+      rationale: `Rises to its peak at note ${peak + 1} of ${line.length} and falls back, so the line is an arch`
+    };
+  }
+  return {
+    directions,
+    shape: "wave",
+    peakIndex: peak,
+    troughIndex: trough,
+    range,
+    rationale: `Changes direction without settling either way (the net movement is ${share}% of the motion), so the line is a wave`
+  };
+}
+
+// src/analyze/melody/motifs.ts
+var MIN_CELL_NOTES = 3;
+var MAX_CELL_NOTES = 8;
+var MIN_OCCURRENCES = 2;
+function windowSignature(notes) {
+  const profile = rhythmProfile(onsetGaps(notes));
+  if (profile === null) {
+    return null;
+  }
+  return `${notes.length}|${intervalsOf(notes).join(",")}|${profile.join(",")}`;
+}
+function nonOverlapping(starts, length) {
+  const picked = [];
+  let lastEnd = Number.NEGATIVE_INFINITY;
+  for (const start of starts) {
+    if (start > lastEnd) {
+      picked.push(start);
+      lastEnd = start + length - 1;
+    }
+  }
+  return picked;
+}
+function subsumes(outer, inner) {
+  let at = 0;
+  for (const start of inner.starts) {
+    while (at + 1 < outer.starts.length && (outer.starts[at + 1] ?? 0) <= start) {
+      at += 1;
+    }
+    const from = outer.starts[at];
+    if (from === void 0 || start < from || start + inner.length > from + outer.length) {
+      return false;
+    }
+  }
+  return true;
+}
+function listBeats(occurrences) {
+  const shown = occurrences.slice(0, 5).map((occurrence) => roundTo(occurrence.startBeat, 3));
+  return occurrences.length > shown.length ? `${shown.join(", ")}, and ${occurrences.length - shown.length} more` : shown.join(", ");
+}
+function motifFromGroup(group, notes) {
+  const first = group.starts[0] ?? 0;
+  const prime = notes.slice(first, first + group.length).map((note) => ({ ...note }));
+  const primePitch = prime[0]?.pitch ?? 0;
+  const primeSpan = onsetSpan(prime);
+  const occurrences = group.starts.map((start) => {
+    const statement = notes.slice(start, start + group.length);
+    const span = onsetSpan(statement);
+    return {
+      noteIndex: start,
+      startBeat: statement[0]?.startBeat ?? 0,
+      endBeat: endBeatOf(statement),
+      transpose: (statement[0]?.pitch ?? 0) - primePitch,
+      timeRatio: primeSpan > BEAT_EPS ? span / primeSpan : 1
+    };
+  });
+  const shape = melodicContour(prime).shape;
+  const transposed = occurrences.some((occurrence) => occurrence.transpose !== 0);
+  const stretched = occurrences.some((occurrence) => Math.abs(occurrence.timeRatio - 1) > BEAT_EPS);
+  const detail = [
+    transposed ? "at more than one pitch level" : "at the same pitch level",
+    stretched ? "and in more than one set of note values" : ""
+  ].filter((part) => part !== "").join(" ");
+  return {
+    notes: prime,
+    intervals: intervalsOf(prime),
+    rhythm: rhythmProfile(onsetGaps(prime)) ?? [],
+    occurrences,
+    rationale: `${group.length}-note ${shape} cell stated ${occurrences.length} ${occurrences.length === 1 ? "time" : "times"} (beats ${listBeats(occurrences)}), ${detail}`
+  };
+}
+function extractMotifs(notes, opts = {}) {
+  const asked = assertOptions(opts, "opts");
+  const minNotes = assertInteger(asked.minNotes ?? MIN_CELL_NOTES, "motif minNotes", 2, 64);
+  const maxNotes = assertInteger(asked.maxNotes ?? MAX_CELL_NOTES, "motif maxNotes", 2, 64);
+  if (maxNotes < minNotes) {
+    throw new InvalidInputError(
+      `motif maxNotes must be at least minNotes ${minNotes}; received ${maxNotes}`
+    );
+  }
+  const minOccurrences = assertInteger(
+    asked.minOccurrences ?? MIN_OCCURRENCES,
+    "motif minOccurrences",
+    2
+  );
+  const sounding = orderedNotes(notes, "melody notes", asked.budget);
+  if (sounding.length < minNotes) {
+    return [];
+  }
+  assertGenerationBudget(
+    sounding.length * (maxNotes - minNotes + 1),
+    "motif windows",
+    asked.budget
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (let length = minNotes; length <= maxNotes; length += 1) {
+    for (let start = 0; start + length <= sounding.length; start += 1) {
+      const signature = windowSignature(sounding.slice(start, start + length));
+      if (signature === null) {
+        continue;
+      }
+      const group = groups.get(signature);
+      if (group === void 0) {
+        groups.set(signature, { signature, length, starts: [start] });
+      } else {
+        group.starts.push(start);
+      }
+    }
+  }
+  const candidates = [...groups.values()].map((group) => ({ ...group, starts: nonOverlapping(group.starts, group.length) })).filter((group) => group.starts.length >= minOccurrences).sort(
+    (a, b) => b.length - a.length || b.starts.length - a.starts.length || (a.starts[0] ?? 0) - (b.starts[0] ?? 0) || (a.signature < b.signature ? -1 : a.signature > b.signature ? 1 : 0)
+  );
+  const keptByLength = /* @__PURE__ */ new Map();
+  const kept = [];
+  let comparisons = 0;
+  for (const candidate of candidates) {
+    const first = candidate.starts[0] ?? 0;
+    let covered = false;
+    for (let length = candidate.length + 1; length <= maxNotes && !covered; length += 1) {
+      const byStart = keptByLength.get(length);
+      if (byStart === void 0) {
+        continue;
+      }
+      for (let from = Math.max(0, first - (length - candidate.length)); from <= first; from += 1) {
+        comparisons += 1;
+        const outer = byStart.get(from);
+        if (outer === void 0 || outer.starts.length < candidate.starts.length) {
+          continue;
+        }
+        comparisons += outer.starts.length + candidate.starts.length;
+        if (subsumes(outer, candidate)) {
+          covered = true;
+          break;
+        }
+      }
+    }
+    assertGenerationBudget(comparisons, "motif subsumption comparisons", asked.budget);
+    if (!covered) {
+      kept.push(candidate);
+      let byStart = keptByLength.get(candidate.length);
+      if (byStart === void 0) {
+        byStart = /* @__PURE__ */ new Map();
+        keptByLength.set(candidate.length, byStart);
+      }
+      for (const start of candidate.starts) {
+        byStart.set(start, candidate);
+      }
+    }
+  }
+  return kept.map((group) => motifFromGroup(group, sounding));
+}
+function motifFromNotes(notes) {
+  const sounding = orderedNotes(notes, "motif notes").map((note) => ({ ...note }));
+  return motifFromGroup(
+    { signature: windowSignature(sounding) ?? "", length: sounding.length, starts: [0] },
+    sounding
+  );
+}
+
+// src/analyze/melody/relation.ts
+var MOTIF_RELATION_KINDS = Object.freeze([
+  "repetition",
+  "transposition",
+  "tonalTransposition",
+  "inversion",
+  "retrograde",
+  "retrogradeInversion",
+  "augmentation",
+  "diminution"
+]);
+function spellingOf(key) {
+  if (key === void 0) {
+    return "sharp";
+  }
+  return keySignatureFifths(key.tonic, key.scale) < 0 ? "flat" : "sharp";
+}
+function intervalBetween(from, to, key) {
+  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}`;
+}
+function ladderIndices(notes, key) {
+  const root = pitchClassOf(key.rootPc);
+  const offsets = scaleTonesInDegreeOrder(key).map((pc) => pitchClassOf(pc - root));
+  if (offsets.length === 0) {
+    return null;
+  }
+  const out = [];
+  for (const note of notes) {
+    const semitones = note.pitch - root;
+    const octave = Math.floor(semitones / 12);
+    const degree = offsets.indexOf(semitones - octave * 12);
+    if (degree < 0) {
+      return null;
+    }
+    out.push(octave * offsets.length + degree);
+  }
+  return out;
+}
+function ladderSteps(indices) {
+  const out = [];
+  for (let i = 1; i < indices.length; i += 1) {
+    out.push((indices[i] ?? 0) - (indices[i - 1] ?? 0));
+  }
+  return out;
+}
+function pitchShapes(a, b) {
+  const shapes = [];
+  if (sameNumbers(a, b)) {
+    shapes.push("exact");
+  }
+  if (sameNumbers(
+    b,
+    a.map((step) => -step)
+  )) {
+    shapes.push("inversion");
+  }
+  const reversed = [...a].reverse();
+  if (sameNumbers(
+    b,
+    reversed.map((step) => -step)
+  )) {
+    shapes.push("retrograde");
+  }
+  if (sameNumbers(b, reversed)) {
+    shapes.push("retrogradeInversion");
+  }
+  return shapes;
+}
+function totalGap(gaps) {
+  return gaps.reduce((sum, gap) => sum + gap, 0);
+}
+function stretchRatio(modelGaps, answerGaps) {
+  const span = totalGap(modelGaps);
+  return span > BEAT_EPS ? totalGap(answerGaps) / span : 1;
+}
+function stretchPhrase(ratio2) {
+  return `note values ${roundTo(ratio2, 3)}x the model's`;
+}
+function relateMotifs(a, b, keyLike) {
+  const key = keyLike === void 0 ? void 0 : resolveKey(keyLike);
+  const model = assertArray(assertRecord(a, "a").notes, "a.notes");
+  const answer = assertArray(assertRecord(b, "b").notes, "b.notes");
+  if (model.length === 0 || model.length !== answer.length) {
+    return null;
+  }
+  const modelGaps = onsetGaps(model);
+  const answerGaps = onsetGaps(answer);
+  const modelProfile = rhythmProfile(modelGaps);
+  const answerProfile = rhythmProfile(answerGaps);
+  const retroGaps = retrogradeGaps(model);
+  const retroProfile = rhythmProfile(retroGaps);
+  if (modelProfile === null || answerProfile === null) {
+    return null;
+  }
+  const forward = sameNumbers(modelProfile, answerProfile);
+  const backward = retroProfile !== null && sameNumbers(retroProfile, answerProfile);
+  const semitones = (answer[0]?.pitch ?? 0) - (model[0]?.pitch ?? 0);
+  const interval = intervalBetween(model[0]?.pitch ?? 0, answer[0]?.pitch ?? 0, key);
+  const gap = (answer[0]?.startBeat ?? 0) - endBeatOf(model);
+  const sequence = gap >= -HUMANIZE_ADJACENCY && gap <= HUMANIZE_ADJACENCY;
+  const timeRatio = stretchRatio(modelGaps, answerGaps);
+  const stretched = Math.abs(timeRatio - 1) > BEAT_EPS;
+  const shapes = pitchShapes(intervalsOf(model), intervalsOf(answer));
+  const base = { sequence, semitones, interval, timeRatio };
+  const backwardBase = { ...base, timeRatio: stretchRatio(retroGaps, answerGaps) };
+  if (forward && shapes.includes("exact")) {
+    if (semitones === 0) {
+      if (!stretched) {
+        return {
+          ...base,
+          kind: "repetition",
+          rationale: "Exact repetition: the same pitches in the same rhythm"
+        };
+      }
+      const augmented = timeRatio > 1;
+      return {
+        ...base,
+        kind: augmented ? "augmentation" : "diminution",
+        rationale: `${augmented ? "Augmentation" : "Diminution"}: the same pitches in ${stretchPhrase(timeRatio)}`
+      };
+    }
+    const name = intervalName(interval);
+    return {
+      ...base,
+      kind: "transposition",
+      rationale: sequence ? `Real sequence: the cell restated ${name} away with every interval kept literally` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "") : `Transposition by ${name}: every interval kept literally` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
+    };
+  }
+  if (forward && key !== void 0) {
+    const modelLadder = ladderIndices(model, key.scale);
+    const answerLadder = ladderIndices(answer, key.scale);
+    if (modelLadder !== null && answerLadder !== null) {
+      const degrees = (answerLadder[0] ?? 0) - (modelLadder[0] ?? 0);
+      if (degrees !== 0 && sameNumbers(ladderSteps(modelLadder), ladderSteps(answerLadder))) {
+        const direction = degrees > 0 ? "higher" : "lower";
+        const count = Math.abs(degrees);
+        return {
+          ...base,
+          kind: "tonalTransposition",
+          degrees,
+          rationale: `${sequence ? "Tonal sequence" : "Tonal transposition"}: the cell restated ${count} scale ${count === 1 ? "degree" : "degrees"} ${direction} inside the key, so the key resizes its intervals \u2014 a real one would have kept them literal`
+        };
+      }
+    }
+  }
+  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${semitones === 0 ? " about the first note" : ""}` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
+    };
+  }
+  if (backward && shapes.includes("retrograde")) {
+    return {
+      ...backwardBase,
+      kind: "retrograde",
+      rationale: "Retrograde: the cell read back to front, rhythm included"
+    };
+  }
+  if (backward && shapes.includes("retrogradeInversion")) {
+    return {
+      ...backwardBase,
+      kind: "retrogradeInversion",
+      rationale: "Retrograde inversion: the cell read back to front and turned upside down"
+    };
+  }
+  return null;
+}
+
+// src/analyze/sequence.ts
+function gradedEditDistance(a, b, cost, gap = 1) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i * gap);
+  for (let i = 1; i <= a.length; i += 1) {
+    const row = new Array(b.length + 1);
+    row[0] = i * gap;
+    for (let j = 1; j <= b.length; j += 1) {
+      const ai = a[i - 1];
+      const bj = b[j - 1];
+      const substitution = (previous[j - 1] ?? 0) + cost(ai, bj);
+      const deletion = (previous[j] ?? 0) + gap;
+      const insertion = (row[j - 1] ?? 0) + gap;
+      row[j] = Math.min(substitution, deletion, insertion);
+    }
+    previous = row;
+  }
+  return previous[b.length] ?? 0;
+}
+function distanceToSimilarity(distance, a, b) {
+  const longest = Math.max(a, b);
+  if (longest === 0) {
+    return 1;
+  }
+  return Math.min(1, Math.max(0, 1 - distance / longest));
+}
+
+// src/analyze/melody/similarity.ts
+var INTERVAL_TOLERANCE = 6;
+var PITCH_WEIGHT = 0.75;
+var RHYTHM_WEIGHT = 0.25;
+function intervalCost(x, y) {
+  return Math.min(1, Math.abs(x - y) / INTERVAL_TOLERANCE);
+}
+function gapCost(x, y) {
+  if (!(x > BEAT_EPS) || !(y > BEAT_EPS)) {
+    return Math.abs(x - y) > BEAT_EPS ? 1 : 0;
+  }
+  return Math.min(1, Math.abs(Math.log2(x / y)));
+}
+function compareMelodies(a, b) {
+  const left = orderedNotes(phraseNotes(a), "melody a");
+  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,
+    rightIntervals.length
+  );
+  const leftGaps = rhythmProfile(onsetGaps(left)) ?? onsetGaps(left);
+  const rightGaps = rhythmProfile(onsetGaps(right)) ?? onsetGaps(right);
+  const rhythmSimilarity = distanceToSimilarity(
+    gradedEditDistance(leftGaps, rightGaps, gapCost),
+    leftGaps.length,
+    rightGaps.length
+  );
+  const similarity = PITCH_WEIGHT * pitchSimilarity + RHYTHM_WEIGHT * rhythmSimilarity;
+  return {
+    similarity,
+    pitchSimilarity,
+    rhythmSimilarity,
+    rationale: `Interval shapes ${Math.round(pitchSimilarity * 100)}% alike, rhythms ${Math.round(rhythmSimilarity * 100)}% alike, weighted ${PITCH_WEIGHT}/${RHYTHM_WEIGHT} into ${roundTo(similarity, 3)}`
+  };
+}
+function melodicSimilarity(a, b) {
+  return compareMelodies(a, b).similarity;
+}
+
+// src/analyze/melody/graph.ts
+var DEFAULT_VARIATION_THRESHOLD = 0.75;
+function summarize(relation) {
+  const { kind, sequence, semitones, degrees, timeRatio } = relation;
+  return { kind, sequence, semitones, degrees, timeRatio };
+}
+function betterParent(candidate, current) {
+  const candidateNamed = candidate.relation !== null;
+  const currentNamed = current.relation !== null;
+  if (candidateNamed !== currentNamed) {
+    return candidateNamed;
+  }
+  if (candidate.similarity !== current.similarity) {
+    return candidate.similarity > current.similarity;
+  }
+  if (candidate.startBeat !== current.startBeat) {
+    return candidate.startBeat > current.startBeat;
+  }
+  return candidate.index < current.index;
+}
+function motifGraph(line, motifs, opts = {}) {
+  const asked = assertOptions(opts, "opts");
+  const variationThreshold = asked.variationThreshold ?? DEFAULT_VARIATION_THRESHOLD;
+  assertRange(variationThreshold, 0, 1, "motif graph variationThreshold");
+  const ordered = orderedNotes(line, "line", asked.budget);
+  const motifList = assertArray(motifs, "motifs");
+  const infos = [];
+  for (let mi = 0; mi < motifList.length; mi += 1) {
+    const motif = assertRecord(motifList[mi], `motifs[${mi}]`);
+    const notes = assertArray(motif.notes, `motifs[${mi}].notes`);
+    const occurrences = assertArray(
+      motif.occurrences,
+      `motifs[${mi}].occurrences`
+    );
+    for (let oi = 0; oi < occurrences.length; oi += 1) {
+      const occurrence = assertRecord(
+        occurrences[oi],
+        `motifs[${mi}].occurrences[${oi}]`
+      );
+      const { noteIndex } = occurrence;
+      const onLine = Number.isInteger(noteIndex) && noteIndex >= 0 && noteIndex + notes.length <= ordered.length && Math.abs((ordered[noteIndex]?.startBeat ?? Number.NaN) - occurrence.startBeat) <= BEAT_EPS;
+      if (!onLine) {
+        throw new InvalidInputError(
+          `motif occurrence motifs[${mi}].occurrences[${oi}] does not lie on the line`
+        );
+      }
+      infos.push({
+        node: {
+          motif: mi,
+          occurrence: oi,
+          startBeat: occurrence.startBeat,
+          endBeat: occurrence.endBeat
+        },
+        data: motifFromNotes(ordered.slice(noteIndex, noteIndex + notes.length))
+      });
+    }
+  }
+  infos.sort((a, b) => a.node.startBeat - b.node.startBeat || a.node.motif - b.node.motif);
+  const nodeCount = infos.length;
+  assertGenerationBudget(nodeCount * nodeCount, "motif graph comparisons", asked.budget);
+  const edges = [];
+  for (let to = 1; to < nodeCount; to += 1) {
+    const toInfo = infos[to];
+    let best = null;
+    for (let from = 0; from < to; from += 1) {
+      const fromInfo = infos[from];
+      const candidate = {
+        index: from,
+        startBeat: fromInfo.node.startBeat,
+        relation: relateMotifs(fromInfo.data, toInfo.data, asked.key),
+        similarity: melodicSimilarity(fromInfo.data, toInfo.data)
+      };
+      if (best === null || betterParent(candidate, best)) {
+        best = candidate;
+      }
+    }
+    if (best !== null && (best.relation !== null || best.similarity >= variationThreshold)) {
+      edges.push({
+        from: best.index,
+        to,
+        relation: best.relation === null ? null : summarize(best.relation),
+        similarity: best.similarity
+      });
+    }
+  }
+  return { nodes: infos.map((info) => info.node), edges };
+}
+
+// src/analyze/reduction/index.ts
+var REDUCTION_LEVELS = Object.freeze(["structural", "passing", "neighbor"]);
+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;
+}
+function isStep2(distance) {
+  const size = Math.abs(distance);
+  return size === 1 || size === 2;
+}
+function touches(before, after) {
+  return Math.abs(after.startBeat - before.endBeat) <= BEAT_EPS;
+}
+function salienceFloors(durations) {
+  const order = durations.map((_, index) => index).sort((a, b) => {
+    const left = durations[a] ?? 0;
+    const right = durations[b] ?? 0;
+    return left - right || a - b;
+  });
+  const rankOf = new Array(durations.length).fill(0);
+  for (let rank = 0; rank < order.length; rank += 1) {
+    rankOf[order[rank] ?? 0] = rank;
+  }
+  const floors = [];
+  const remaining = durations.length - 1;
+  for (let index = 0; index < durations.length; index += 1) {
+    if (remaining <= 0) {
+      floors.push(0);
+      continue;
+    }
+    const skipped = rankOf[index] ?? 0;
+    const at = (position) => durations[order[position < skipped ? position : position + 1] ?? 0] ?? 0;
+    const middle = remaining >> 1;
+    floors.push(remaining % 2 === 1 ? at(middle) : (at(middle - 1) + at(middle)) / 2);
+  }
+  return floors;
+}
+function isTonicChord(chord, key) {
+  return pitchClassOf(chord.rootPc - key.rootPc) === 0 && !isAppliedDominant(chord, key);
+}
+function functionalReason(segment, before, after, keyAt) {
+  const key = keyAt(segment.startBeat);
+  if (after !== void 0 && isCadentialSixFour(segment.chord, after.chord, key)) {
+    return { kind: "cadentialSixFour" };
+  }
+  if (isTonicChord(segment.chord, key)) {
+    return { kind: "tonic" };
+  }
+  if (isDominantChordOf(segment.chord, key)) {
+    return { kind: "dominant" };
+  }
+  if (before !== void 0) {
+    const arrival = detectCadence(before.chord, segment.chord, key).type;
+    if (arrival !== null) {
+      return { kind: "cadenceArrival", cadence: arrival };
+    }
+  }
+  if (after !== void 0) {
+    const agent = detectCadence(segment.chord, after.chord, keyAt(after.startBeat)).type;
+    if (agent !== null && TONIC_ARRIVING.has(agent)) {
+      return { kind: "cadenceAgent", cadence: agent };
+    }
+  }
+  return null;
+}
+function figureReason(segment, before, after) {
+  if (before === void 0 || after === void 0) {
+    return null;
+  }
+  const incoming = signedStep(before.chord.rootPc, segment.chord.rootPc);
+  const outgoing = signedStep(segment.chord.rootPc, after.chord.rootPc);
+  if (!isStep2(incoming) || !isStep2(outgoing)) {
+    return null;
+  }
+  if (incoming > 0 === outgoing > 0) {
+    return { kind: "passing" };
+  }
+  return pitchClassOf(before.chord.rootPc) === pitchClassOf(after.chord.rootPc) ? { kind: "neighbor" } : null;
+}
+function describe2(reason) {
+  switch (reason.kind) {
+    case "tonic":
+      return "Structural: the tonic of the key, which the progression is heard against";
+    case "dominant":
+      return "Structural: the dominant of the key, the chord its tonic is approached from";
+    case "cadentialSixFour":
+      return "Structural: a tonic six-four on the bass of the dominant that follows, which prolongs that dominant rather than framing the tonic";
+    case "cadenceArrival":
+      return `Structural: the arrival of a ${reason.cadence} cadence`;
+    case "cadenceAgent":
+      return `Structural: the chord that drives a ${reason.cadence} cadence`;
+    case "salient":
+      return "Structural: it holds the harmony longer than the chords around it";
+    case "first":
+      return "Structural: the first chord of the progression frames it";
+    case "last":
+      return "Structural: the last chord of the progression frames it";
+    case "unfigured":
+      return "Structural: its root neither steps through to the next chord nor returns to the last, so it embellishes nothing";
+    case "passing":
+      return "Passing: its root steps in from the previous chord and on to the next in the same direction";
+    case "neighbor":
+      return "Neighbor: its root steps away from the surrounding harmony and returns to it";
+  }
+}
+var BASIS_READINGS = {
+  function: ({ segment, before, after, keyAt }) => functionalReason(segment, before, after, keyAt),
+  duration: ({ segment, salienceFloor }) => segment.endBeat - segment.startBeat > salienceFloor ? { kind: "salient" } : null
+};
+var REDUCTION_BASES = Object.keys(BASIS_READINGS);
+function levelOf(reason) {
+  if (reason.kind === "passing") {
+    return "passing";
+  }
+  return reason.kind === "neighbor" ? "neighbor" : "structural";
+}
+function reduceProgression(timeline, key, opts = {}) {
+  assertChordTimeline(timeline);
+  const asked = assertOptions(opts, "opts");
+  const keyAt = keyScaleAt(key);
+  const basis = assertOneOf(asked.basis ?? "function", REDUCTION_BASES, "reduction basis");
+  const reading = BASIS_READINGS[basis];
+  const segments = timeline.segments;
+  const floors = basis === "duration" ? salienceFloors(segments.map((segment) => segment.endBeat - segment.startBeat)) : [];
+  const result = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (segment === void 0) {
+      continue;
+    }
+    const previous = segments[index - 1];
+    const following = segments[index + 1];
+    const before = previous !== void 0 && touches(previous, segment) ? previous : void 0;
+    const after = following !== void 0 && touches(segment, following) ? following : void 0;
+    let reason = reading({ segment, before, after, keyAt, salienceFloor: floors[index] ?? 0 });
+    if (reason === null && index === 0) {
+      reason = { kind: "first" };
+    }
+    if (reason === null && index === segments.length - 1) {
+      reason = { kind: "last" };
+    }
+    reason ??= figureReason(segment, before, after) ?? { kind: "unfigured" };
+    result.push({
+      chord: segment.chord,
+      startBeat: segment.startBeat,
+      endBeat: segment.endBeat,
+      level: levelOf(reason),
+      rationale: describe2(reason)
+    });
+  }
+  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) {
+    return false;
+  }
+  const ratio2 = value / unit;
+  return Math.abs(ratio2 - Math.round(ratio2)) < BEAT_EPS;
+}
+function rhythmLevel(beatInQuarters, meters) {
+  const ts = meterAt(beatInQuarters, meters);
+  const offset = beatInQuarters - barStartBeat(beatInQuarters, meters);
+  const pulse = pulseBeats(ts);
+  if (isMultipleOf(offset, pulse)) {
+    return metricWeight(beatInQuarters, meters) + 2;
+  }
+  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(
+    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
+var RHYTHM_SLOTS_PER_BEAT = 12;
+var SLOT_WIDTH = 1 / RHYTHM_SLOTS_PER_BEAT;
+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,
+    endBeat: 0,
+    bars: 0,
+    onsets: 0,
+    onsetDensity: 0,
+    barOnsets: [],
+    onsetLevels: new Array(RHYTHM_LEVEL_COUNT).fill(0),
+    barPositions: [],
+    interOnsetShares: new Array(RHYTHM_IOI_BINS.length).fill(0),
+    restRatio: 0,
+    syncopation: 0,
+    offGridRatio: 0,
+    rationale: "Nothing sounds, so there is no rhythm to place on a grid"
+  };
+}
+function foldOnsets(sounding) {
+  const sorted = [...sounding].sort((a, b) => a.startBeat - b.startBeat);
+  const onsets = [];
+  for (const note of sorted) {
+    const noteEnd = note.startBeat + note.durationBeat;
+    const current = onsets[onsets.length - 1];
+    if (current !== void 0 && note.startBeat - current.beat <= HUMANIZE_ADJACENCY) {
+      current.end = Math.max(current.end, noteEnd);
+    } else {
+      onsets.push({ beat: note.startBeat, end: noteEnd });
+    }
+  }
+  return onsets;
+}
+function snapOnset(onset, meters) {
+  const ts = meterAt(onset.beat, meters);
+  const barStart = barStartBeat(onset.beat, meters);
+  const offset = onset.beat - barStart;
+  const slot = Math.round(offset / SLOT_WIDTH);
+  const snapped = barStart + slot * SLOT_WIDTH;
+  const offGrid = Math.abs(onset.beat - snapped) > RHYTHM_OFF_GRID_TOLERANCE;
+  return { ...onset, ts, barStart, slot, snapped, level: rhythmLevel(snapped, meters), offGrid };
+}
+function tsKey(ts) {
+  return ts.grouping === void 0 ? `${ts.numerator}/${ts.denominator}` : `${ts.numerator}/${ts.denominator}:${ts.grouping.join("+")}`;
+}
+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 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));
+  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;
+  if (span <= 0) {
+    return 0;
+  }
+  const intervals = sounding.map((note) => [
+    Math.max(windowStart, note.startBeat),
+    Math.min(windowEnd, note.startBeat + note.durationBeat)
+  ]).filter(([from, to]) => to > from).sort((a, b) => a[0] - b[0]);
+  let covered = 0;
+  let curStart = 0;
+  let curEnd = Number.NEGATIVE_INFINITY;
+  for (const [from, to] of intervals) {
+    if (from - curEnd > HUMANIZE_ADJACENCY) {
+      if (curEnd > Number.NEGATIVE_INFINITY) {
+        covered += curEnd - curStart;
+      }
+      curStart = from;
+      curEnd = to;
+    } else {
+      curEnd = Math.max(curEnd, to);
+    }
+  }
+  if (curEnd > Number.NEGATIVE_INFINITY) {
+    covered += curEnd - curStart;
+  }
+  return 1 - covered / span;
+}
+function syncopationOf(snapped, startBeat, endBeat, meters) {
+  if (snapped.length === 0) {
+    return 0;
+  }
+  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 point of barGridPoints(bar, meters, otherPulses)) {
+      if (point.beat > startBeat + BEAT_EPS && point.beat <= endBeat + BEAT_EPS) {
+        points.push(point);
+      }
+    }
+  }
+  const normalizer = points.reduce((sum, p) => sum + p.level, 0);
+  if (normalizer <= 0) {
+    return 0;
+  }
+  let numerator = 0;
+  let ptr = 0;
+  for (let i = 0; i < snapped.length; i += 1) {
+    const onset = snapped[i];
+    if (onset === void 0) {
+      continue;
+    }
+    const next = snapped[i + 1];
+    const windowEnd = next !== void 0 ? next.snapped : onset.end;
+    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 > 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 bars = barSpanOf(startBeat, endBeat, meters);
+  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;
+  const firstBar = barIndexAt(startBeat, meters);
+  const barOnsets = new Array(lastBarOf(meters, startBeat, endBeat) - firstBar + 1).fill(0);
+  for (const onset of onsets) {
+    const index = barIndexAt(onset.beat, meters) - firstBar;
+    if (index >= 0 && index < barOnsets.length) {
+      barOnsets[index] = (barOnsets[index] ?? 0) + 1;
+    }
+  }
+  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;
+    if (onset.offGrid) {
+      offGridCount += 1;
+    }
+  }
+  for (let i = 0; i < onsetLevels.length; i += 1) {
+    onsetLevels[i] = (onsetLevels[i] ?? 0) / onsets.length;
+  }
+  const profiles = [];
+  const profileIndex = /* @__PURE__ */ new Map();
+  for (const onset of snapped) {
+    const key = tsKey(onset.ts);
+    let index = profileIndex.get(key);
+    if (index === void 0) {
+      index = profiles.length;
+      profileIndex.set(key, index);
+      const slotsPerBar = Math.ceil(beatsPerBar(onset.ts) * RHYTHM_SLOTS_PER_BEAT);
+      profiles.push({
+        ts: onset.ts,
+        slotsPerBar,
+        shares: new Array(slotsPerBar).fill(0),
+        onsets: 0
+      });
+    }
+    const profile = profiles[index];
+    if (profile !== void 0) {
+      const slotIndex = (onset.slot % profile.slotsPerBar + profile.slotsPerBar) % profile.slotsPerBar;
+      profile.shares[slotIndex] = (profile.shares[slotIndex] ?? 0) + 1;
+      profile.onsets += 1;
+    }
+  }
+  for (const profile of profiles) {
+    for (let i = 0; i < profile.shares.length; i += 1) {
+      profile.shares[i] = (profile.shares[i] ?? 0) / profile.onsets;
+    }
+  }
+  const interOnsetShares = new Array(RHYTHM_IOI_BINS.length).fill(0);
+  for (let i = 0; i < onsets.length; i += 1) {
+    const onset = onsets[i];
+    if (onset === void 0) {
+      continue;
+    }
+    const next = onsets[i + 1];
+    const ioi = next !== void 0 ? next.beat - onset.beat : onset.end - onset.beat;
+    const bin = ioiBinIndex(ioi);
+    interOnsetShares[bin] = (interOnsetShares[bin] ?? 0) + 1;
+  }
+  for (let i = 0; i < interOnsetShares.length; i += 1) {
+    interOnsetShares[i] = (interOnsetShares[i] ?? 0) / onsets.length;
+  }
+  const restRatio = restRatioOf(sounding, startBeat, endBeat);
+  const syncopation = syncopationOf(snapped, startBeat, endBeat, meters);
+  const offGridRatio = offGridCount / onsets.length;
+  return {
+    startBeat,
+    endBeat,
+    bars,
+    onsets: onsets.length,
+    onsetDensity,
+    barOnsets,
+    onsetLevels,
+    barPositions: profiles,
+    interOnsetShares,
+    restRatio,
+    syncopation,
+    offGridRatio,
+    rationale: `${onsets.length} onsets over ${bars.toFixed(2)} bars (${onsetDensity.toFixed(2)} per bar), ${Math.round(restRatio * 100)}% rest, syncopation ${syncopation.toFixed(2)}`
+  };
+}
+
+// src/analyze/reference/validate.ts
+var MASS_TOLERANCE = 1e-9;
+function assertString(value, name) {
+  if (typeof value !== "string") {
+    throw new InvalidInputError(`${name} must be a string; received ${describeRejected(value)}`);
+  }
+  return value;
+}
+function assertSpanOrder(startBeat, endBeat, name) {
+  if (endBeat < startBeat) {
+    throw new InvalidInputError(
+      `${name}.endBeat must be at least ${name}.startBeat; received ${endBeat} < ${startBeat}`
+    );
+  }
+}
+function assertNullable(value, name, validate) {
+  if (value === void 0) {
+    throw new InvalidInputError(`${name} must be present; received undefined`);
+  }
+  return value === null ? null : validate(value, name);
+}
+function assertMassDistribution(value, length, name, allowAllZero) {
+  const shares = assertArray(value, name);
+  if (shares.length !== length) {
+    throw new InvalidInputError(`${name} must have length ${length}; received ${shares.length}`);
+  }
+  let sum = 0;
+  for (let index = 0; index < shares.length; index += 1) {
+    const share = assertFiniteNumber(shares[index], `${name}[${index}]`);
+    if (share < 0) {
+      throw new InvalidInputError(`${name}[${index}] must be at least 0; received ${share}`);
+    }
+    sum += share;
+  }
+  if (allowAllZero && sum === 0) {
+    return shares;
+  }
+  if (Math.abs(sum - 1) > MASS_TOLERANCE) {
+    throw new InvalidInputError(`${name} must sum to 1; received ${sum}`);
+  }
+  return shares;
+}
+function assertBarPositionProfile(value, name) {
+  const read = assertRecord(value, name);
+  assertTimeSignature(read.ts, `${name}.ts`);
+  const slotsPerBar = assertPositiveInt(read.slotsPerBar, `${name}.slotsPerBar`);
+  const onsets = assertInteger(read.onsets, `${name}.onsets`, 0);
+  assertMassDistribution(read.shares, slotsPerBar, `${name}.shares`, onsets === 0);
+  return read;
+}
+function assertRhythmAnalysis(value, name) {
+  const read = assertRecord(value, name);
+  const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
+  const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  assertRange(read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  const onsets = assertInteger(read.onsets, `${name}.onsets`, 0);
+  assertRange(read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  const barOnsets = assertArray(read.barOnsets, `${name}.barOnsets`);
+  for (let index = 0; index < barOnsets.length; index += 1) {
+    assertRange(
+      barOnsets[index],
+      0,
+      Number.MAX_SAFE_INTEGER,
+      `${name}.barOnsets[${index}]`
+    );
+  }
+  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}]`);
+  }
+  assertMassDistribution(
+    read.interOnsetShares,
+    RHYTHM_IOI_BINS.length,
+    `${name}.interOnsetShares`,
+    onsets === 0
+  );
+  assertRange(read.restRatio, 0, 1, `${name}.restRatio`);
+  assertRange(read.syncopation, 0, 1, `${name}.syncopation`);
+  assertRange(read.offGridRatio, 0, 1, `${name}.offGridRatio`);
+  assertString(read.rationale, `${name}.rationale`);
+  return read;
+}
+function assertFormSection(value, name, sectionCount) {
+  const read = assertRecord(value, name);
+  assertString(read.label, `${name}.label`);
+  const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
+  const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  assertRange(read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  assertInteger(read.firstOccurrence, `${name}.firstOccurrence`, 0, Math.max(sectionCount - 1, 0));
+  assertRange(read.similarity, 0, 1, `${name}.similarity`);
+  assertString(read.rationale, `${name}.rationale`);
+  return read;
+}
+function assertReferenceCadence(value, name) {
+  const read = assertRecord(value, name);
+  assertFiniteNumber(read.atBeat, `${name}.atBeat`);
+  assertOneOf(read.type, CADENCE_TYPES, `${name}.type`);
+  assertRange(read.weight, 0, 1, `${name}.weight`);
+  return read;
+}
+function assertReferencePhraseMelody(value, name) {
+  const read = assertRecord(value, name);
+  assertOneOf(read.shape, MELODIC_CONTOUR_SHAPES, `${name}.shape`);
+  assertMidiPitch(read.low, `${name}.low`);
+  assertMidiPitch(read.high, `${name}.high`);
+  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 !== 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}]`);
+  }
+  assertRange(read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  assertRange(read.restRatio, 0, 1, `${name}.restRatio`);
+  return read;
+}
+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,
+    `${name}.section`,
+    (v, n) => assertInteger(v, n, 0, Math.max(sectionCount - 1, 0))
+  );
+  assertRange(read.confidence, 0, 1, `${name}.confidence`);
+  assertNullable(read.cadence, `${name}.cadence`, assertReferenceCadence);
+  assertNullable(read.melody, `${name}.melody`, assertReferencePhraseMelody);
+  const motifNodes = assertArray(read.motifNodes, `${name}.motifNodes`);
+  for (let index = 0; index < motifNodes.length; index += 1) {
+    assertInteger(
+      motifNodes[index],
+      `${name}.motifNodes[${index}]`,
+      0,
+      Math.max(nodeCount - 1, 0)
+    );
+  }
+  return read;
+}
+function assertReferenceForm(value, name, span, nodeCount) {
+  const read = assertRecord(value, name);
+  const hypermeter = assertRecord(
+    read.hypermeter,
+    `${name}.hypermeter`
+  );
+  assertRange(hypermeter.groupBars, 0, Number.MAX_SAFE_INTEGER, `${name}.hypermeter.groupBars`);
+  assertRange(hypermeter.confidence, 0, 1, `${name}.hypermeter.confidence`);
+  const sections = assertArray(read.sections, `${name}.sections`);
+  for (let index = 0; index < sections.length; index += 1) {
+    assertFormSection(sections[index], `${name}.sections[${index}]`, sections.length);
+  }
+  const phrases = assertArray(read.phrases, `${name}.phrases`);
+  for (let index = 0; index < phrases.length; index += 1) {
+    assertReferencePhrase(
+      phrases[index],
+      `${name}.phrases[${index}]`,
+      span,
+      sections.length,
+      nodeCount
+    );
+  }
+  return read;
+}
+function assertResolvedKeyField(value, name) {
+  const read = assertRecord(value, name);
+  try {
+    resolveKey(read);
+  } catch (error) {
+    if (error instanceof InvalidInputError) {
+      throw new InvalidInputError(`${name} must be a valid key: ${error.message}`);
+    }
+    throw error;
+  }
+  return read;
+}
+function assertReferenceKeyRegion(value, name) {
+  const read = assertRecord(value, name);
+  const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
+  const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  assertResolvedKeyField(read.key, `${name}.key`);
+  assertRange(read.confidence, 0, 1, `${name}.confidence`);
+  return read;
+}
+function assertReferenceChord(value, name, keys) {
+  const read = assertRecord(value, name);
+  const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
+  const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  const keyIndex = assertInteger(read.key, `${name}.key`, 0, Math.max(keys.length - 1, 0));
+  const roman = assertString(read.roman, `${name}.roman`);
+  try {
+    romanToChord(roman, keys[keyIndex]);
+  } catch (error) {
+    if (error instanceof InvalidInputError) {
+      throw new InvalidInputError(
+        `${name}.roman must be readable by romanToChord; received ${describeRejected(roman)}: ${error.message}`
+      );
+    }
+    throw error;
+  }
+  assertOneOf(read.function, HARMONIC_FUNCTIONS, `${name}.function`);
+  assertOneOf(read.level, REDUCTION_LEVELS, `${name}.level`);
+  return read;
+}
+function assertReferenceHarmony(value, name) {
+  const read = assertRecord(value, name);
+  const keys = assertArray(read.keys, `${name}.keys`);
+  for (let index = 0; index < keys.length; index += 1) {
+    assertReferenceKeyRegion(keys[index], `${name}.keys[${index}]`);
+  }
+  const resolvedKeys = keys.map((region) => region.key);
+  const chords = assertArray(read.chords, `${name}.chords`);
+  for (let index = 0; index < chords.length; index += 1) {
+    assertReferenceChord(chords[index], `${name}.chords[${index}]`, resolvedKeys);
+  }
+  assertRhythmAnalysis(read.rhythm, `${name}.rhythm`);
+  return read;
+}
+function assertMotifRelationSummary(value, name) {
+  const read = assertRecord(value, name);
+  assertOneOf(read.kind, MOTIF_RELATION_KINDS, `${name}.kind`);
+  assertFlag(read.sequence, `${name}.sequence`);
+  assertFiniteNumber(read.semitones, `${name}.semitones`);
+  if (read.degrees !== void 0) {
+    assertFiniteNumber(read.degrees, `${name}.degrees`);
+  }
+  const timeRatio = assertFiniteNumber(read.timeRatio, `${name}.timeRatio`);
+  if (timeRatio <= 0) {
+    throw new InvalidInputError(`${name}.timeRatio must be positive; received ${timeRatio}`);
+  }
+  return read;
+}
+function assertMotifGraphNode(value, name, occurrenceCounts) {
+  const read = assertRecord(value, name);
+  const motif = assertInteger(
+    read.motif,
+    `${name}.motif`,
+    0,
+    Math.max(occurrenceCounts.length - 1, 0)
+  );
+  assertInteger(
+    read.occurrence,
+    `${name}.occurrence`,
+    0,
+    Math.max((occurrenceCounts[motif] ?? 1) - 1, 0)
+  );
+  const startBeat = assertFiniteNumber(read.startBeat, `${name}.startBeat`);
+  const endBeat = assertFiniteNumber(read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  return read;
+}
+function assertMotifGraphEdge(value, name, nodeCount) {
+  const read = assertRecord(value, name);
+  const from = assertInteger(read.from, `${name}.from`, 0, Math.max(nodeCount - 1, 0));
+  const to = assertInteger(read.to, `${name}.to`, 0, Math.max(nodeCount - 1, 0));
+  if (from >= to) {
+    throw new InvalidInputError(
+      `${name}.from must be less than ${name}.to; received from=${from}, to=${to}`
+    );
+  }
+  assertNullable(read.relation, `${name}.relation`, assertMotifRelationSummary);
+  assertRange(read.similarity, 0, 1, `${name}.similarity`);
+  return read;
+}
+function assertMotifGraph(value, name, occurrenceCounts) {
+  const read = assertRecord(value, name);
+  const nodes = assertArray(read.nodes, `${name}.nodes`);
+  for (let index = 0; index < nodes.length; index += 1) {
+    assertMotifGraphNode(nodes[index], `${name}.nodes[${index}]`, occurrenceCounts);
+  }
+  const edges = assertArray(read.edges, `${name}.edges`);
+  const seenTo = /* @__PURE__ */ new Set();
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = assertMotifGraphEdge(edges[index], `${name}.edges[${index}]`, nodes.length);
+    if (seenTo.has(edge.to)) {
+      throw new InvalidInputError(`${name}.edges: node ${edge.to} has more than one incoming edge`);
+    }
+    seenTo.add(edge.to);
+  }
+  return read;
+}
+function assertReferenceMotif(value, name) {
+  const read = assertRecord(value, name);
+  const intervals = assertArray(read.intervals, `${name}.intervals`);
+  let pitch = 0;
+  let low = 0;
+  let high = 0;
+  for (let index = 0; index < intervals.length; index += 1) {
+    const interval = assertFiniteNumber(intervals[index], `${name}.intervals[${index}]`);
+    if (!Number.isInteger(interval)) {
+      throw new InvalidInputError(
+        `${name}.intervals[${index}] must be a whole number of semitones; received ${interval}`
+      );
+    }
+    pitch += interval;
+    low = Math.min(low, pitch);
+    high = Math.max(high, pitch);
+  }
+  if (high - low > MIDI_MAX) {
+    throw new InvalidInputError(
+      `${name}.intervals must span at most ${MIDI_MAX} semitones; received ${high - low}`
+    );
+  }
+  const rhythm = assertArray(read.rhythm, `${name}.rhythm`);
+  if (rhythm.length !== intervals.length) {
+    throw new InvalidInputError(
+      `${name}.rhythm must hold one ratio per interval (${intervals.length}); received ${rhythm.length}`
+    );
+  }
+  for (let index = 0; index < rhythm.length; index += 1) {
+    const ratio2 = assertFiniteNumber(rhythm[index], `${name}.rhythm[${index}]`);
+    if (!(ratio2 > 0)) {
+      throw new InvalidInputError(`${name}.rhythm[${index}] must be positive; received ${ratio2}`);
+    }
+  }
+  const unitBeats = assertRange(read.unitBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.unitBeats`);
+  if (unitBeats > 0 !== rhythm.length > 0) {
+    throw new InvalidInputError(
+      `${name}.unitBeats must be positive exactly when rhythm is non-empty; received ${unitBeats} with ${rhythm.length} ratio(s)`
+    );
+  }
+  assertRange(read.spanBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.spanBeats`);
+  assertPositiveInt(read.occurrences, `${name}.occurrences`);
+  return read;
+}
+function assertReferenceMelody(value, name) {
+  const read = assertRecord(value, name);
+  assertNullable(read.register, `${name}.register`, (v, n) => {
+    const register = assertRecord(v, n);
+    assertMidiPitch(register.low, `${n}.low`);
+    assertMidiPitch(register.high, `${n}.high`);
+    assertRange(register.mean, 0, MIDI_MAX, `${n}.mean`);
+    return register;
+  });
+  assertNullable(read.shape, `${name}.shape`, (v, n) => assertOneOf(v, MELODIC_CONTOUR_SHAPES, n));
+  const motifs = assertArray(read.motifs, `${name}.motifs`);
+  const occurrenceCounts = [];
+  for (let index = 0; index < motifs.length; index += 1) {
+    assertReferenceMotif(motifs[index], `${name}.motifs[${index}]`);
+    occurrenceCounts.push(motifs[index].occurrences);
+  }
+  assertMotifGraph(read.graph, `${name}.graph`, occurrenceCounts);
+  assertRhythmAnalysis(read.rhythm, `${name}.rhythm`);
+  return read;
+}
+function assertReferenceProfile(value, name = "reference profile") {
+  const read = assertRecord(value, name);
+  if (read.profileVersion !== REFERENCE_PROFILE_VERSION) {
+    throw new InvalidInputError(
+      `${name}.profileVersion must be ${REFERENCE_PROFILE_VERSION}; received ${describeRejected(read.profileVersion)}`
+    );
+  }
+  const span = assertRecord(
+    read.span,
+    `${name}.span`
+  );
+  const startBeat = assertFiniteNumber(span.startBeat, `${name}.span.startBeat`);
+  const endBeat = assertFiniteNumber(span.endBeat, `${name}.span.endBeat`);
+  assertSpanOrder(startBeat, endBeat, `${name}.span`);
+  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`, { startBeat, endBeat }, melody.graph.nodes.length);
+  assertReferenceHarmony(read.harmony, `${name}.harmony`);
+  return read;
+}
+
+// src/analyze/reference/measures.ts
+var PROGRESSION_GAP = 0.75;
+var SAME_DEGREE_COST = 0.25;
+var SAME_FUNCTION_COST = 0.5;
+var HALF_PHRYGIAN_COST = 0.5;
+var MODE_CHANGE_COST = 0.5;
+var SHAPE_MISMATCH_COST = 0.25;
+var REGISTER_SPAN = 24;
+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_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) {
+    return null;
+  }
+  if (!hasA || !hasB) {
+    return 0;
+  }
+  return measure();
+}
+function aligned(a, b, cost, gap = 1) {
+  return distanceToSimilarity(gradedEditDistance(a, b, cost, gap), a.length, b.length);
+}
+function alignedSimilarity(a, b, cost, gap = 1) {
+  return whenBoth(a.length > 0, b.length > 0, () => aligned(a, b, cost, gap));
+}
+function massOf(values) {
+  let total = 0;
+  for (const value of values) {
+    total += value;
+  }
+  return total;
+}
+function intersection(a, b) {
+  const massA = massOf(a);
+  const massB = massOf(b);
+  let shared2 = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    shared2 += Math.min((a[i] ?? 0) / massA, (b[i] ?? 0) / massB);
+  }
+  return Math.min(1, shared2);
+}
+function distributionSimilarity(a, b) {
+  return whenBoth(massOf(a) > 0, massOf(b) > 0, () => intersection(a, b));
+}
+function ratio(a, b) {
+  const larger = Math.max(a, b);
+  return larger === 0 ? 1 : Math.min(a, b) / larger;
+}
+function sectionSequenceSimilarity(a, b) {
+  return alignedSimilarity(a, b, (x, y) => x === y ? 0 : 1);
+}
+function phraseLengthSimilarity(a, b) {
+  return alignedSimilarity(a, b, (x, y) => {
+    const longer = Math.max(x, y);
+    return longer === 0 ? 0 : Math.min(Math.abs(x - y) / longer, 1);
+  });
+}
+function simpleDegreeToken(roman) {
+  for (const name of NAMED_CHORDS) {
+    if (roman.startsWith(name)) {
+      return name;
+    }
+  }
+  const match = roman.match(/^([b#]*)([IV]+)/i);
+  return match ? `${match[1]}${match[2].toUpperCase()}` : roman;
+}
+function romanDegreeToken(roman) {
+  const slash = roman.indexOf("/");
+  if (slash < 0) {
+    return simpleDegreeToken(roman);
+  }
+  return `${simpleDegreeToken(roman.slice(0, slash))}/${simpleDegreeToken(roman.slice(slash + 1))}`;
+}
+function chordCost(x, y) {
+  if (x.roman === y.roman) {
+    return 0;
+  }
+  if (romanDegreeToken(x.roman) === romanDegreeToken(y.roman)) {
+    return SAME_DEGREE_COST;
+  }
+  return x.function === y.function ? SAME_FUNCTION_COST : 1;
+}
+function progressionSimilarity(a, b, budget) {
+  assertGenerationBudget(a.length * b.length, "reference progression alignment", budget);
+  return alignedSimilarity(a, b, chordCost, PROGRESSION_GAP);
+}
+function functionMass(chords) {
+  const mass = HARMONIC_FUNCTIONS.map(() => 0);
+  for (const chord of chords) {
+    const bin = HARMONIC_FUNCTIONS.indexOf(chord.function);
+    mass[bin] = (mass[bin] ?? 0) + Math.max(0, chord.endBeat - chord.startBeat);
+  }
+  return mass;
+}
+function functionSimilarity(a, b) {
+  return distributionSimilarity(functionMass(a), functionMass(b));
+}
+function cadenceSimilarity(a, b) {
+  return alignedSimilarity(a, b, (x, y) => {
+    if (x === y) {
+      return 0;
+    }
+    const halfAndPhrygian = x === "half" && y === "phrygian" || x === "phrygian" && y === "half";
+    return halfAndPhrygian ? HALF_PHRYGIAN_COST : 1;
+  });
+}
+function keyTokens(keys) {
+  const home = keys[0]?.scale.rootPc ?? 0;
+  return keys.map((key) => ({
+    distance: ((key.scale.rootPc - home) % 12 + 12) % 12,
+    mask: key.scale.modeMask12
+  }));
+}
+function keyPlanSimilarity(a, b) {
+  return alignedSimilarity(keyTokens(a), keyTokens(b), (x, y) => {
+    if (x.distance !== y.distance) {
+      return 1;
+    }
+    return x.mask === y.mask ? 0 : MODE_CHANGE_COST;
+  });
+}
+function onsetSimilarity(a, b) {
+  return whenBoth(a.onsets > 0, b.onsets > 0, () => {
+    let weighted = 0;
+    let weight = 0;
+    for (const left of a.barPositions) {
+      for (const right of b.barPositions) {
+        const shared2 = left.ts.numerator === right.ts.numerator && left.ts.denominator === right.ts.denominator && left.onsets > 0 && right.onsets > 0;
+        if (shared2) {
+          const w = left.onsets + right.onsets;
+          weighted += w * intersection(left.shares, right.shares);
+          weight += w;
+        }
+      }
+    }
+    return weight > 0 ? weighted / weight : intersection(a.onsetLevels, b.onsetLevels);
+  });
+}
+function densitySimilarity(a, b) {
+  return whenBoth(a.onsets > 0, b.onsets > 0, () => ratio(a.onsetDensity, b.onsetDensity));
+}
+function durationSimilarity(a, b) {
+  return whenBoth(
+    a.onsets > 0,
+    b.onsets > 0,
+    () => intersection(a.interOnsetShares, b.interOnsetShares)
+  );
+}
+function syncopationSimilarity(a, b) {
+  return whenBoth(a.onsets > 0, b.onsets > 0, () => 1 - Math.abs(a.syncopation - b.syncopation));
+}
+function cellNotes(motif) {
+  const notes = [];
+  let low = 0;
+  let high = 0;
+  let offset = 0;
+  for (const interval of motif.intervals) {
+    offset += interval;
+    low = Math.min(low, offset);
+    high = Math.max(high, offset);
+  }
+  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;
+    notes.push({ pitch, startBeat: beat, durationBeat: i < motif.intervals.length ? step : 1 });
+    pitch += motif.intervals[i] ?? 0;
+    beat += step;
+  }
+  return notes;
+}
+function bestMatchMean(from, to) {
+  let weighted = 0;
+  let weight = 0;
+  for (const motif of from) {
+    let best = 0;
+    for (const other of to) {
+      best = Math.max(best, compareMelodies(motif.cell, other.cell).pitchSimilarity);
+    }
+    weighted += motif.occurrences * best;
+    weight += motif.occurrences;
+  }
+  return weighted / weight;
+}
+function surfaceSimilarity(a, b) {
+  return whenBoth(a.length > 0, b.length > 0, () => {
+    const left = a.map((motif) => ({ cell: cellNotes(motif), occurrences: motif.occurrences }));
+    const right = b.map((motif) => ({ cell: cellNotes(motif), occurrences: motif.occurrences }));
+    return (bestMatchMean(left, right) + bestMatchMean(right, left)) / 2;
+  });
+}
+function coverageOf(graph, spanBeats) {
+  if (!(spanBeats > 0) || graph.nodes.length === 0) {
+    return 0;
+  }
+  const spans = graph.nodes.map((node) => [node.startBeat, node.endBeat]).sort((x, y) => x[0] - y[0] || x[1] - y[1]);
+  let covered = 0;
+  let [runStart, runEnd] = spans[0];
+  for (const [start, end] of spans) {
+    if (start > runEnd) {
+      covered += runEnd - runStart;
+      runStart = start;
+      runEnd = end;
+    } else {
+      runEnd = Math.max(runEnd, end);
+    }
+  }
+  covered += runEnd - runStart;
+  return Math.min(1, covered / spanBeats);
+}
+function bump(histogram, bin) {
+  histogram[bin] = (histogram[bin] ?? 0) + 1;
+}
+function summarise({ graph, spanBeats }) {
+  const kinds = new Array(MOTIF_RELATION_KINDS.length + 1).fill(0);
+  const parentEdge = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const kind = edge.relation?.kind;
+    bump(
+      kinds,
+      kind === void 0 ? MOTIF_RELATION_KINDS.length : MOTIF_RELATION_KINDS.indexOf(kind)
+    );
+    parentEdge.set(edge.to, edge);
+  }
+  const depth = new Array(graph.nodes.length).fill(0);
+  const root = graph.nodes.map((_, i) => i);
+  for (let node = 0; node < graph.nodes.length; node += 1) {
+    const edge = parentEdge.get(node);
+    if (edge !== void 0) {
+      const kind = edge.relation?.kind;
+      const keepsPitch = kind !== void 0 && PITCH_PRESERVING.has(kind);
+      depth[node] = (depth[edge.from] ?? 0) + (keepsPitch ? 0 : 1);
+      root[node] = root[edge.from] ?? edge.from;
+    }
+  }
+  const familySize = /* @__PURE__ */ new Map();
+  for (const r of root) {
+    familySize.set(r, (familySize.get(r) ?? 0) + 1);
+  }
+  const families = new Array(FAMILY_SIZE_BINS).fill(0);
+  for (const size of familySize.values()) {
+    bump(families, Math.min(size, FAMILY_SIZE_BINS) - 1);
+  }
+  const depths = new Array(DEPTH_BINS).fill(0);
+  for (const d of depth) {
+    bump(depths, Math.min(d, DEPTH_BINS - 1));
+  }
+  return { kinds, families, depths, coverage: coverageOf(graph, spanBeats) };
+}
+function motifStructureSimilarity(a, b) {
+  const left = summarise(a);
+  const right = summarise(b);
+  const terms = [
+    distributionSimilarity(left.kinds, right.kinds),
+    distributionSimilarity(left.families, right.families),
+    distributionSimilarity(left.depths, right.depths),
+    whenBoth(
+      left.coverage > 0,
+      right.coverage > 0,
+      () => 1 - Math.abs(left.coverage - right.coverage)
+    )
+  ].filter((term) => term !== null);
+  return terms.length === 0 ? null : massOf(terms) / terms.length;
+}
+function nullableCost(cost) {
+  return (x, y) => {
+    if (x === null || y === null) {
+      return x === y ? 0 : 1;
+    }
+    return cost(x, y);
+  };
+}
+function phraseSimilarity(a, b, cost) {
+  const hasA = a.some((phrase) => phrase !== null);
+  const hasB = b.some((phrase) => phrase !== null);
+  return whenBoth(hasA, hasB, () => aligned(a, b, nullableCost(cost)));
+}
+function normalisedOutline(phrase) {
+  const mean = massOf(phrase.outline) / (phrase.outline.length || 1);
+  const range = phrase.high - phrase.low || 1;
+  return phrase.outline.map((point) => (point - mean) / range);
+}
+function contourCost(x, y) {
+  const left = normalisedOutline(x);
+  const right = normalisedOutline(y);
+  let difference = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    difference += Math.abs((left[i] ?? 0) - (right[i] ?? 0));
+  }
+  const outlineCost = Math.min(1, difference / (left.length || 1));
+  return Math.min(1, outlineCost + (x.shape === y.shape ? 0 : SHAPE_MISMATCH_COST));
+}
+function contourSimilarity(a, b) {
+  return phraseSimilarity(a, b, contourCost);
+}
+function registerSimilarity(a, b) {
+  const meanA = a.mean ?? 0;
+  const meanB = b.mean ?? 0;
+  return phraseSimilarity(a.phrases, b.phrases, (x, y) => {
+    const offset = Math.abs(x.mean - meanA - (y.mean - meanB));
+    const range = Math.abs(x.high - x.low - (y.high - y.low));
+    const peak = Math.abs(x.peakPosition - y.peakPosition);
+    return Math.min(1, (offset + range) / REGISTER_SPAN + PEAK_POSITION_WEIGHT * peak);
+  });
+}
+
+// src/analyze/reference/internal.ts
+function weightedMean(notes) {
+  let weighted = 0;
+  let total = 0;
+  for (const note of notes) {
+    weighted += note.pitch * note.durationBeat;
+    total += note.durationBeat;
+  }
+  return total > 0 ? weighted / total : 0;
+}
+function phraseMelody(line, startBeat, endBeat, lineMean, meters, budget) {
+  const inside = line.filter((note) => note.startBeat >= startBeat - BEAT_EPS && note.startBeat < endBeat - BEAT_EPS).map((note) => ({
+    ...note,
+    durationBeat: Math.min(note.startBeat + note.durationBeat, endBeat) - note.startBeat
+  }));
+  const first = inside[0];
+  if (first === void 0 || inside.length < 2) {
+    return null;
+  }
+  let low = first.pitch;
+  let peak = first;
+  for (const note of inside) {
+    low = Math.min(low, note.pitch);
+    if (note.pitch > peak.pitch) {
+      peak = note;
+    }
+  }
+  const length = endBeat - startBeat;
+  const outline = [];
+  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) {
+        break;
+      }
+      held = note;
+    }
+    outline.push(held.pitch - lineMean);
+  }
+  const rhythm = rhythmOver(inside, { meters, totalBeats: endBeat, budget }, startBeat);
+  return {
+    shape: melodicContour(inside).shape,
+    low,
+    high: peak.pitch,
+    mean: weightedMean(inside),
+    peakPitch: peak.pitch,
+    peakPosition: Math.min(1, Math.max(0, (peak.startBeat - startBeat) / length)),
+    outline,
+    onsetDensity: rhythm.onsetDensity,
+    restRatio: rhythm.restRatio
+  };
+}
+
+export {
+  HUMANIZE_ADJACENCY,
+  sameInstant,
+  adjacent,
+  hasEnded,
+  windowWeights,
+  MODAL_SCALE_NAMES,
+  detectChord,
+  detectChordBest,
+  detectKey,
+  detectKeyFromNotes,
+  detectKeyBest,
+  barSpanOf,
+  clamp01,
+  floorMod,
+  firstSoundingBeat,
+  resolveSpanEnd,
+  lastBarOf,
+  sliceBars,
+  weightSimilarity,
+  harmonicNovelty,
+  combineEvidence,
+  augmentedSixthChord,
+  augmentedSixthKind,
+  augmentedSixthFromPitchClasses,
+  spellAugmentedSixth,
+  CADENCE_TYPES,
+  detectCadence,
+  isBorrowedChord,
+  borrowedSource,
+  romanToChord,
+  chordToRoman,
+  explainRoman,
+  HARMONIC_FUNCTIONS,
+  isMinorKey,
+  functionOf,
+  isDiatonic,
+  parallelKey,
+  analyzeChord,
+  secondaryDominant,
+  secondaryDominantOf,
+  pivotChords,
   gridForNotes,
+  latestSoundingEnd,
   barGridStart,
   keyTimelineFromNotes,
   detectModulations,
   attachPivots,
   keyLookup,
   prevailingKeyOf,
-  keyScaleAt,
   toVoiceNotes,
   analyzeVoice,
   assertChordTimeline,
+  assertSpansInOrder,
+  statedKeyRegions,
   chordTimelineFromChords,
   chordAtBeat,
   segmentStartingAt,
   chordTimelineFromNotes,
   dirtySlotsFor,
   analyzeTimeline,
-  detectCadences
+  detectCadences,
+  orderedNotes,
+  MELODIC_CONTOUR_SHAPES,
+  melodicContour,
+  extractMotifs,
+  motifFromNotes,
+  MOTIF_RELATION_KINDS,
+  relateMotifs,
+  compareMelodies,
+  melodicSimilarity,
+  DEFAULT_VARIATION_THRESHOLD,
+  motifGraph,
+  REDUCTION_LEVELS,
+  reduceProgression,
+  REFERENCE_PROFILE_VERSION,
+  sectionSequenceSimilarity,
+  phraseLengthSimilarity,
+  progressionSimilarity,
+  functionSimilarity,
+  cadenceSimilarity,
+  keyPlanSimilarity,
+  onsetSimilarity,
+  densitySimilarity,
+  durationSimilarity,
+  syncopationSimilarity,
+  surfaceSimilarity,
+  motifStructureSimilarity,
+  contourSimilarity,
+  registerSimilarity,
+  rhythmLevel,
+  ioiBinIndex,
+  RHYTHM_IOI_BINS,
+  analyzeRhythm,
+  rhythmOver,
+  assertReferenceProfile,
+  weightedMean,
+  phraseMelody
 };
-//# sourceMappingURL=chunk-H2KJHBW4.js.map
+//# sourceMappingURL=chunk-FJFULJZE.js.map