@libraz/libcantus 1.2.0 → 1.3.0

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

@@ -33,6 +33,7 @@ import {
   isNeapolitanChordOf,
   isScaleTone,
   keyRelationBetween,
+  keySignatureFifths,
   majorKey,
   makeChord,
   minorKey,
@@ -55,25 +56,37 @@ 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,
+  meterAt,
   metricGridUnit,
   metricWeight,
+  midiToNote,
   parseInterval,
   pitchClassOf,
+  pulseBeats,
   resolveMeters,
+  spelledInterval,
   toNoteData,
   transposeByInterval,
   transposeNote
@@ -779,6 +792,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);
@@ -1466,6 +1487,7 @@ function capitalize(text) {
 }
 
 // src/analyze/functional/function.ts
+var HARMONIC_FUNCTIONS = Object.freeze(["tonic", "subdominant", "dominant"]);
 var FUNCTION_BY_OFFSET = [
   "tonic",
   // 0  I
@@ -1669,6 +1691,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));
 }
@@ -3267,6 +3299,1805 @@ function detectCadences(timeline, key) {
   return hits;
 }
 
+// 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) {
+  let end = 0;
+  for (const note of notes) {
+    end = Math.max(end, note.startBeat + note.durationBeat);
+  }
+  return end;
+}
+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: `${share}% of the motion runs ${net > 0 ? "up" : "down"}, 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 (${share}% of the motion nets out), 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 spelling = spellingOf(key);
+  return spelledInterval(midiToNote(from, spelling), midiToNote(to, spelling));
+}
+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`
+        };
+      }
+    }
+  }
+  if (forward && shapes.includes("inversion")) {
+    return {
+      ...base,
+      kind: "inversion",
+      rationale: "Inversion: every interval turned upside down 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);
+  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 = /* @__PURE__ */ new Set(["authentic", "plagal", "modal", "deceptive"]);
+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/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;
+}
+function ioiBinIndex(ioi) {
+  const exponent = Math.min(4, Math.max(-4, Math.round(2 * Math.log2(ioi)) / 2));
+  return Math.round((exponent + 4) / 0.5);
+}
+
+// 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))
+);
+function emptyAnalysis() {
+  return {
+    startBeat: 0,
+    endBeat: 0,
+    bars: 0,
+    onsets: 0,
+    onsetDensity: 0,
+    barOnsets: [],
+    onsetLevels: new Array(6).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 barGridBeats(bar, meters) {
+  const barStart = barPositionToBeat({ bar, beat: 0 }, meters);
+  const ts = meterAt(barStart, meters);
+  const barLength = beatsPerBarAt(barStart, meters);
+  const subUnit = pulseBeats(ts) / (isCompound(ts) ? 3 : 2);
+  const steps = Math.max(1, Math.round(barLength / subUnit));
+  return Array.from({ length: steps }, (_, k) => barStart + k * subUnit);
+}
+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 points = [];
+  for (let bar = firstBar; bar <= lastBar; bar += 1) {
+    for (const beat of barGridBeats(bar, meters)) {
+      if (beat > startBeat + BEAT_EPS && beat <= endBeat + BEAT_EPS) {
+        points.push({ beat, level: rhythmLevel(beat, meters) });
+      }
+    }
+  }
+  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;
+    }
+    let scan = ptr;
+    let maxLevel = 0;
+    while (scan < points.length && (points[scan]?.beat ?? Number.POSITIVE_INFINITY) < windowEnd - BEAT_EPS) {
+      maxLevel = Math.max(maxLevel, points[scan]?.level ?? 0);
+      scan += 1;
+    }
+    if (maxLevel > onset.level) {
+      numerator += maxLevel - onset.level;
+    }
+    ptr = scan;
+  }
+  return numerator / normalizer;
+}
+function analyzeRhythm(notes, opts = {}) {
+  const meters = resolveMeters(opts, "rhythm meters");
+  assertNoteEvents(notes, "rhythm notes", { allowNonPositiveDuration: true, budget: opts.budget });
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  if (sounding.length === 0) {
+    return emptyAnalysis();
+  }
+  const firstOnset = sounding.reduce(
+    (min, n) => Math.min(min, n.startBeat),
+    Number.POSITIVE_INFINITY
+  );
+  const startBeat = barGridStart(firstOnset, meters);
+  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
+  const endBeat = Math.max(startBeat, opts.totalBeats ?? lastEnd);
+  assertRange(endBeat, 0, Number.MAX_SAFE_INTEGER, "rhythm totalBeats");
+  const bars = barSpanOf(startBeat, endBeat, meters);
+  assertGenerationBudget(Math.ceil(bars) * 48, "rhythm analysis slots", opts.budget);
+  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(6).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/types.ts
+var REFERENCE_PROFILE_VERSION = 1;
+
+// 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, 6, `${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, 127, `${name}.mean`);
+  assertRange(read.peakPitch, 0, 127, `${name}.peakPitch`);
+  assertRange(read.peakPosition, 0, 1, `${name}.peakPosition`);
+  const outline = assertArray(read.outline, `${name}.outline`);
+  if (outline.length !== 8) {
+    throw new InvalidInputError(`${name}.outline must have length 8; received ${outline.length}`);
+  }
+  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, 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(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, 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}]`, 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 > 127) {
+    throw new InvalidInputError(
+      `${name}.intervals must span at most 127 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, 127, `${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`, 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 = /* @__PURE__ */ new Set([
+  "repetition",
+  "augmentation",
+  "diminution"
+]);
+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(127 - 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 < 8; k += 1) {
+    const at = startBeat + (k + 0.5) * length / 8;
+    let held = first;
+    for (const note of inside) {
+      if (note.startBeat > at + BEAT_EPS) {
+        break;
+      }
+      held = note;
+    }
+    outline.push(held.pitch - lineMean);
+  }
+  const rhythm = analyzeRhythm(inside, { meters, totalBeats: endBeat, budget });
+  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,
@@ -3283,14 +5114,14 @@ export {
   augmentedSixthKind,
   augmentedSixthFromPitchClasses,
   spellAugmentedSixth,
-  isCadentialSixFour,
+  CADENCE_TYPES,
   detectCadence,
   isBorrowedChord,
   borrowedSource,
-  isAppliedDominant,
   romanToChord,
   chordToRoman,
   explainRoman,
+  HARMONIC_FUNCTIONS,
   isMinorKey,
   functionOf,
   isDiatonic,
@@ -3299,6 +5130,7 @@ export {
   secondaryDominant,
   secondaryDominantOf,
   pivotChords,
+  barSpanOf,
   clamp01,
   floorMod,
   firstSoundingBeat,
@@ -3314,7 +5146,6 @@ export {
   attachPivots,
   keyLookup,
   prevailingKeyOf,
-  keyScaleAt,
   toVoiceNotes,
   analyzeVoice,
   assertChordTimeline,
@@ -3324,6 +5155,41 @@ export {
   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,
+  sectionSequenceSimilarity,
+  phraseLengthSimilarity,
+  progressionSimilarity,
+  functionSimilarity,
+  cadenceSimilarity,
+  keyPlanSimilarity,
+  onsetSimilarity,
+  densitySimilarity,
+  durationSimilarity,
+  syncopationSimilarity,
+  surfaceSimilarity,
+  motifStructureSimilarity,
+  contourSimilarity,
+  registerSimilarity,
+  rhythmLevel,
+  ioiBinIndex,
+  RHYTHM_IOI_BINS,
+  analyzeRhythm,
+  REFERENCE_PROFILE_VERSION,
+  assertReferenceProfile,
+  weightedMean,
+  phraseMelody
 };
-//# sourceMappingURL=chunk-H2KJHBW4.js.map
+//# sourceMappingURL=chunk-GNVN4PPJ.js.map