@libraz/libcantus 1.1.0 → 1.3.0

package/dist/{chunk-Q6R3QAZD.cjs → chunk-IFZDWIKM.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkTT6PKMPRcjs = require('./chunk-TT6PKMPR.cjs');
+var _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
 
 
 
@@ -47,8 +47,8 @@ var _chunkTT6PKMPRcjs = require('./chunk-TT6PKMPR.cjs');
 
 
 
-var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
+var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
@@ -77,18 +77,31 @@ var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
-var _chunkXKSO2V5Icjs = require('./chunk-XKSO2V5I.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
 
 // src/analyze/detect/modes.ts
 var MODAL_CANDIDATES = Object.freeze([
-  { scaleName: "dorian", mode: "minor", mask: _chunkYPB3A3EYcjs.DORIAN_MASK, substitutions: [[8, 9]] },
-  { scaleName: "phrygian", mode: "minor", mask: _chunkYPB3A3EYcjs.PHRYGIAN_MASK, substitutions: [[2, 1]] },
-  { scaleName: "lydian", mode: "major", mask: _chunkYPB3A3EYcjs.LYDIAN_MASK, substitutions: [[5, 6]] },
-  { scaleName: "mixolydian", mode: "major", mask: _chunkYPB3A3EYcjs.MIXOLYDIAN_MASK, substitutions: [[11, 10]] },
+  { scaleName: "dorian", mode: "minor", mask: _chunk3R3QVKY5cjs.DORIAN_MASK, substitutions: [[8, 9]] },
+  { scaleName: "phrygian", mode: "minor", mask: _chunk3R3QVKY5cjs.PHRYGIAN_MASK, substitutions: [[2, 1]] },
+  { scaleName: "lydian", mode: "major", mask: _chunk3R3QVKY5cjs.LYDIAN_MASK, substitutions: [[5, 6]] },
+  { scaleName: "mixolydian", mode: "major", mask: _chunk3R3QVKY5cjs.MIXOLYDIAN_MASK, substitutions: [[11, 10]] },
   {
     scaleName: "locrian",
     mode: "minor",
-    mask: _chunkYPB3A3EYcjs.LOCRIAN_MASK,
+    mask: _chunk3R3QVKY5cjs.LOCRIAN_MASK,
     substitutions: [
       [2, 1],
       [7, 6]
@@ -115,12 +128,12 @@ function resolveModalCandidates(modes) {
     return MODAL_CANDIDATES;
   }
   if (!Array.isArray(modes)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("modes must be a boolean or an array of mode names");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("modes must be a boolean or an array of mode names");
   }
   const requested = new Set(modes);
   for (const name of requested) {
     if (!MODAL_SCALE_NAMES.some((known) => known === name)) {
-      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
         `unknown mode '${String(name)}'; expected one of ${MODAL_SCALE_NAMES.join(", ")}`
       );
     }
@@ -131,7 +144,7 @@ function resolveModalCandidates(modes) {
 // src/analyze/adjacency.ts
 var HUMANIZE_ADJACENCY = 0.05;
 function sameInstant(beat, other) {
-  return Math.abs(beat - other) <= _chunkXKSO2V5Icjs.BEAT_EPS;
+  return Math.abs(beat - other) <= _chunkS5BKZZGMcjs.BEAT_EPS;
 }
 function adjacent(prevEnd, nextStart) {
   return Math.abs(nextStart - prevEnd) <= HUMANIZE_ADJACENCY;
@@ -145,7 +158,7 @@ var MAX_VELOCITY = 127;
 var ACCENT_DIVISOR = 3;
 function noteWeight(note, beats, meter) {
   const velocityFactor = note.velocity !== void 0 ? note.velocity / MAX_VELOCITY : 1;
-  const accent = meter === void 0 ? 1 : 1 + _chunkXKSO2V5Icjs.metricWeight.call(void 0, note.startBeat, meter) / ACCENT_DIVISOR;
+  const accent = meter === void 0 ? 1 : 1 + _chunkS5BKZZGMcjs.metricWeight.call(void 0, note.startBeat, meter) / ACCENT_DIVISOR;
   return beats * velocityFactor * accent;
 }
 function bucketNotesBySlot(notes, grid, slotCount, opts) {
@@ -158,7 +171,7 @@ function bucketNotesBySlot(notes, grid, slotCount, opts) {
       Math.ceil((note.startBeat + note.durationBeat - grid.origin) / grid.slotBeats)
     );
     memberships += Math.max(0, lastExclusive - first);
-    _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, memberships, opts.name, opts.budget);
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, opts.name, opts.budget);
     for (let slot = first; slot < lastExclusive; slot += 1) {
       _optionalChain([buckets, 'access', _2 => _2[slot], 'optionalAccess', _3 => _3.push, 'call', _4 => _4(note)]);
     }
@@ -171,14 +184,14 @@ function windowWeights(notes, windowStart, windowEnd, meter) {
   for (const note of notes) {
     const noteEnd = note.startBeat + note.durationBeat;
     const overlap = Math.min(noteEnd, windowEnd) - Math.max(note.startBeat, windowStart);
-    if (overlap <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
-    const onsetInWindow = note.startBeat >= windowStart - _chunkXKSO2V5Icjs.BEAT_EPS && note.startBeat < windowEnd - _chunkXKSO2V5Icjs.BEAT_EPS;
-    const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, note.pitch);
+    const onsetInWindow = note.startBeat >= windowStart - _chunkS5BKZZGMcjs.BEAT_EPS && note.startBeat < windowEnd - _chunkS5BKZZGMcjs.BEAT_EPS;
+    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch);
     const weight = noteWeight(note, overlap, onsetInWindow ? meter : void 0);
     weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + weight;
-    if (weight > _chunkXKSO2V5Icjs.BEAT_EPS && note.pitch < lowestPitch) {
+    if (weight > _chunkS5BKZZGMcjs.BEAT_EPS && note.pitch < lowestPitch) {
       lowestPitch = note.pitch;
     }
   }
@@ -213,12 +226,12 @@ var NAMED_PROFILES = {
 };
 function assertProfileVector(vector, name) {
   if (vector.length !== PROFILE_LENGTH) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`${name} must have ${PROFILE_LENGTH} entries`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must have ${PROFILE_LENGTH} entries`);
   }
   for (let index = 0; index < vector.length; index += 1) {
     const value = vector[index];
     if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`${name}[${index}] must be a finite number`);
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}[${index}] must be a finite number`);
     }
   }
 }
@@ -229,18 +242,18 @@ function resolveKeyProfile(profile) {
   if (typeof profile === "string") {
     const named = NAMED_PROFILES[profile];
     if (named === void 0) {
-      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
         `unknown key profile '${profile}'; expected one of ${Object.keys(NAMED_PROFILES).join(", ")}`
       );
     }
     return named;
   }
   if (typeof profile !== "object" || profile === null) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("profile must be a profile name or a { major, minor } pair");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("profile must be a profile name or a { major, minor } pair");
   }
   const { major, minor } = profile;
   if (!Array.isArray(major) || !Array.isArray(minor)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("profile must carry a major and a minor vector");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("profile must carry a major and a minor vector");
   }
   assertProfileVector(major, "profile.major");
   assertProfileVector(minor, "profile.minor");
@@ -290,44 +303,44 @@ function profileScore(dist, vector, tonic) {
 
 // src/analyze/detect/index.ts
 function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(_chunkXKSO2V5Icjs.pitchClassOf))].sort((a, b) => a - b);
+  return [...new Set(pitches.map(_chunkS5BKZZGMcjs.pitchClassOf))].sort((a, b) => a - b);
 }
 function assertPitches(pitches, name, budget = void 0) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, pitches, name);
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, pitches, name);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
   for (let index = 0; index < pitches.length; index += 1) {
-    _chunkXKSO2V5Icjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
+    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
   }
 }
 function detectChord(pitches, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
   assertPitches(pitches, "chord detection pitches");
-  if (asked.bassPc !== void 0) _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, asked.bassPc, "bassPc");
+  if (asked.bassPc !== void 0) _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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 bassPc = asked.bassPc !== void 0 ? _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, asked.bassPc) : inputKind === "midi" ? _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
+  const bassPc = asked.bassPc !== void 0 ? _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, asked.bassPc) : inputKind === "midi" ? _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
   const inputSet = new Set(input);
   const matches = [];
-  const qualities = _chunkYPB3A3EYcjs.chordQualities.call(void 0, );
+  const qualities = _chunk3R3QVKY5cjs.chordQualities.call(void 0, );
   const toneCounts = new Map(
-    qualities.map((quality) => [quality, _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, 0, quality)).length])
+    qualities.map((quality) => [quality, _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 0, quality)).length])
   );
   const qualityRank = new Map(qualities.map((quality, index) => [quality, index]));
   for (const rootPc of input) {
     for (const quality of qualities) {
-      const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, quality);
-      const tones = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord);
+      const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality);
+      const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
       const toneSet = new Set(tones);
       const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + 7);
+      const fifthPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 7);
       if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
         continue;
       }
       const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + iv) === bassPc);
+      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + iv) === bassPc);
       const inversion = bassPc === void 0 || bassIndex < 0 ? null : bassIndex;
       const match = {
         rootPc,
@@ -372,15 +385,15 @@ function detectChordBest(pitches, opts = {}) {
   if (!best) {
     return null;
   }
-  return _chunkYPB3A3EYcjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
+  return _chunk3R3QVKY5cjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
 }
 var MINOR_VARIANTS = [
-  { variant: "natural", mask: _chunkYPB3A3EYcjs.NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
-  { variant: "harmonic", mask: _chunkYPB3A3EYcjs.HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
-  { variant: "melodic", mask: _chunkYPB3A3EYcjs.MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
+  { variant: "natural", mask: _chunk3R3QVKY5cjs.NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
+  { variant: "harmonic", mask: _chunk3R3QVKY5cjs.HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
+  { variant: "melodic", mask: _chunk3R3QVKY5cjs.MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
 ];
 var MAJOR_VARIANTS = [
-  { variant: "major", mask: _chunkYPB3A3EYcjs.MAJOR_MASK, scaleName: "major" }
+  { variant: "major", mask: _chunk3R3QVKY5cjs.MAJOR_MASK, scaleName: "major" }
 ];
 var SCALE_NAME_ORDER = [
   "major",
@@ -407,7 +420,7 @@ function quoteScores(rival, winner) {
   return `${rival.toFixed(digits)} against ${winner.toFixed(digits)}`;
 }
 function keyLabel(match) {
-  const tonic = _chunkXKSO2V5Icjs.formatNote.call(void 0, _chunkYPB3A3EYcjs.spelledKeyOf.call(void 0, match.key).tonic);
+  const tonic = _chunkS5BKZZGMcjs.formatNote.call(void 0, _chunk3R3QVKY5cjs.spelledKeyOf.call(void 0, match.key).tonic);
   const scale = match.scaleName.replace(/([A-Z])/g, " $1").toLowerCase();
   return `${tonic} ${scale}`;
 }
@@ -438,11 +451,11 @@ function explainMatches(results, inputSize) {
   winner.alternatives = results.slice(1, EXPLAINED_RIVALS + 1).map((rival) => ({ label: keyLabel(rival), reason: keyRivalReason(winner, rival) }));
 }
 function detectKey(pitches, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "opts");
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
   assertPitches(pitches, "key detection pitches", asked.budget);
   const weights = asked.weights;
   if (weights !== void 0 && weights.length !== pitches.length) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("weights must have one entry per pitch");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("weights must have one entry per pitch");
   }
   const profile = resolveKeyProfile(opts.profile);
   const modalCandidates = resolveModalCandidates(opts.modes).map((candidate) => ({
@@ -453,11 +466,11 @@ function detectKey(pitches, opts = {}) {
   let total = 0;
   for (let index = 0; index < pitches.length; index += 1) {
     const weight = weights === void 0 ? 1 : _nullishCoalesce(weights[index], () => ( 0));
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
     if (weight <= 0) {
       continue;
     }
-    const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(pitches[index], () => ( 0)));
+    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(pitches[index], () => ( 0)));
     counts.set(pc, (_nullishCoalesce(counts.get(pc), () => ( 0))) + weight);
     total += weight;
   }
@@ -538,8 +551,8 @@ function detectKey(pitches, opts = {}) {
   return results;
 }
 function detectKeyFromNotes(notes, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
     allowNonPositiveDuration: true,
     budget: asked.budget
   });
@@ -561,40 +574,40 @@ function detectKeyBest(pitches, opts = {}) {
 
 // src/analyze/functional/internal.ts
 function isMinorScale(key) {
-  return _chunkYPB3A3EYcjs.isMinorMask.call(void 0, key.modeMask12);
+  return _chunk3R3QVKY5cjs.isMinorMask.call(void 0, key.modeMask12);
 }
 function parallelScale(key) {
   return {
-    rootPc: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc),
-    modeMask12: isMinorScale(key) ? _chunkYPB3A3EYcjs.MAJOR_MASK : _chunkYPB3A3EYcjs.NATURAL_MINOR_MASK
+    rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc),
+    modeMask12: isMinorScale(key) ? _chunk3R3QVKY5cjs.MAJOR_MASK : _chunk3R3QVKY5cjs.NATURAL_MINOR_MASK
   };
 }
 function degreeRootPc(degreeNumber, key) {
-  const tones = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
   if (tones.length === 0) {
-    return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc);
+    return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
   }
   const index = ((degreeNumber - 1) % tones.length + tones.length) % tones.length;
-  return _nullishCoalesce(tones[index], () => ( _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc)));
+  return _nullishCoalesce(tones[index], () => ( _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc)));
 }
 function loweredDegrees(key) {
-  const tones = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
   const out = /* @__PURE__ */ new Set();
   if (tones.length !== 7) {
     return out;
   }
-  const major = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYPB3A3EYcjs.MAJOR_MASK });
+  const major = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.MAJOR_MASK });
   for (let index = 0; index < 7; index += 1) {
     const tone = tones[index];
     const majorTone = major[index];
-    if (tone !== void 0 && majorTone !== void 0 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
+    if (tone !== void 0 && majorTone !== void 0 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
       out.add(index + 1);
     }
   }
   return out;
 }
 function romanReference(key) {
-  return _chunkYPB3A3EYcjs.heptatonicFrameOf.call(void 0, key);
+  return _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key);
 }
 
 // src/analyze/functional/augmented-sixth.ts
@@ -606,11 +619,11 @@ var TONES_ABOVE_BASS = {
   german: [0, 4, 7, 10]
 };
 var SPELLED_ABOVE_BASS = {
-  italian: ["P1", "M3", "A6"].map((name) => _chunkXKSO2V5Icjs.parseInterval.call(void 0, name)),
-  french: ["P1", "M3", "A4", "A6"].map((name) => _chunkXKSO2V5Icjs.parseInterval.call(void 0, name)),
-  german: ["P1", "M3", "P5", "A6"].map((name) => _chunkXKSO2V5Icjs.parseInterval.call(void 0, name))
+  italian: ["P1", "M3", "A6"].map((name) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name)),
+  french: ["P1", "M3", "A4", "A6"].map((name) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name)),
+  german: ["P1", "M3", "P5", "A6"].map((name) => _chunkS5BKZZGMcjs.parseInterval.call(void 0, name))
 };
-var BASS_INTERVAL = _chunkXKSO2V5Icjs.parseInterval.call(void 0, "m6");
+var BASS_INTERVAL = _chunkS5BKZZGMcjs.parseInterval.call(void 0, "m6");
 var CHORD_SHAPE = {
   italian: { rootAboveBass: 0, quality: "dom7", intervals: [0, 4, 10] },
   french: { rootAboveBass: 6, quality: "7b5", intervals: [0, 4, 6, 10] },
@@ -629,7 +642,7 @@ var SYMBOL_BY_KIND = {
   german: "Ger6"
 };
 function bassPcOf(key) {
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc + BASS_ABOVE_TONIC);
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + BASS_ABOVE_TONIC);
 }
 function bareSpelling(note) {
   return { letter: note.letter, alter: note.alter };
@@ -643,13 +656,13 @@ function augmentedSixthChord(kind, key) {
   return augmentedSixthOn(kind, key);
 }
 function augmentedSixthOn(kind, keyLike) {
-  const checked = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const checked = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
   const shape = CHORD_SHAPE[checked];
-  const { scale: key, tonic } = _chunkYPB3A3EYcjs.resolveKey.call(void 0, keyLike);
+  const { scale: key, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
   const bassPc = bassPcOf(key);
-  const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, bassPc);
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, bassPc);
   chord.intervals = [...shape.intervals];
-  const bass = _chunkXKSO2V5Icjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
+  const bass = _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
   const tones = spelledInChordOrder(checked, tonic);
   const [root = bass] = tones;
   chord.rootSpelling = bareSpelling(root);
@@ -660,55 +673,55 @@ function augmentedSixthOn(kind, keyLike) {
 function kindOfPitchClasses(pcs, bass) {
   for (const kind of KINDS) {
     const tones = TONES_ABOVE_BASS[kind];
-    if (pcs.size === tones.length && tones.every((tone) => pcs.has(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, bass + tone)))) {
+    if (pcs.size === tones.length && tones.every((tone) => pcs.has(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bass + tone)))) {
       return kind;
     }
   }
   return null;
 }
 function spellingId(note) {
-  return `${_chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
+  return `${_chunkS5BKZZGMcjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
 }
 function spellsAugmentedSixth(chord, kind, key) {
   const tonic = key.tonic;
-  const written = new Set(_chunkYPB3A3EYcjs.spellChord.call(void 0, chord, tonic, key.scale).map(spellingId));
+  const written = new Set(_chunk3R3QVKY5cjs.spellChord.call(void 0, chord, tonic, key.scale).map(spellingId));
   const tones = spelledFromTonic(kind, tonic).map(spellingId);
   return written.size === tones.length && tones.every((tone) => written.has(tone));
 }
 function augmentedSixthKind(chord, key) {
-  return augmentedSixthKindOf(_chunkYPB3A3EYcjs.toChordData.call(void 0, chord), key);
+  return augmentedSixthKindOf(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key);
 }
 function augmentedSixthKindOf(chord, keyLike) {
-  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
   const bass = bassPcOf(resolved.scale);
-  if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
+  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
     return null;
   }
-  const kind = kindOfPitchClasses(new Set(_chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord)), bass);
+  const kind = kindOfPitchClasses(new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord)), bass);
   if (kind === null || !spellsAugmentedSixth(chord, kind, resolved)) {
     return null;
   }
   return kind;
 }
 function augmentedSixthFromPitchClasses(pcs, bassPc, key) {
-  return augmentedSixthOverBass(_chunkXKSO2V5Icjs.assertArray.call(void 0, pcs, "pcs"), bassPc, key);
+  return augmentedSixthOverBass(_chunkS5BKZZGMcjs.assertArray.call(void 0, pcs, "pcs"), bassPc, key);
 }
 function augmentedSixthOverBass(pcs, bassPc, keyLike) {
-  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
   const bass = bassPcOf(resolved.scale);
-  if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, bassPc) !== bass) {
+  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc) !== bass) {
     return null;
   }
-  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkXKSO2V5Icjs.pitchClassOf)), bass);
+  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkS5BKZZGMcjs.pitchClassOf)), bass);
   return kind === null ? null : augmentedSixthOn(kind, resolved);
 }
 function spellAugmentedSixth(kind, tonic) {
-  return spelledFromTonic(kind, _chunkXKSO2V5Icjs.toNoteData.call(void 0, tonic));
+  return spelledFromTonic(kind, _chunkS5BKZZGMcjs.toNoteData.call(void 0, tonic));
 }
 function spelledFromTonic(kind, tonic) {
-  const checked = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
-  const bass = _chunkXKSO2V5Icjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
-  return SPELLED_ABOVE_BASS[checked].map((interval) => _chunkXKSO2V5Icjs.transposeByInterval.call(void 0, bass, interval));
+  const checked = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const bass = _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
+  return SPELLED_ABOVE_BASS[checked].map((interval) => _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, bass, interval));
 }
 function augmentedSixthFromSymbol(symbol, key) {
   const kind = KIND_BY_SYMBOL.get(symbol);
@@ -724,11 +737,11 @@ var SUBDOMINANT_DEGREE = 4;
 var DOMINANT_DEGREE = 5;
 var SUBMEDIANT_DEGREE = 6;
 function degreeOffset(degreeNumber, key) {
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
 }
 function thirdBelongsToKey(chord, key) {
   return chord.intervals.some(
-    (interval) => (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, interval) === 3 || _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, interval) === 4) && _chunkYPB3A3EYcjs.isScaleTone.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc + interval), key)
+    (interval) => (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 3 || _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 4) && _chunk3R3QVKY5cjs.isScaleTone.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + interval), key)
   );
 }
 function deceptiveTargets(key) {
@@ -740,25 +753,25 @@ function deceptiveTargets(key) {
   return borrowed === submediant ? [submediant] : [submediant, borrowed];
 }
 function restsOnDominant(to, key) {
-  if (_chunkYPB3A3EYcjs.hasMajorThird.call(void 0, to) || _chunkYPB3A3EYcjs.isDominantChordOf.call(void 0, to, key)) {
+  if (_chunk3R3QVKY5cjs.hasMajorThird.call(void 0, to) || _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, to, key)) {
     return true;
   }
-  if (_chunkYPB3A3EYcjs.scaleSystemOf.call(void 0, key) !== "modal") {
+  if (_chunk3R3QVKY5cjs.scaleSystemOf.call(void 0, key) !== "modal") {
     return false;
   }
-  const dominantPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc + degreeOffset(DOMINANT_DEGREE, key));
-  const leadingToneDominant = _chunkYPB3A3EYcjs.isScaleTone.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, dominantPc + 4), key);
+  const dominantPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + degreeOffset(DOMINANT_DEGREE, key));
+  const leadingToneDominant = _chunk3R3QVKY5cjs.isScaleTone.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, dominantPc + 4), key);
   return !leadingToneDominant && thirdBelongsToKey(to, key);
 }
 function isTonicSixFour(chord, key) {
-  if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) !== 0 || chord.bassPc === void 0) {
+  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) !== 0 || chord.bassPc === void 0) {
     return false;
   }
-  const isTriad = chord.intervals.length === 3 && chord.intervals.some((interval) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, interval) === 7);
-  return isTriad && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
+  const isTriad = chord.intervals.length === 3 && chord.intervals.some((interval) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 7);
+  return isTriad && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
 }
 function isCadentialSixFour(chord, next, key) {
-  return isTonicSixFour(chord, key) && _chunkYPB3A3EYcjs.isDominantChordOf.call(void 0, next, key) && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(next.bassPc, () => ( next.rootPc)));
+  return isTonicSixFour(chord, key) && _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, next, key) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(next.bassPc, () => ( next.rootPc)));
 }
 function outerPitches(voicing) {
   let bass;
@@ -777,20 +790,28 @@ function outerPitches(voicing) {
   return { bass, soprano };
 }
 function bassPcOf2(chord, voicedBass) {
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(voicedBass, () => ( chord.bassPc)), () => ( chord.rootPc)));
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(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 = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc);
-  const fromOffset = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, from.rootPc - tonic);
-  const toOffset = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, to.rootPc - tonic);
-  const dominant = _chunkYPB3A3EYcjs.isDominantChordOf.call(void 0, from, key);
-  if ((dominant || _chunkYPB3A3EYcjs.isLeadingToneChordOf.call(void 0, from, key)) && toOffset === 0) {
+  const tonic = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  const fromOffset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc - tonic);
+  const toOffset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - tonic);
+  const dominant = _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, from, key);
+  if ((dominant || _chunk3R3QVKY5cjs.isLeadingToneChordOf.call(void 0, from, key)) && toOffset === 0) {
     return "authentic";
   }
   if (fromOffset === degreeOffset(SUBDOMINANT_DEGREE, key) && toOffset === 0) {
     return "plagal";
   }
-  if (fromOffset === 10 && toOffset === 0 && _chunkYPB3A3EYcjs.hasMajorThird.call(void 0, from)) {
+  if (fromOffset === 10 && toOffset === 0 && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, from)) {
     return "modal";
   }
   if (dominant && deceptiveTargets(key).includes(toOffset)) {
@@ -798,7 +819,7 @@ function cadenceType(from, to, key, fromBassPc, toBassPc) {
   }
   const dominantOffset = degreeOffset(DOMINANT_DEGREE, key);
   const half = toOffset === dominantOffset && restsOnDominant(to, key) && fromOffset !== dominantOffset;
-  if (half && isMinorScale(key) && fromOffset === 5 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, toBassPc - tonic) === 7) {
+  if (half && isMinorScale(key) && fromOffset === 5 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, toBassPc - tonic) === 7) {
     return "phrygian";
   }
   return half ? "half" : null;
@@ -900,12 +921,12 @@ function cadenceAlternatives(facts) {
   return out;
 }
 function detectCadence(from, to, key, opts = {}) {
-  const { approach, ...rest } = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const { approach, ...rest } = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
   return cadenceBetween(
-    _chunkYPB3A3EYcjs.toChordData.call(void 0, from),
-    _chunkYPB3A3EYcjs.toChordData.call(void 0, to),
-    _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key),
-    approach === void 0 ? rest : { ...rest, approach: _chunkYPB3A3EYcjs.toChordData.call(void 0, approach) }
+    _chunk3R3QVKY5cjs.toChordData.call(void 0, from),
+    _chunk3R3QVKY5cjs.toChordData.call(void 0, to),
+    _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key),
+    approach === void 0 ? rest : { ...rest, approach: _chunk3R3QVKY5cjs.toChordData.call(void 0, approach) }
   );
 }
 function cadenceBetween(from, to, key, opts = {}) {
@@ -914,11 +935,11 @@ function cadenceBetween(from, to, key, opts = {}) {
   const toOuter = outerPitches(_nullishCoalesce(toVoicing, () => ( [])));
   const fromBassPc = bassPcOf2(from, fromOuter.bass);
   const toBassPc = bassPcOf2(to, toOuter.bass);
-  const toRootPosition = toBassPc === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, to.rootPc);
-  const rootPosition = fromBassPc === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, from.rootPc) && toRootPosition;
-  const soprano = toOuter.soprano === void 0 ? null : _chunkYPB3A3EYcjs.chordToneRole.call(void 0, toOuter.soprano, to);
+  const toRootPosition = toBassPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc);
+  const rootPosition = fromBassPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc) && toRootPosition;
+  const soprano = toOuter.soprano === void 0 ? null : _chunk3R3QVKY5cjs.chordToneRole.call(void 0, toOuter.soprano, to);
   const type = cadenceType(from, to, key, fromBassPc, toBassPc);
-  const leadingTone = _chunkYPB3A3EYcjs.isLeadingToneChordOf.call(void 0, from, key);
+  const leadingTone = _chunk3R3QVKY5cjs.isLeadingToneChordOf.call(void 0, from, key);
   const facts = {
     type,
     strength: type === "authentic" ? authenticStrength(leadingTone, rootPosition, toOuter.soprano !== void 0, soprano) : null,
@@ -927,10 +948,10 @@ function cadenceBetween(from, to, key, opts = {}) {
     // promised is the one it does not get.
     evaded: type === "authentic" && !toRootPosition,
     leadingTone,
-    fromOffset: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
-    toOffset: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
+    fromOffset: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
+    toOffset: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
     minor: isMinorScale(key),
-    onFifthDegree: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc) === degreeOffset(DOMINANT_DEGREE, key),
+    onFifthDegree: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc) === degreeOffset(DOMINANT_DEGREE, key),
     sixFour: opts.approach !== void 0 && isCadentialSixFour(opts.approach, from, key),
     withinSixFour: isCadentialSixFour(from, to, key)
   };
@@ -951,53 +972,53 @@ function cadenceBetween(from, to, key, opts = {}) {
 // src/analyze/functional/borrowed.ts
 function isMinorScaleAlteration(chord, key) {
   if (!isMinorScale(key)) return false;
-  const alteredKey = { rootPc: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYPB3A3EYcjs.HARMONIC_MINOR_MASK };
-  if (_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, alteredKey)) return true;
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && _chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, { rootPc: _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYPB3A3EYcjs.MELODIC_MINOR_MASK });
+  const alteredKey = { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.HARMONIC_MINOR_MASK };
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, alteredKey)) return true;
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.MELODIC_MINOR_MASK });
 }
 function isBorrowed(chord, key) {
-  if (_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
     return false;
   }
-  if (_chunkYPB3A3EYcjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return true;
   }
   if (isMinorScaleAlteration(chord, key)) {
     return false;
   }
-  return _chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, parallelScale(key));
+  return _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, parallelScale(key));
 }
 function borrowedSourceOf(chord, key) {
-  if (_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
     return null;
   }
-  if (_chunkYPB3A3EYcjs.isNeapolitanChordOf.call(void 0, chord, key)) return "neapolitan";
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) return "neapolitan";
   if (isBorrowed(chord, key)) {
     return isMinorScale(key) ? "parallelMajor" : "parallelMinor";
   }
   return null;
 }
 function isBorrowedChord(chord, key) {
-  return isBorrowed(_chunkYPB3A3EYcjs.toChordData.call(void 0, chord), _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key));
+  return isBorrowed(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
 }
 function borrowedSource(chord, key) {
-  return borrowedSourceOf(_chunkYPB3A3EYcjs.toChordData.call(void 0, chord), _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key));
+  return borrowedSourceOf(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
 }
 
 // src/analyze/functional/tonicization.ts
 function isTonicizableRoot(rootPc, key) {
-  return _chunkYPB3A3EYcjs.tonicizableDegrees.call(void 0, key).some((degree) => degree.rootPc === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc));
+  return _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key).some((degree) => degree.rootPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc));
 }
 function appliedTarget(chord, key) {
-  const dominant = _chunkYPB3A3EYcjs.hasDominantSonority.call(void 0, chord);
-  const leadingTone = _chunkYPB3A3EYcjs.LEADING_TONE_QUALITIES.has(chord.quality);
+  const dominant = _chunk3R3QVKY5cjs.hasDominantSonority.call(void 0, chord);
+  const leadingTone = _chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(chord.quality);
   if (!dominant && !leadingTone) {
     return null;
   }
-  return _chunkYPB3A3EYcjs.appliedDominantTarget.call(void 0, chord.rootPc + (dominant ? 5 : 1), key);
+  return _chunk3R3QVKY5cjs.appliedDominantTarget.call(void 0, chord.rootPc + (dominant ? 5 : 1), key);
 }
 function isAppliedDominant(chord, key) {
-  if (_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
     return false;
   }
   const source = borrowedSourceOf(chord, key);
@@ -1010,7 +1031,7 @@ function pointsAtTonicizableDegree(chord, key) {
   if (appliedTarget(chord, key) !== null) {
     return true;
   }
-  return _chunkYPB3A3EYcjs.soundsDominantSeventh.call(void 0, chord) && isTonicizableRoot(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - 1), key);
+  return _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord) && isTonicizableRoot(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - 1), key);
 }
 
 // src/analyze/functional/roman.ts
@@ -1125,33 +1146,33 @@ function parseInversion(figures) {
 function parseSimpleRoman(text, key) {
   const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
   if (!match) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
   }
   const glyphText = _nullishCoalesce(match[2], () => ( ""));
   if (glyphText !== glyphText.toUpperCase() && glyphText !== glyphText.toLowerCase()) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`Roman numeral must use one case: ${text}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Roman numeral must use one case: ${text}`);
   }
   const accidental = match[1] === "b" ? -1 : match[1] === "#" ? 1 : 0;
   const glyph = glyphText.toUpperCase();
   const degreeNumber = ROMAN_TO_DEGREE[glyph];
   if (degreeNumber === void 0) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
   }
   const isUpper = glyphText[0] === _optionalChain([glyphText, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.toUpperCase, 'call', _7 => _7()]);
   const suffix = _nullishCoalesce(match[3], () => ( ""));
   const frame = romanReference(key);
   const redundantFlat = accidental === -1 && loweredDegrees(frame).has(degreeNumber);
-  const diatonicRootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, 
+  const diatonicRootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 
     degreeRootPc(degreeNumber, frame) + (redundantFlat ? 0 : accidental)
   );
-  const rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && _chunkYPB3A3EYcjs.LEADING_TONE_QUALITIES.has(quality2) ? _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, diatonicRootPc + 1) : diatonicRootPc;
+  const rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && _chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(quality2) ? _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, diatonicRootPc + 1) : diatonicRootPc;
   const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
   if (canonical !== void 0) {
     return { rootPc: rootForQuality(canonical), quality: canonical, inversion: 0 };
   }
   const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
   if (!parsedSuffix) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
   }
   const qualityMarker = _nullishCoalesce(parsedSuffix[1], () => ( ""));
   const isDim = qualityMarker === "o" || qualityMarker === "\xB0" || qualityMarker === "dim";
@@ -1160,7 +1181,7 @@ function parseSimpleRoman(text, key) {
   const explicitMaj7 = parsedSuffix[2] !== void 0;
   const figures = _nullishCoalesce(parsedSuffix[3], () => ( ""));
   if (figures !== "" && !INVERSION_FIGURES.has(figures)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
       `Unsupported figured-bass or extension "${figures}" in Roman numeral: ${text}`
     );
   }
@@ -1191,22 +1212,22 @@ function parseSimpleRoman(text, key) {
 var NEAPOLITAN_SIXTH = "N6";
 function chromaticSymbolChord(text, key) {
   if (text === NEAPOLITAN_SIXTH) {
-    const rootPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.scale.rootPc + 1);
-    return _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, "maj", _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc + 4));
+    const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.scale.rootPc + 1);
+    return _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "maj", _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 4));
   }
   return augmentedSixthFromSymbol(text, key);
 }
 function tonicizedKey(targetRoot, key) {
-  return _chunkYPB3A3EYcjs.resolveKey.call(void 0, {
-    scale: _chunkYPB3A3EYcjs.majorKey.call(void 0, targetRoot),
-    tonic: _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, targetRoot, key.tonic, key.scale)
+  return _chunk3R3QVKY5cjs.resolveKey.call(void 0, {
+    scale: _chunk3R3QVKY5cjs.majorKey.call(void 0, targetRoot),
+    tonic: _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, targetRoot, key.tonic, key.scale)
   });
 }
 function augmentedSixthTarget(chord, key) {
-  if (_chunkYPB3A3EYcjs.chordToneSpellings.call(void 0, chord) === void 0) {
+  if (_chunk3R3QVKY5cjs.chordToneSpellings.call(void 0, chord) === void 0) {
     return null;
   }
-  for (const degree of _chunkYPB3A3EYcjs.tonicizableDegrees.call(void 0, key.scale)) {
+  for (const degree of _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key.scale)) {
     if (degree.degreeNumber === 1) {
       continue;
     }
@@ -1217,14 +1238,14 @@ function augmentedSixthTarget(chord, key) {
   return null;
 }
 function chordFromParsed(parsed) {
-  const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, parsed.rootPc, parsed.quality);
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, parsed.rootPc, parsed.quality);
   if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, parsed.rootPc + (_nullishCoalesce(chord.intervals[parsed.inversion], () => ( 0))));
+    chord.bassPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, parsed.rootPc + (_nullishCoalesce(chord.intervals[parsed.inversion], () => ( 0))));
   }
   return chord;
 }
 function romanToChord(text, key) {
-  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
   const scale = resolved.scale;
   const trimmed = text.trim().replace(/(\d)\/(?=\d)/g, "$1");
   const slash = trimmed.indexOf("/");
@@ -1241,14 +1262,14 @@ function romanStyle(quality) {
   return ROMAN_STYLE[quality];
 }
 function romanSpelling(rootPc, key) {
-  const tones = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
-  const diatonic = tones.indexOf(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc));
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
+  const diatonic = tones.indexOf(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc));
   if (diatonic >= 0) {
     return { degreeNumber: diatonic + 1, accidental: "" };
   }
   const lowered = loweredDegrees(romanReference(key));
   for (let i = 0; i < tones.length; i += 1) {
-    if (lowered.has(i + 1) && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc)) {
+    if (lowered.has(i + 1) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
@@ -1257,20 +1278,20 @@ function romanSpelling(rootPc, key) {
     if (degreeNumber2 === 1 || degreeNumber2 === 5) {
       continue;
     }
-    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc)) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: degreeNumber2, accidental: "b" };
     }
   }
   for (let i = 0; i < tones.length; i += 1) {
-    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc)) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
-  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
+  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
   return { degreeNumber, accidental };
 }
 function seventhDegreeAccidental(accidental, degreeNumber, quality, key) {
-  if (degreeNumber !== 7 || !_chunkYPB3A3EYcjs.LEADING_TONE_QUALITIES.has(quality) || !loweredDegrees(romanReference(key)).has(7)) {
+  if (degreeNumber !== 7 || !_chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(quality) || !loweredDegrees(romanReference(key)).has(7)) {
     return accidental;
   }
   if (accidental === "#") {
@@ -1312,22 +1333,22 @@ var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
 function numeralFor(degreeNumber, lower) {
   const glyph = ROMAN[degreeNumber - 1];
   if (glyph === void 0) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
   }
   return lower ? glyph.toLowerCase() : glyph;
 }
 function chordToRoman(chord, key, opts = {}) {
-  return renderRoman(_chunkYPB3A3EYcjs.toChordData.call(void 0, chord), key, _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts")).roman;
+  return renderRoman(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key, _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts")).roman;
 }
 function renderRoman(chord, keyLike, opts) {
-  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
   const key = resolved.scale;
   const augmented = augmentedSixthSymbol(chord, resolved);
   if (augmented !== null) {
     return { roman: augmented, derivation: { kind: "augmentedSixth" } };
   }
   if (opts.applied === true) {
-    const target = _nullishCoalesce(augmentedSixthTarget(chord, resolved), () => ( (_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key) ? null : appliedTarget(chord, key))));
+    const target = _nullishCoalesce(augmentedSixthTarget(chord, resolved), () => ( (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, 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);
@@ -1344,14 +1365,14 @@ function renderRoman(chord, keyLike, opts) {
   let inversion = 0;
   let bass = "root";
   if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc + iv) === chord.bassPc);
+    const idx = chord.intervals.findIndex((iv) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === chord.bassPc);
     if (idx > 0) {
       inversion = idx;
     } else if (idx < 0) {
       bass = "foreign";
     }
   }
-  if (opts.neapolitan === true && inversion === 1 && _chunkYPB3A3EYcjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+  if (opts.neapolitan === true && inversion === 1 && _chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return { roman: NEAPOLITAN_SIXTH, derivation: { kind: "neapolitan" } };
   }
   if (inversion > 0) {
@@ -1450,8 +1471,8 @@ function romanAlternatives(chord, key, opts) {
   return out;
 }
 function explainRoman(chord, key, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
   const { roman, derivation } = renderRoman(data, key, asked);
   return {
     roman,
@@ -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
@@ -1519,18 +1541,18 @@ var MINOR_FUNCTION_BY_OFFSET = [
   // 11 viio
 ];
 function isMinorKey(key) {
-  return isMinorScale(_chunkYPB3A3EYcjs.toKeyScale.call(void 0, key));
+  return isMinorScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
 }
 function functionOf(chord, key) {
-  return functionWithReason(_chunkYPB3A3EYcjs.toChordData.call(void 0, chord), _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key)).function;
+  return functionWithReason(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key)).function;
 }
 function degreeFunction(chord, key) {
   const functions = isMinorScale(key) ? MINOR_FUNCTION_BY_OFFSET : FUNCTION_BY_OFFSET;
-  return _nullishCoalesce(functions[_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
+  return _nullishCoalesce(functions[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
 }
 function functionWithReason(chord, key) {
-  const offset = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
-  if (_chunkYPB3A3EYcjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+  const offset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
+  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return { function: "subdominant", reason: "neapolitan" };
   }
   if (augmentedSixthKindOf(chord, key) !== null) {
@@ -1539,7 +1561,7 @@ function functionWithReason(chord, key) {
   if (isAppliedDominant(chord, key)) {
     return { function: "dominant", reason: "applied" };
   }
-  if (!isMinorScale(key) && !_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key) && _chunkYPB3A3EYcjs.hasMajorThird.call(void 0, chord) && (offset === 8 || offset === 10)) {
+  if (!isMinorScale(key) && !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key) && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, chord) && (offset === 8 || offset === 10)) {
     return { function: "subdominant", reason: "flatSideMajor" };
   }
   return { function: degreeFunction(chord, key), reason: "degree" };
@@ -1562,7 +1584,7 @@ function describeChord(fn, reason, roman, source) {
 function functionAlternatives(chord, key, reason, accepted) {
   const out = [];
   if (reason === "degree") {
-    if (pointsAtTonicizableDegree(chord, key) && _chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, key)) {
+    if (pointsAtTonicizableDegree(chord, key) && _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
       out.push({
         label: "applied dominant",
         reason: "The chord is diatonic to the key, so it keeps the function of its degree rather than tonicizing another"
@@ -1586,15 +1608,15 @@ function functionAlternatives(chord, key, reason, accepted) {
   return out;
 }
 function isDiatonic(chord, key) {
-  return _chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, _chunkYPB3A3EYcjs.toChordData.call(void 0, chord), _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key));
+  return _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, _chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
 }
 function parallelKey(key) {
-  return parallelScale(_chunkYPB3A3EYcjs.toKeyScale.call(void 0, key));
+  return parallelScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
 }
 function analyzeChord(chord, key, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const scale = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key);
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
   const source = borrowedSourceOf(data, scale);
   const { function: fn, reason } = functionWithReason(data, scale);
   const roman = renderRoman(data, scale, asked).roman;
@@ -1611,18 +1633,18 @@ function analyzeChord(chord, key, opts = {}) {
   };
 }
 function secondaryDominant(targetDegree, key) {
-  const scale = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key);
-  const degreeCount = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, scale).length;
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, targetDegree, "targetDegree", 1, degreeCount);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  const degreeCount = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, scale).length;
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, targetDegree, "targetDegree", 1, degreeCount);
   const targetRoot = degreeRootPc(targetDegree, scale);
-  return _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7");
+  return _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7");
 }
 function secondaryDominantOf(target) {
-  const data = _chunkYPB3A3EYcjs.toChordData.call(void 0, target);
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, data.rootPc, "target chord rootPc");
-  const dominant = _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, data.rootPc + 7), "dom7");
+  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, target);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, data.rootPc, "target chord rootPc");
+  const dominant = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, data.rootPc + 7), "dom7");
   if (data.rootSpelling !== void 0) {
-    const moved = _chunkXKSO2V5Icjs.transposeNote.call(void 0, data.rootSpelling, 7);
+    const moved = _chunkS5BKZZGMcjs.transposeNote.call(void 0, data.rootSpelling, 7);
     dominant.rootSpelling = { letter: moved.letter, alter: moved.alter };
   }
   return dominant;
@@ -1631,17 +1653,17 @@ function secondaryDominantOf(target) {
 // src/analyze/functional/pivot.ts
 var HEPTATONIC_DEGREES = 7;
 function pivotChords(from, to) {
-  return pivotsBetween(_chunkYPB3A3EYcjs.toKeyScale.call(void 0, from), _chunkYPB3A3EYcjs.toKeyScale.call(void 0, to));
+  return pivotsBetween(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, from), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, to));
 }
 function pivotsBetween(from, to) {
-  if (_chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, from).length !== HEPTATONIC_DEGREES) {
+  if (_chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, from).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 || !_chunkYPB3A3EYcjs.isDiatonicChord.call(void 0, chord, to)) {
+    if (chord === null || !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, to)) {
       continue;
     }
     const identity = `${chord.rootPc}:${chord.quality}`;
@@ -1659,9 +1681,9 @@ function pivotsBetween(from, to) {
 }
 function stackedTriad(degree, key) {
   try {
-    return _chunkYPB3A3EYcjs.diatonicTriad.call(void 0, degree, key);
+    return _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key);
   } catch (error) {
-    if (error instanceof _chunkXKSO2V5Icjs.InvalidInputError) {
+    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
       return null;
     }
     throw error;
@@ -1669,6 +1691,16 @@ function stackedTriad(degree, key) {
 }
 
 // src/analyze/form/internal.ts
+function barSpanOf(startBeat, endBeat, meter) {
+  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, startBeat, meter);
+  const lastBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, endBeat, meter);
+  const partOf = (beat, bar) => {
+    const barStart = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
+    const barLength = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 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));
 }
@@ -1683,34 +1715,34 @@ function firstSoundingBeat(notes, fallback = 0) {
   return Number.isFinite(first) ? first : fallback;
 }
 function lastBarOf(meter, spanStart, spanEnd) {
-  const firstBar = _chunkXKSO2V5Icjs.barIndexAt.call(void 0, spanStart, meter);
-  const bar = _chunkXKSO2V5Icjs.barIndexAt.call(void 0, Math.max(spanStart, spanEnd), meter);
-  if (bar > firstBar && _chunkXKSO2V5Icjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter) >= spanEnd - _chunkXKSO2V5Icjs.BEAT_EPS) {
+  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, spanStart, meter);
+  const bar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, Math.max(spanStart, spanEnd), meter);
+  if (bar > firstBar && _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter) >= spanEnd - _chunkS5BKZZGMcjs.BEAT_EPS) {
     return bar - 1;
   }
   return bar;
 }
 function sliceBars(notes, meter, spanStart, spanEnd, budget) {
-  const firstBar = _chunkXKSO2V5Icjs.barIndexAt.call(void 0, spanStart, meter);
+  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, spanStart, meter);
   const lastBar = lastBarOf(meter, spanStart, spanEnd);
   const barCount = lastBar - firstBar + 1;
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, barCount, "form bars", budget);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, barCount, "form bars", budget);
   const buckets = Array.from({ length: barCount }, () => []);
   let memberships = 0;
   for (const note of notes) {
     const noteEnd = note.startBeat + note.durationBeat;
-    const from = Math.max(firstBar, _chunkXKSO2V5Icjs.barIndexAt.call(void 0, note.startBeat, meter));
-    const to = Math.min(lastBar, _chunkXKSO2V5Icjs.barIndexAt.call(void 0, Math.max(note.startBeat, noteEnd - _chunkXKSO2V5Icjs.BEAT_EPS), meter));
+    const from = Math.max(firstBar, _chunkS5BKZZGMcjs.barIndexAt.call(void 0, note.startBeat, meter));
+    const to = Math.min(lastBar, _chunkS5BKZZGMcjs.barIndexAt.call(void 0, Math.max(note.startBeat, noteEnd - _chunkS5BKZZGMcjs.BEAT_EPS), meter));
     memberships += Math.max(0, to - from + 1);
-    _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, memberships, "form note-to-bar memberships", budget);
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, "form note-to-bar memberships", budget);
     for (let bar = from; bar <= to; bar += 1) {
       _optionalChain([buckets, 'access', _8 => _8[bar - firstBar], 'optionalAccess', _9 => _9.push, 'call', _10 => _10(note)]);
     }
   }
   const slices = [];
   for (let bar = firstBar; bar <= lastBar; bar += 1) {
-    const startBeat = _chunkXKSO2V5Icjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
-    const endBeat = _chunkXKSO2V5Icjs.barPositionToBeat.call(void 0, { bar: bar + 1, beat: 0 }, meter);
+    const startBeat = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
+    const endBeat = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar: bar + 1, beat: 0 }, meter);
     const barNotes = _nullishCoalesce(buckets[bar - firstBar], () => ( []));
     const { weights, totalWeight } = windowWeights(barNotes, startBeat, endBeat, meter);
     slices.push({ index: bar, startBeat, endBeat, notes: barNotes, weights, totalWeight });
@@ -1728,10 +1760,10 @@ function weightSimilarity(a, b) {
     normA += x * x;
     normB += y * y;
   }
-  if (normA <= _chunkXKSO2V5Icjs.BEAT_EPS && normB <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS && normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
     return 1;
   }
-  if (normA <= _chunkXKSO2V5Icjs.BEAT_EPS || normB <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS || normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
     return 0;
   }
   return clamp01(dot / Math.sqrt(normA * normB));
@@ -1758,13 +1790,13 @@ function combineEvidence(strengths) {
 // src/analyze/grid.ts
 function gridOriginOf(firstOnset, slotBeats) {
   const startBeat = firstOnset < 0 && firstOnset > -HUMANIZE_ADJACENCY ? 0 : firstOnset;
-  return { origin: Math.floor(startBeat / slotBeats + _chunkXKSO2V5Icjs.BEAT_EPS) * slotBeats, startBeat };
+  return { origin: Math.floor(startBeat / slotBeats + _chunkS5BKZZGMcjs.BEAT_EPS) * slotBeats, startBeat };
 }
 function gridForNotes(notes, slotBeats) {
   return gridOriginOf(firstSoundingBeat(notes), slotBeats);
 }
 function barGridStart(firstOnset, meter) {
-  return gridOriginOf(firstOnset, _chunkXKSO2V5Icjs.beatsPerBarAt.call(void 0, firstOnset, meter)).startBeat;
+  return gridOriginOf(firstOnset, _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, firstOnset, meter)).startBeat;
 }
 
 // src/analyze/keys/index.ts
@@ -1784,13 +1816,13 @@ var FIFTHS_DISTANCE_COST = 0.18;
 var KEY_CANDIDATES = (() => {
   const candidates = [];
   for (let rootPc = 0; rootPc < 12; rootPc += 1) {
-    candidates.push({ key: _chunkYPB3A3EYcjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
-    candidates.push({ key: _chunkYPB3A3EYcjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
+    candidates.push({ key: _chunk3R3QVKY5cjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
+    candidates.push({ key: _chunk3R3QVKY5cjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
   }
   return candidates;
 })();
 function fifthsOf(rootPc, minor) {
-  const majorRoot = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
+  const majorRoot = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
   const raw = majorRoot * 7 % 12;
   return raw > 6 ? raw - 12 : raw;
 }
@@ -1808,9 +1840,9 @@ function chooseKeys(slots, changeCost, meter, budget) {
   if (slots.length === 0) {
     return [];
   }
-  const back = _chunkXKSO2V5Icjs.allocateChoiceTable.call(void 0, slots.length, count, "key search choices", budget);
-  let costs = _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
-  let spare = _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
+  const back = _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slots.length, count, "key search choices", budget);
+  let costs = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
+  let spare = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
   const opening = _nullishCoalesce(_optionalChain([slots, 'access', _11 => _11[0], 'optionalAccess', _12 => _12.scores]), () => ( []));
   for (let c = 0; c < count; c += 1) {
     costs[c] = -(_nullishCoalesce(opening[c], () => ( 0)));
@@ -1819,7 +1851,7 @@ function chooseKeys(slots, changeCost, meter, budget) {
     const slot = slots[i];
     const previous = costs;
     const next = spare;
-    const accent = _chunkXKSO2V5Icjs.metricWeight.call(void 0, _nullishCoalesce(_optionalChain([slot, 'optionalAccess', _13 => _13.startBeat]), () => ( 0)), meter);
+    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, _nullishCoalesce(_optionalChain([slot, 'optionalAccess', _13 => _13.startBeat]), () => ( 0)), meter);
     const metricFactor = 1 - STRONG_BEAT_DISCOUNT * accent / MAX_METRIC_WEIGHT;
     const rowBase = i * count;
     for (let to = 0; to < count; to += 1) {
@@ -1889,7 +1921,7 @@ function enforceMinimumRegion(slots, path, minBeats, budget) {
     return chosen;
   }
   const candidates = KEY_CANDIDATES.length;
-  const totals = _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, slots.length, candidates, "key region scores", budget);
+  const totals = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, slots.length, candidates, "key region scores", budget);
   for (let i = 0; i < slots.length; i += 1) {
     const scores = _nullishCoalesce(_optionalChain([slots, 'access', _18 => _18[i], 'optionalAccess', _19 => _19.scores]), () => ( []));
     const base = i * candidates;
@@ -1920,13 +1952,13 @@ function enforceMinimumRegion(slots, path, minBeats, budget) {
       return chosen;
     }
     const length = region.endBeat - region.startBeat;
-    if (region.merged || length >= minBeats - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (region.merged || length >= minBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
     const previous = region.previous;
     const next = region.next;
-    const before = previous !== void 0 && Math.abs(previous.endBeat - region.startBeat) < _chunkXKSO2V5Icjs.BEAT_EPS ? previous : void 0;
-    const after = next !== void 0 && Math.abs(next.startBeat - region.endBeat) < _chunkXKSO2V5Icjs.BEAT_EPS ? next : void 0;
+    const before = previous !== void 0 && Math.abs(previous.endBeat - region.startBeat) < _chunkS5BKZZGMcjs.BEAT_EPS ? previous : void 0;
+    const after = next !== void 0 && Math.abs(next.startBeat - region.endBeat) < _chunkS5BKZZGMcjs.BEAT_EPS ? next : void 0;
     if (before === void 0 && after === void 0) {
       continue;
     }
@@ -2036,7 +2068,7 @@ function withRelations(regions) {
     if (previous === void 0 || current === void 0) {
       continue;
     }
-    const relation = _chunkYPB3A3EYcjs.keyRelationBetween.call(void 0, previous.key, current.key);
+    const relation = _chunk3R3QVKY5cjs.keyRelationBetween.call(void 0, previous.key, current.key);
     if (relation !== null && relation !== "same") {
       current.modulation = relation;
     }
@@ -2044,22 +2076,22 @@ function withRelations(regions) {
   return regions;
 }
 function keyTimelineFromNotes(notes, opts = {}) {
-  const meters = _chunkXKSO2V5Icjs.resolveMeters.call(void 0, opts, "key timeline meters");
-  const bar = _chunkXKSO2V5Icjs.beatsPerBarAt.call(void 0, 0, meters);
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "key timeline meters");
+  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
   const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
   const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
   const budget = opts.budget;
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, notes, "key timeline notes", { allowNonPositiveDuration: true, budget });
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, 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 = _nullishCoalesce(opts.totalBeats, () => ( lastEnd));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, 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 - _chunkXKSO2V5Icjs.BEAT_EPS));
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, slotCount * KEY_CANDIDATES.length, "key timeline slots", budget);
+  const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slotCount * KEY_CANDIDATES.length, "key timeline slots", budget);
   if (slotCount === 0 || sounding.length === 0) {
     return [];
   }
@@ -2097,7 +2129,7 @@ function keyTimelineFromNotes(notes, opts = {}) {
       (candidate) => profileScore(weights, candidate.minor ? profile.minor : profile.major, candidate.rootPc) * totalWeight
     );
     slots.push({ startBeat, endBeat, scores, weight: totalWeight });
-    if (totalWeight > _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (totalWeight > _chunkS5BKZZGMcjs.BEAT_EPS) {
       weightSum += totalWeight;
       soundingSlots += 1;
     }
@@ -2111,14 +2143,14 @@ function keyTimelineFromNotes(notes, opts = {}) {
   const grouped = regionsFromPath(slots, path);
   const head = grouped[0];
   const next = grouped[1];
-  if (head !== void 0 && next !== void 0 && head.endBeat - Math.max(head.startBeat, musicStart) < slotBeats - _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (head !== void 0 && next !== void 0 && head.endBeat - Math.max(head.startBeat, musicStart) < slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
     next.startBeat = head.startBeat;
     next.from = head.from;
     grouped.shift();
   }
   const regions = grouped.map((region) => {
     const candidate = KEY_CANDIDATES[region.candidate];
-    const key = _chunkYPB3A3EYcjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _24 => _24.key]), () => ( _chunkYPB3A3EYcjs.majorKey.call(void 0, 0))));
+    const key = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _24 => _24.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
     const startBeat = Math.max(region.startBeat, musicStart);
     const weights = new Array(PITCH_CLASSES).fill(0);
     for (let i = region.from; i < region.toExclusive; i += 1) {
@@ -2138,7 +2170,7 @@ function keyTimelineFromNotes(notes, opts = {}) {
     return {
       startBeat,
       endBeat: region.endBeat,
-      key: _chunkYPB3A3EYcjs.resolveKey.call(void 0, key),
+      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, key),
       confidence: Math.max(0, correlation)
     };
   });
@@ -2150,20 +2182,20 @@ var TONIC_CREDIT = 0.4;
 var CADENCE_CREDIT = 0.6;
 var CHORD_MODULATION_COST = 0.6;
 function chordFitsKey(chord, candidate) {
-  const tones = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord);
+  const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
   if (tones.length === 0) {
     return 0;
   }
   let inKey = 0;
   for (const pc of tones) {
-    if (_chunkYPB3A3EYcjs.isScaleTone.call(void 0, pc, candidate.key)) {
+    if (_chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, candidate.key)) {
       inKey += 1;
     }
   }
   let score = CHORD_TONE_CREDIT * ((inKey - (tones.length - inKey)) / tones.length);
-  const rootDegree = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
+  const rootDegree = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
   if (rootDegree === 7) {
-    if (_chunkYPB3A3EYcjs.soundsDominantSeventh.call(void 0, chord)) {
+    if (_chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord)) {
       score += DOMINANT_CREDIT;
     } else if (chord.quality === "maj") {
       score += DOMINANT_CREDIT * 0.5;
@@ -2175,17 +2207,17 @@ function chordFitsKey(chord, candidate) {
   return score;
 }
 function detectModulations(chords, opts = {}) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, chords, "modulation chord segments");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "modulation chord segments");
   chords.forEach((segment, index) => {
-    _chunkXKSO2V5Icjs.assertRecord.call(void 0, segment, `modulation chord segments[${index}]`);
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, segment, `modulation chord segments[${index}]`);
   });
-  const meters = _chunkXKSO2V5Icjs.resolveMeters.call(void 0, opts, "modulation meters");
-  const bar = _chunkXKSO2V5Icjs.beatsPerBarAt.call(void 0, 0, meters);
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "modulation meters");
+  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
   const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
   const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, 
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
     chords.length * KEY_CANDIDATES.length,
     "modulation chord segments",
     opts.budget
@@ -2193,7 +2225,7 @@ function detectModulations(chords, opts = {}) {
   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 totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastChordEnd));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, 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 [];
@@ -2216,14 +2248,14 @@ function detectModulations(chords, opts = {}) {
     if (arriving === void 0 || approaching === void 0 || slot === void 0) {
       continue;
     }
-    const isDominantMotion = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && _chunkYPB3A3EYcjs.soundsDominantSeventh.call(void 0, approaching);
+    const isDominantMotion = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, approaching);
     if (!isDominantMotion) {
       continue;
     }
     const length = slot.endBeat - slot.startBeat;
     for (let c = 0; c < KEY_CANDIDATES.length; c += 1) {
       const candidate = KEY_CANDIDATES[c];
-      if (candidate !== void 0 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
+      if (candidate !== void 0 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
         slot.scores[c] = (_nullishCoalesce(slot.scores[c], () => ( 0))) + CADENCE_CREDIT * length;
       }
     }
@@ -2237,7 +2269,7 @@ function detectModulations(chords, opts = {}) {
   const profile = resolveKeyProfile(opts.profile);
   const regions = grouped.map((region) => {
     const candidate = KEY_CANDIDATES[region.candidate];
-    const key = _chunkYPB3A3EYcjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _31 => _31.key]), () => ( _chunkYPB3A3EYcjs.majorKey.call(void 0, 0))));
+    const key = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _31 => _31.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
     const weights = new Array(PITCH_CLASSES).fill(0);
     for (let i = region.from; i < region.toExclusive; i += 1) {
       const segment = ordered[i];
@@ -2245,10 +2277,10 @@ function detectModulations(chords, opts = {}) {
         continue;
       }
       const overlap = segment.endBeat - segment.startBeat;
-      if (overlap <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+      if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
         continue;
       }
-      for (const pc of _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, segment.chord)) {
+      for (const pc of _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, segment.chord)) {
         weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + overlap;
       }
     }
@@ -2273,7 +2305,7 @@ function detectModulations(chords, opts = {}) {
 var THIRD_SEMITONES = [3, 4];
 var FIFTH_SEMITONES = [6, 7, 8];
 function triadCore(chord) {
-  const root = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc);
+  const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc);
   let third;
   let fifth;
   for (const interval of chord.intervals) {
@@ -2289,7 +2321,7 @@ function triadCore(chord) {
   if (third === void 0 || fifth === void 0) {
     return null;
   }
-  return [root, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, root + third), _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, root + fifth)].sort((a, b) => a - b);
+  return [root, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + third), _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + fifth)].sort((a, b) => a - b);
 }
 function lastChordFinishedBy(chords) {
   const byEnd = chords.map((_, index) => index).sort((a, b) => (_nullishCoalesce(_optionalChain([chords, 'access', _34 => _34[a], 'optionalAccess', _35 => _35.endBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([chords, 'access', _36 => _36[b], 'optionalAccess', _37 => _37.endBeat]), () => ( 0))));
@@ -2327,7 +2359,7 @@ function attachPivots(regions, chords) {
     if (previous === void 0 || current === void 0) {
       continue;
     }
-    const last = finished(current.startBeat + _chunkXKSO2V5Icjs.BEAT_EPS);
+    const last = finished(current.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS);
     if (last === void 0) {
       continue;
     }
@@ -2335,9 +2367,9 @@ function attachPivots(regions, chords) {
     if (core === null) {
       continue;
     }
-    const root = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, last.chord.rootPc);
+    const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, last.chord.rootPc);
     const pivot = pivotChords(previous.key, current.key).find(
-      (entry) => entry.chord.rootPc === root && sameTones(_chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, entry.chord), core)
+      (entry) => entry.chord.rootPc === root && sameTones(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, entry.chord), core)
     );
     if (pivot !== void 0) {
       current.pivot = pivot;
@@ -2362,12 +2394,12 @@ function keyLookup(regions, fallback) {
   };
 }
 function prevailingKeyOf(regions) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, regions, "key regions");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, regions, "key regions");
   const totals = /* @__PURE__ */ new Map();
   for (const [index, given] of regions.entries()) {
-    const region = _chunkXKSO2V5Icjs.assertRecord.call(void 0, given, `key regions[${index}]`);
-    _chunkXKSO2V5Icjs.assertRecord.call(void 0, region.key, `key regions[${index}].key`);
-    const id = `${_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, region.key.scale.rootPc)}:${region.key.scale.modeMask12}`;
+    const region = _chunkS5BKZZGMcjs.assertRecord.call(void 0, given, `key regions[${index}]`);
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, region.key, `key regions[${index}].key`);
+    const id = `${_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, region.key.scale.rootPc)}:${region.key.scale.modeMask12}`;
     const entry = totals.get(id);
     const length = Math.max(0, region.endBeat - region.startBeat);
     if (entry === void 0) {
@@ -2392,11 +2424,11 @@ function keyScaleAt(key) {
   if (typeof key === "function") {
     return key;
   }
-  const scale = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
   return () => scale;
 }
 function toVoiceNotes(events) {
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, events, "voice notes", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "voice notes", { allowNonPositiveDuration: true });
   return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
 }
 function intervalAboveBass(pitch, others, chord) {
@@ -2408,7 +2440,7 @@ function intervalAboveBass(pitch, others, chord) {
     return ((pitch - bass) % 12 + 12) % 12;
   }
   const ref = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
-  return ((_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch) - _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
+  return ((_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
 }
 var TENSION_DEGREE_BY_INTERVAL = {
   1: 9,
@@ -2427,7 +2459,7 @@ function asSounded(chord) {
   if (chord.bassPc === void 0) {
     return chord;
   }
-  return { ...chord, intervals: [...chord.intervals, _chunkYPB3A3EYcjs.intervalAboveRoot.call(void 0, chord.bassPc, chord)] };
+  return { ...chord, intervals: [...chord.intervals, _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, chord.bassPc, chord)] };
 }
 function isStep(a, b) {
   const d = Math.abs(a - b);
@@ -2456,19 +2488,19 @@ var STEP_RESOLUTION = 2;
 var NEAREST_CHORD_TONE_REACH = 12;
 function nearestChordTone(pitch, chord, maxDistance) {
   for (let delta = 1; delta <= maxDistance; delta += 1) {
-    if (_chunkYPB3A3EYcjs.isChordMember.call(void 0, pitch - delta, chord)) {
+    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch - delta, chord)) {
       return pitch - delta;
     }
-    if (_chunkYPB3A3EYcjs.isChordMember.call(void 0, pitch + delta, chord)) {
+    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch + delta, chord)) {
       return pitch + delta;
     }
   }
   return void 0;
 }
 function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
-  _chunkXKSO2V5Icjs.assertFunction.call(void 0, chordAtBeat2, "chordAtBeat");
-  _chunkXKSO2V5Icjs.assertFunction.call(void 0, otherVoicesAtBeat, "otherVoicesAtBeat");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, chordAtBeat2, "chordAtBeat");
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, otherVoicesAtBeat, "otherVoicesAtBeat");
   const keyAt = keyScaleAt(key);
   const result = [];
   for (let i = 0; i < voice.length; i += 1) {
@@ -2484,11 +2516,11 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
     const next = nextNote !== void 0 && adjacent(noteEnd, nextNote.startBeat) ? nextNote : void 0;
     const chord = chordAtBeat2(note.startBeat);
     const labels = [];
-    const member = _chunkYPB3A3EYcjs.isChordMember.call(void 0, note.pitch, chord);
+    const member = _chunk3R3QVKY5cjs.isChordMember.call(void 0, note.pitch, chord);
     let handled = false;
     if (chord && member) {
-      const role = _chunkYPB3A3EYcjs.chordToneRole.call(void 0, note.pitch, chord);
-      const degree = role === null ? tensionDegree(_chunkYPB3A3EYcjs.intervalAboveRoot.call(void 0, note.pitch, chord)) : void 0;
+      const role = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, note.pitch, chord);
+      const degree = role === null ? tensionDegree(_chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, note.pitch, chord)) : void 0;
       if (role) {
         labels.push({ kind: "chordTone", role });
         handled = true;
@@ -2496,7 +2528,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         labels.push({ kind: "tension", degree });
         handled = true;
       } else {
-        const bassRole = _chunkYPB3A3EYcjs.chordToneRole.call(void 0, note.pitch, asSounded(chord));
+        const bassRole = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, note.pitch, asSounded(chord));
         if (bassRole !== null) {
           labels.push({ kind: "chordTone", role: bassRole });
           handled = true;
@@ -2505,11 +2537,11 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
     }
     if (!handled && chord && prev && next) {
       const prevChord = chordAtBeat2(prev.startBeat);
-      const prepared = prev.pitch === note.pitch && _chunkYPB3A3EYcjs.isChordMember.call(void 0, prev.pitch, prevChord);
+      const prepared = prev.pitch === note.pitch && _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, prevChord);
       const resolves = isStep(next.pitch, note.pitch);
       const others = otherVoicesAtBeat(note.startBeat);
       const verticallyDissonant = others.some(
-        (ov) => _chunkYPB3A3EYcjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
+        (ov) => _chunk3R3QVKY5cjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
       );
       if (prepared && verticallyDissonant && resolves) {
         const ic = intervalAboveBass(note.pitch, others, chord);
@@ -2521,8 +2553,8 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && prev && next) {
-      const prevMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
-      const nextMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
       const up = note.pitch - prev.pitch > 0;
       const contInto = next.pitch - note.pitch > 0;
       const sameDir = note.pitch !== prev.pitch && next.pitch !== note.pitch && up === contInto;
@@ -2531,20 +2563,20 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         handled = true;
       }
     }
-    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunkYPB3A3EYcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
+    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
       labels.push({ kind: "neighbor" });
       handled = true;
     }
     if (!handled && chord && next && !member && note.pitch === next.pitch) {
       const nextChord = chordAtBeat2(next.startBeat);
-      if (_chunkYPB3A3EYcjs.isChordMember.call(void 0, next.pitch, nextChord)) {
+      if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
         labels.push({ kind: "anticipation" });
         handled = true;
       }
     }
     if (!handled && chord && prev && next && !member) {
-      const prevMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
-      const nextMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
       const leapFromPrev = Math.abs(note.pitch - prev.pitch) >= LEAP_SEMITONES;
       const stepToNext = isStep(next.pitch, note.pitch);
       const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;
@@ -2554,8 +2586,8 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && prev && next && !member) {
-      const prevMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
-      const nextMember = _chunkYPB3A3EYcjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
+      const prevMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, chordAtBeat2(next.startBeat));
       const stepFromPrev = isStep(note.pitch, prev.pitch);
       const leapToNext = Math.abs(next.pitch - note.pitch) >= LEAP_SEMITONES;
       const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;
@@ -2565,7 +2597,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && !member) {
-      const ic = _chunkYPB3A3EYcjs.intervalAboveRoot.call(void 0, note.pitch, chord);
+      const ic = _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, note.pitch, chord);
       const degree = tensionDegree(ic);
       const colours = NATURAL_TENSION_INTERVALS.has(ic) || chord.intervals.some((i2) => i2 === 10 || i2 === 11);
       const avoid = ic === 5 && chord.intervals.includes(4) && !chord.intervals.includes(5) || ic === 11 && chord.intervals.includes(4) && chord.intervals.includes(10);
@@ -2584,7 +2616,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         );
       }
     }
-    if (next && _chunkYPB3A3EYcjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
+    if (next && _chunk3R3QVKY5cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
       labels.push({ kind: "leadingTone", resolveTo: next.pitch });
     }
     const analyzed = {
@@ -2635,22 +2667,22 @@ function describe(labels) {
 
 // src/analyze/timeline/index.ts
 function assertChordTimeline(timeline, name = "timeline") {
-  const read = _chunkXKSO2V5Icjs.assertRecord.call(void 0, timeline, name);
-  _chunkXKSO2V5Icjs.assertFunction.call(void 0, read.at, `${name}.at`);
-  const segments = _chunkXKSO2V5Icjs.assertArray.call(void 0, read.segments, `${name}.segments`);
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, timeline, name);
+  _chunkS5BKZZGMcjs.assertFunction.call(void 0, read.at, `${name}.at`);
+  const segments = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.segments, `${name}.segments`);
   for (let index = 0; index < segments.length; index += 1) {
-    const segment = _chunkXKSO2V5Icjs.assertRecord.call(void 0, segments[index], `${name}.segments[${index}]`);
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, segment.startBeat, `${name}.segments[${index}].startBeat`);
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, segment.endBeat, `${name}.segments[${index}].endBeat`);
+    const segment = _chunkS5BKZZGMcjs.assertRecord.call(void 0, segments[index], `${name}.segments[${index}]`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, segment.startBeat, `${name}.segments[${index}].startBeat`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, segment.endBeat, `${name}.segments[${index}].endBeat`);
   }
   return read;
 }
 function chordTimelineFromChords(chords, totalBeats) {
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, chords, "chords");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "chords");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
   for (let index = 0; index < chords.length; index += 1) {
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, 
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
       _nullishCoalesce(_optionalChain([chords, 'access', _42 => _42[index], 'optionalAccess', _43 => _43.startBeat]), () => ( Number.NaN)),
       -Number.MAX_SAFE_INTEGER,
       Number.MAX_SAFE_INTEGER,
@@ -2665,13 +2697,13 @@ function chordTimelineFromChords(chords, totalBeats) {
     return {
       startBeat: gc.startBeat,
       endBeat,
-      chord: _chunkYPB3A3EYcjs.chordFromSpan.call(void 0, gc)
+      chord: _chunk3R3QVKY5cjs.chordFromSpan.call(void 0, gc)
     };
   }).filter((seg) => seg.endBeat > seg.startBeat);
   return { at: segmentLookup(segments), segments };
 }
 function chordAtBeat(segments, beat) {
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
   const candidate = segments[firstAfter(segments, beat) - 1];
   return candidate !== void 0 && beat >= candidate.startBeat && beat < candidate.endBeat ? candidate.chord : null;
 }
@@ -2691,7 +2723,7 @@ function firstAfter(segments, beat) {
 function segmentStartingAt(segments, beat) {
   const index = firstAfter(segments, beat);
   for (const candidate of [segments[index - 1], segments[index]]) {
-    if (candidate !== void 0 && Math.abs(candidate.startBeat - beat) < _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (candidate !== void 0 && Math.abs(candidate.startBeat - beat) < _chunkS5BKZZGMcjs.BEAT_EPS) {
       return candidate;
     }
   }
@@ -2712,10 +2744,10 @@ var OCTAVE = 12;
 function scoreMatch(match, weights, maxWeight, key, pedalPc) {
   const rootWeight = maxWeight > 0 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
   const rootStanding = match.inversion === 0 ? Math.max(rootWeight, BASS_ROOT_STANDING) : rootWeight;
-  const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, match.rootPc, match.quality);
+  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, match.rootPc, match.quality);
   const account = matchAccount(match, chord, pedalPc);
   let score = rootStanding;
-  if (_chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunkYPB3A3EYcjs.isScaleTone.call(void 0, pc, key))) {
+  if (_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, key))) {
     score += DIATONIC_BONUS;
   }
   if (account.exact) {
@@ -2730,7 +2762,7 @@ 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);
 }
 function namesAsExtension(chord, pc) {
-  return chord.intervals.some((iv) => iv >= OCTAVE && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc + iv) === pc);
+  return chord.intervals.some((iv) => iv >= OCTAVE && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === pc);
 }
 function matchAccount(match, chord, pedalPc) {
   const unvoiced = pedalPc !== null && namesAsExtension(chord, pedalPc) ? 1 : 0;
@@ -2746,10 +2778,10 @@ function bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) {
   let highestBass = Number.NEGATIVE_INFINITY;
   for (const note of notes) {
     const overlap = Math.min(note.startBeat + note.durationBeat, windowEnd) - Math.max(note.startBeat, windowStart);
-    if (overlap <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
-    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, note.pitch) === bassPc) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch) === bassPc) {
       highestBass = Math.max(highestBass, note.pitch);
     } else {
       upperFloor = Math.min(upperFloor, note.pitch);
@@ -2758,7 +2790,7 @@ function bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) {
   return highestBass <= upperFloor;
 }
 function chordConfidence(chord, weights, totalWeight, exact) {
-  const tones = new Set(_chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord));
+  const tones = new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord));
   let chordWeight = 0;
   for (let pc = 0; pc < 12; pc += 1) {
     if (tones.has(pc)) {
@@ -2776,12 +2808,12 @@ function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
     windowEnd,
     meters
   );
-  if (totalWeight <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (totalWeight <= _chunkS5BKZZGMcjs.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 = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, lowestPitch);
+  const bassPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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;
@@ -2789,17 +2821,17 @@ function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
   let bestMatch = null;
   let bestScore = Number.NEGATIVE_INFINITY;
   for (const match of matches) {
-    const score = scoreMatch(match, weights, maxWeight, _chunkYPB3A3EYcjs.scaleOf.call(void 0, key), pedalPc);
+    const score = scoreMatch(match, weights, maxWeight, _chunk3R3QVKY5cjs.scaleOf.call(void 0, key), pedalPc);
     if (score > bestScore) {
       bestScore = score;
       bestMatch = match;
     }
   }
   if (bestMatch) {
-    const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
+    const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
     const account = matchAccount(
       bestMatch,
-      _chunkYPB3A3EYcjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality),
+      _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality),
       pedalPc
     );
     const reading = {
@@ -2823,7 +2855,7 @@ function shared(chord) {
 }
 var DOMINANT_ABOVE_TONIC = 7;
 function resolvesOntoDominant(readings, index, key) {
-  const dominantPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc + DOMINANT_ABOVE_TONIC);
+  const dominantPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + DOMINANT_ABOVE_TONIC);
   const candidate = _optionalChain([readings, 'access', _46 => _46[index], 'optionalAccess', _47 => _47.chord]);
   for (let i = index + 1; i < readings.length; i += 1) {
     const next = readings[i];
@@ -2834,10 +2866,10 @@ function resolvesOntoDominant(readings, index, key) {
     if (candidate !== void 0 && sameChord(chord, candidate)) {
       continue;
     }
-    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== dominantPc) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== dominantPc) {
       return false;
     }
-    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc) === dominantPc) {
+    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc) === dominantPc) {
       return true;
     }
   }
@@ -2870,7 +2902,7 @@ var LEXICON_TONES = (() => {
     for (const quality of SEGMENTATION_QUALITIES) {
       LEXICON_ROOTS[candidate] = rootPc;
       LEXICON_TONE_START[candidate] = tones.length;
-      tones.push(..._chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, quality)));
+      tones.push(..._chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality)));
       candidate += 1;
     }
   }
@@ -2891,7 +2923,7 @@ function candidateScore(candidate, weights, totalWeight) {
   for (let index = first; index < last; index += 1) {
     const weight = _nullishCoalesce(weights[_nullishCoalesce(LEXICON_TONES[index], () => ( 0))], () => ( 0));
     covered += weight;
-    if (weight <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (weight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       missing += 1;
     }
   }
@@ -2907,16 +2939,16 @@ function slotOfBeat(grid, beat) {
 }
 function createBoundaryTables(slotCount, budget) {
   return {
-    scores: _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window scores", budget),
-    back: _chunkXKSO2V5Icjs.allocateChoiceTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window choices", budget),
-    costs: _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
-    spare: _chunkXKSO2V5Icjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
-    path: _chunkXKSO2V5Icjs.allocateChoiceTable.call(void 0, slotCount, 1, "timeline window path", budget)
+    scores: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window scores", budget),
+    back: _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window choices", budget),
+    costs: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    spare: _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    path: _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, slotCount, 1, "timeline window path", budget)
   };
 }
 function scoreSlot(tables, slot, index) {
   const base = index * LEXICON_SIZE;
-  if (slot.totalWeight <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (slot.totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
     tables.scores.fill(0, base, base + LEXICON_SIZE);
     return;
   }
@@ -2946,7 +2978,7 @@ function chooseBoundaries(tables, from, to, grid, meters, changeCost) {
       }
     }
     const slotStart = beatOfSlot(grid, from + i);
-    const accent = _chunkXKSO2V5Icjs.metricWeight.call(void 0, slotStart, meters);
+    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, slotStart, meters);
     const penalty = changeCost * (1 - STRONG_BEAT_DISCOUNT2 * accent / MAX_METRIC_WEIGHT2);
     const rowBase = (from + i) * LEXICON_SIZE;
     const change = cheapest + penalty;
@@ -2988,7 +3020,7 @@ function chooseBoundaries(tables, from, to, grid, meters, changeCost) {
 }
 function slotBeatsWithin(gridUnit, minChordBeats, harmonicRhythm) {
   const resolution = Math.min(minChordBeats, harmonicRhythm);
-  const divisions = Math.max(1, Math.ceil(gridUnit / resolution - _chunkXKSO2V5Icjs.BEAT_EPS));
+  const divisions = Math.max(1, Math.ceil(gridUnit / resolution - _chunkS5BKZZGMcjs.BEAT_EPS));
   return gridUnit / divisions;
 }
 function gridSpans(slotCount, grid) {
@@ -3004,7 +3036,7 @@ function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
   let weightSum = 0;
   for (let i = 0; i < slotCount; i += 1) {
     const weight = _nullishCoalesce(_optionalChain([slotWeights, 'access', _48 => _48[i], 'optionalAccess', _49 => _49.totalWeight]), () => ( 0));
-    if (weight > _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (weight > _chunkS5BKZZGMcjs.BEAT_EPS) {
       soundingSlots += 1;
       weightSum += weight;
     }
@@ -3014,7 +3046,7 @@ function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
   }
   const meanSlotWeight = weightSum / soundingSlots;
   const changeCost = CHANGE_COST * meanSlotWeight * (harmonicRhythm / slotBeats);
-  const silent = slotWeights.map((slot) => slot.totalWeight <= _chunkXKSO2V5Icjs.BEAT_EPS);
+  const silent = slotWeights.map((slot) => slot.totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS);
   const breaks = new Array(slotCount).fill(false);
   for (let i = 0; i < slotCount; ) {
     if (!silent[i]) {
@@ -3025,7 +3057,7 @@ function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
     while (end < slotCount && silent[end]) {
       end += 1;
     }
-    if ((end - i) * slotBeats >= harmonicRhythm - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if ((end - i) * slotBeats >= harmonicRhythm - _chunkS5BKZZGMcjs.BEAT_EPS) {
       for (let k = i; k < end; k += 1) {
         breaks[k] = true;
       }
@@ -3088,30 +3120,30 @@ function evidenceFits(previous, grid, slotCount, totalBeats, segmentation, harmo
   return previous.grid.origin === grid.origin && previous.grid.slotBeats === grid.slotBeats && previous.slotCount === slotCount && previous.totalBeats === totalBeats && previous.segmentation === segmentation && previous.harmonicRhythm === harmonicRhythm && previous.keyGiven === keyGiven;
 }
 function analyzeTimeline(notes, opts = {}, previous, dirty) {
-  const meters = _chunkXKSO2V5Icjs.resolveMeters.call(void 0, opts, "timeline meters");
-  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunkXKSO2V5Icjs.beatsPerBarAt.call(void 0, 0, meters)));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "timeline meters");
+  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters)));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
   const segmentation = _nullishCoalesce(opts.segmentation, () => ( "dynamic"));
-  const gridUnit = _chunkXKSO2V5Icjs.metricGridUnit.call(void 0, meters);
+  const gridUnit = _chunkS5BKZZGMcjs.metricGridUnit.call(void 0, meters);
   const minChordBeats = _nullishCoalesce(opts.minChordBeats, () => ( gridUnit));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
   const budget = opts.budget;
   const noteOptions = { allowNonPositiveDuration: true, budget };
   if (opts.pickupBeats !== void 0) {
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
     noteOptions.minStartBeat = -opts.pickupBeats;
   }
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, notes, "timeline notes", noteOptions);
-  const sounding = _chunkTT6PKMPRcjs.sortedNoteEvents.call(void 0, notes.filter((note) => note.durationBeat > 0));
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "timeline notes", noteOptions);
+  const sounding = _chunk35NBV2FTcjs.sortedNoteEvents.call(void 0, notes.filter((note) => note.durationBeat > 0));
   const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
   const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastNoteEnd));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, 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 };
-  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - _chunkXKSO2V5Icjs.BEAT_EPS));
+  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
   const dynamic = segmentation === "dynamic";
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, 
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
     dynamic ? slotCount * LEXICON_SIZE : slotCount,
     "timeline windows",
     budget
@@ -3120,13 +3152,13 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     {
       startBeat: musicStart,
       endBeat: totalBeats,
-      key: _chunkYPB3A3EYcjs.resolveKey.call(void 0, opts.key),
+      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, opts.key),
       confidence: 1
     }
   ] : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
-  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunkYPB3A3EYcjs.resolveKey.call(void 0, _chunkYPB3A3EYcjs.majorKey.call(void 0, 0))));
+  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunk3R3QVKY5cjs.resolveKey.call(void 0, _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
   const keyAt = keyLookup(keys, prevailingKey);
-  const scaleAt = (beat) => _chunkYPB3A3EYcjs.scaleOf.call(void 0, keyAt(beat));
+  const scaleAt = (beat) => _chunk3R3QVKY5cjs.scaleOf.call(void 0, keyAt(beat));
   const segments = [];
   const segmentConfidence = [];
   const slotNotes = bucketNotesBySlot(sounding, grid, slotCount, {
@@ -3200,7 +3232,7 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     }
     const { start, end } = bounds;
     const last = segments[segments.length - 1];
-    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < _chunkS5BKZZGMcjs.BEAT_EPS) {
       const lastLength = last.endBeat - last.startBeat;
       const length = end - start;
       const lastConfidence = _nullishCoalesce(segmentConfidence[segmentConfidence.length - 1], () => ( 0));
@@ -3241,11 +3273,11 @@ function detectCadences(timeline, key) {
     if (!prev || !cur) {
       continue;
     }
-    if (Math.abs(cur.startBeat - prev.endBeat) > _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (Math.abs(cur.startBeat - prev.endBeat) > _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
     const before = timeline.segments[i - 2];
-    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= _chunkXKSO2V5Icjs.BEAT_EPS ? before.chord : void 0;
+    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS ? before.chord : void 0;
     const key2 = keyAt(cur.startBeat);
     const cadence = detectCadence(prev.chord, cur.chord, key2, {
       ...approach === void 0 ? {} : { approach }
@@ -3255,7 +3287,7 @@ function detectCadences(timeline, key) {
     }
     if (cadence.type === "half" && isCadentialSixFour(prev.chord, cur.chord, key2)) {
       const next = timeline.segments[i + 1];
-      if (next !== void 0 && Math.abs(next.startBeat - cur.endBeat) <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+      if (next !== void 0 && Math.abs(next.startBeat - cur.endBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS) {
         const onward = detectCadence(cur.chord, next.chord, keyAt(next.startBeat)).type;
         if (onward === "authentic" || onward === "deceptive") {
           continue;
@@ -3267,6 +3299,1840 @@ 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 _chunkS5BKZZGMcjs.assertRecord.call(void 0, phrase, "melodic phrase").notes;
+}
+function orderedNotes(notes, name, budget) {
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, 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) <= _chunkS5BKZZGMcjs.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((_nullishCoalesce(_optionalChain([notes, 'access', _57 => _57[i], 'optionalAccess', _58 => _58.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _59 => _59[i - 1], 'optionalAccess', _60 => _60.pitch]), () => ( 0))));
+  }
+  return out;
+}
+function onsetGaps(notes) {
+  const out = [];
+  for (let i = 1; i < notes.length; i += 1) {
+    out.push((_nullishCoalesce(_optionalChain([notes, 'access', _61 => _61[i], 'optionalAccess', _62 => _62.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _63 => _63[i - 1], 'optionalAccess', _64 => _64.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(
+      (_nullishCoalesce(_optionalChain([later, 'optionalAccess', _65 => _65.startBeat]), () => ( 0))) + (_nullishCoalesce(_optionalChain([later, 'optionalAccess', _66 => _66.durationBeat]), () => ( 0))) - ((_nullishCoalesce(_optionalChain([earlier, 'optionalAccess', _67 => _67.startBeat]), () => ( 0))) + (_nullishCoalesce(_optionalChain([earlier, 'optionalAccess', _68 => _68.durationBeat]), () => ( 0))))
+    );
+  }
+  return out;
+}
+function rhythmProfile(gaps) {
+  const unit = _nullishCoalesce(gaps[0], () => ( 0));
+  if (!(unit > _chunkS5BKZZGMcjs.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((_nullishCoalesce(a[i], () => ( 0))) - (_nullishCoalesce(b[i], () => ( 0)))) > _chunkS5BKZZGMcjs.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 (_nullishCoalesce(_optionalChain([notes, 'access', _69 => _69[notes.length - 1], 'optionalAccess', _70 => _70.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _71 => _71[0], 'optionalAccess', _72 => _72.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 ((_nullishCoalesce(_optionalChain([notes, 'access', _73 => _73[i], 'optionalAccess', _74 => _74.pitch]), () => ( 0))) > (_nullishCoalesce(_optionalChain([notes, 'access', _75 => _75[peak], 'optionalAccess', _76 => _76.pitch]), () => ( 0)))) {
+      peak = i;
+    }
+    if ((_nullishCoalesce(_optionalChain([notes, 'access', _77 => _77[i], 'optionalAccess', _78 => _78.pitch]), () => ( 0))) < (_nullishCoalesce(_optionalChain([notes, 'access', _79 => _79[trough], 'optionalAccess', _80 => _80.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 = (_nullishCoalesce(_optionalChain([line, 'access', _81 => _81[peak], 'optionalAccess', _82 => _82.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([line, 'access', _83 => _83[trough], 'optionalAccess', _84 => _84.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 = _nullishCoalesce(_optionalChain([line, 'access', _85 => _85[0], 'optionalAccess', _86 => _86.pitch]), () => ( 0));
+  const last = _nullishCoalesce(_optionalChain([line, 'access', _87 => _87[line.length - 1], 'optionalAccess', _88 => _88.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 = _nullishCoalesce(_optionalChain([line, 'access', _89 => _89[peak], 'optionalAccess', _90 => _90.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 && (_nullishCoalesce(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 = _nullishCoalesce(group.starts[0], () => ( 0));
+  const prime = notes.slice(first, first + group.length).map((note) => ({ ...note }));
+  const primePitch = _nullishCoalesce(_optionalChain([prime, 'access', _91 => _91[0], 'optionalAccess', _92 => _92.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: _nullishCoalesce(_optionalChain([statement, 'access', _93 => _93[0], 'optionalAccess', _94 => _94.startBeat]), () => ( 0)),
+      endBeat: endBeatOf(statement),
+      transpose: (_nullishCoalesce(_optionalChain([statement, 'access', _95 => _95[0], 'optionalAccess', _96 => _96.pitch]), () => ( 0))) - primePitch,
+      timeRatio: primeSpan > _chunkS5BKZZGMcjs.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) > _chunkS5BKZZGMcjs.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: _nullishCoalesce(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 = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const minNotes = _chunkS5BKZZGMcjs.assertInteger.call(void 0, _nullishCoalesce(asked.minNotes, () => ( MIN_CELL_NOTES)), "motif minNotes", 2, 64);
+  const maxNotes = _chunkS5BKZZGMcjs.assertInteger.call(void 0, _nullishCoalesce(asked.maxNotes, () => ( MAX_CELL_NOTES)), "motif maxNotes", 2, 64);
+  if (maxNotes < minNotes) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `motif maxNotes must be at least minNotes ${minNotes}; received ${maxNotes}`
+    );
+  }
+  const minOccurrences = _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+    _nullishCoalesce(asked.minOccurrences, () => ( MIN_OCCURRENCES)),
+    "motif minOccurrences",
+    2
+  );
+  const sounding = orderedNotes(notes, "melody notes", asked.budget);
+  if (sounding.length < minNotes) {
+    return [];
+  }
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+    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 || (_nullishCoalesce(a.starts[0], () => ( 0))) - (_nullishCoalesce(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 = _nullishCoalesce(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;
+        }
+      }
+    }
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 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: _nullishCoalesce(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 _chunk3R3QVKY5cjs.keySignatureFifths.call(void 0, key.tonic, key.scale) < 0 ? "flat" : "sharp";
+}
+function intervalBetween(from, to, key) {
+  const spelling = spellingOf(key);
+  return _chunkS5BKZZGMcjs.spelledInterval.call(void 0, _chunkS5BKZZGMcjs.midiToNote.call(void 0, from, spelling), _chunkS5BKZZGMcjs.midiToNote.call(void 0, to, spelling));
+}
+function intervalName(interval) {
+  return `${interval.descending && interval.semitones !== 0 ? "-" : ""}${interval.quality}${interval.number}`;
+}
+function ladderIndices(notes, key) {
+  const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  const offsets = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key).map((pc) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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((_nullishCoalesce(indices[i], () => ( 0))) - (_nullishCoalesce(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 > _chunkS5BKZZGMcjs.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 : _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const model = _chunkS5BKZZGMcjs.assertArray.call(void 0, _chunkS5BKZZGMcjs.assertRecord.call(void 0, a, "a").notes, "a.notes");
+  const answer = _chunkS5BKZZGMcjs.assertArray.call(void 0, _chunkS5BKZZGMcjs.assertRecord.call(void 0, 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 = (_nullishCoalesce(_optionalChain([answer, 'access', _97 => _97[0], 'optionalAccess', _98 => _98.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([model, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.pitch]), () => ( 0)));
+  const interval = intervalBetween(_nullishCoalesce(_optionalChain([model, 'access', _101 => _101[0], 'optionalAccess', _102 => _102.pitch]), () => ( 0)), _nullishCoalesce(_optionalChain([answer, 'access', _103 => _103[0], 'optionalAccess', _104 => _104.pitch]), () => ( 0)), key);
+  const gap = (_nullishCoalesce(_optionalChain([answer, 'access', _105 => _105[0], 'optionalAccess', _106 => _106.startBeat]), () => ( 0))) - endBeatOf(model);
+  const sequence = gap >= -HUMANIZE_ADJACENCY && gap <= HUMANIZE_ADJACENCY;
+  const timeRatio = stretchRatio(modelGaps, answerGaps);
+  const stretched = Math.abs(timeRatio - 1) > _chunkS5BKZZGMcjs.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 = (_nullishCoalesce(answerLadder[0], () => ( 0))) - (_nullishCoalesce(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 = (_nullishCoalesce(previous[j - 1], () => ( 0))) + cost(ai, bj);
+      const deletion = (_nullishCoalesce(previous[j], () => ( 0))) + gap;
+      const insertion = (_nullishCoalesce(row[j - 1], () => ( 0))) + gap;
+      row[j] = Math.min(substitution, deletion, insertion);
+    }
+    previous = row;
+  }
+  return _nullishCoalesce(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 > _chunkS5BKZZGMcjs.BEAT_EPS) || !(y > _chunkS5BKZZGMcjs.BEAT_EPS)) {
+    return Math.abs(x - y) > _chunkS5BKZZGMcjs.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 = _nullishCoalesce(rhythmProfile(onsetGaps(left)), () => ( onsetGaps(left)));
+  const rightGaps = _nullishCoalesce(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 = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const variationThreshold = _nullishCoalesce(asked.variationThreshold, () => ( DEFAULT_VARIATION_THRESHOLD));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, variationThreshold, 0, 1, "motif graph variationThreshold");
+  const ordered = orderedNotes(line, "line", asked.budget);
+  const motifList = _chunkS5BKZZGMcjs.assertArray.call(void 0, motifs, "motifs");
+  const infos = [];
+  for (let mi = 0; mi < motifList.length; mi += 1) {
+    const motif = _chunkS5BKZZGMcjs.assertRecord.call(void 0, motifList[mi], `motifs[${mi}]`);
+    const notes = _chunkS5BKZZGMcjs.assertArray.call(void 0, motif.notes, `motifs[${mi}].notes`);
+    const occurrences = _chunkS5BKZZGMcjs.assertArray.call(void 0, 
+      motif.occurrences,
+      `motifs[${mi}].occurrences`
+    );
+    for (let oi = 0; oi < occurrences.length; oi += 1) {
+      const occurrence = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+        occurrences[oi],
+        `motifs[${mi}].occurrences[${oi}]`
+      );
+      const { noteIndex } = occurrence;
+      const onLine = Number.isInteger(noteIndex) && noteIndex >= 0 && noteIndex + notes.length <= ordered.length && Math.abs((_nullishCoalesce(_optionalChain([ordered, 'access', _107 => _107[noteIndex], 'optionalAccess', _108 => _108.startBeat]), () => ( Number.NaN))) - occurrence.startBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS;
+      if (!onLine) {
+        throw new (0, _chunkS5BKZZGMcjs.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;
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 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 (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, toPc) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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) <= _chunkS5BKZZGMcjs.BEAT_EPS;
+}
+function salienceFloors(durations) {
+  const order = durations.map((_, index) => index).sort((a, b) => {
+    const left = _nullishCoalesce(durations[a], () => ( 0));
+    const right = _nullishCoalesce(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[_nullishCoalesce(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 = _nullishCoalesce(rankOf[index], () => ( 0));
+    const at = (position) => _nullishCoalesce(durations[_nullishCoalesce(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 _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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 (_chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, 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 _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, before.chord.rootPc) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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 = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const keyAt = keyScaleAt(key);
+  const basis = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(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: _nullishCoalesce(floors[index], () => ( 0)) });
+    if (reason === null && index === 0) {
+      reason = { kind: "first" };
+    }
+    if (reason === null && index === segments.length - 1) {
+      reason = { kind: "last" };
+    }
+    reason ??= _nullishCoalesce(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)) < _chunkS5BKZZGMcjs.BEAT_EPS;
+}
+function rhythmLevel(beatInQuarters, meters) {
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, beatInQuarters, meters);
+  const offset = beatInQuarters - _chunkS5BKZZGMcjs.barStartBeat.call(void 0, beatInQuarters, meters);
+  const pulse = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts);
+  if (isMultipleOf(offset, pulse)) {
+    return _chunkS5BKZZGMcjs.metricWeight.call(void 0, beatInQuarters, meters) + 2;
+  }
+  const subUnit = pulse / (_chunkS5BKZZGMcjs.isCompound.call(void 0, 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 = _chunkS5BKZZGMcjs.meterAt.call(void 0, onset.beat, meters);
+  const barStart = _chunkS5BKZZGMcjs.barStartBeat.call(void 0, 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 = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meters);
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, barStart, meters);
+  const barLength = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, barStart, meters);
+  const subUnit = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts) / (_chunkS5BKZZGMcjs.isCompound.call(void 0, 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 = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, startBeat, meters);
+  const lastBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, endBeat, meters);
+  const points = [];
+  for (let bar = firstBar; bar <= lastBar; bar += 1) {
+    for (const beat of barGridBeats(bar, meters)) {
+      if (beat > startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && beat <= endBeat + _chunkS5BKZZGMcjs.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 && (_nullishCoalesce(_optionalChain([points, 'access', _109 => _109[ptr], 'optionalAccess', _110 => _110.beat]), () => ( Number.POSITIVE_INFINITY))) <= onset.snapped + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      ptr += 1;
+    }
+    let scan = ptr;
+    let maxLevel = 0;
+    while (scan < points.length && (_nullishCoalesce(_optionalChain([points, 'access', _111 => _111[scan], 'optionalAccess', _112 => _112.beat]), () => ( Number.POSITIVE_INFINITY))) < windowEnd - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      maxLevel = Math.max(maxLevel, _nullishCoalesce(_optionalChain([points, 'access', _113 => _113[scan], 'optionalAccess', _114 => _114.level]), () => ( 0)));
+      scan += 1;
+    }
+    if (maxLevel > onset.level) {
+      numerator += maxLevel - onset.level;
+    }
+    ptr = scan;
+  }
+  return numerator / normalizer;
+}
+function analyzeRhythm(notes, opts = {}) {
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "rhythm meters");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, 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, _nullishCoalesce(opts.totalBeats, () => ( lastEnd)));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, endBeat, 0, Number.MAX_SAFE_INTEGER, "rhythm totalBeats");
+  const bars = barSpanOf(startBeat, endBeat, meters);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 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 = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, startBeat, meters);
+  const barOnsets = new Array(lastBarOf(meters, startBeat, endBeat) - firstBar + 1).fill(0);
+  for (const onset of onsets) {
+    const index = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, onset.beat, meters) - firstBar;
+    if (index >= 0 && index < barOnsets.length) {
+      barOnsets[index] = (_nullishCoalesce(barOnsets[index], () => ( 0))) + 1;
+    }
+  }
+  const onsetLevels = new Array(6).fill(0);
+  let offGridCount = 0;
+  for (const onset of snapped) {
+    onsetLevels[onset.level] = (_nullishCoalesce(onsetLevels[onset.level], () => ( 0))) + 1;
+    if (onset.offGrid) {
+      offGridCount += 1;
+    }
+  }
+  for (let i = 0; i < onsetLevels.length; i += 1) {
+    onsetLevels[i] = (_nullishCoalesce(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(_chunkS5BKZZGMcjs.beatsPerBar.call(void 0, 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] = (_nullishCoalesce(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] = (_nullishCoalesce(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] = (_nullishCoalesce(interOnsetShares[bin], () => ( 0))) + 1;
+  }
+  for (let i = 0; i < interOnsetShares.length; i += 1) {
+    interOnsetShares[i] = (_nullishCoalesce(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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be a string; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, value)}`);
+  }
+  return value;
+}
+function assertSpanOrder(startBeat, endBeat, name) {
+  if (endBeat < startBeat) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.endBeat must be at least ${name}.startBeat; received ${endBeat} < ${startBeat}`
+    );
+  }
+}
+function assertNullable(value, name, validate) {
+  if (value === void 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be present; received undefined`);
+  }
+  return value === null ? null : validate(value, name);
+}
+function assertMassDistribution(value, length, name, allowAllZero) {
+  const shares = _chunkS5BKZZGMcjs.assertArray.call(void 0, value, name);
+  if (shares.length !== length) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must have length ${length}; received ${shares.length}`);
+  }
+  let sum = 0;
+  for (let index = 0; index < shares.length; index += 1) {
+    const share = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, shares[index], `${name}[${index}]`);
+    if (share < 0) {
+      throw new (0, _chunkS5BKZZGMcjs.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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must sum to 1; received ${sum}`);
+  }
+  return shares;
+}
+function assertBarPositionProfile(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, read.ts, `${name}.ts`);
+  const slotsPerBar = _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, read.slotsPerBar, `${name}.slotsPerBar`);
+  const onsets = _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.onsets, `${name}.onsets`, 0);
+  assertMassDistribution(read.shares, slotsPerBar, `${name}.shares`, onsets === 0);
+  return read;
+}
+function assertRhythmAnalysis(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  const onsets = _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.onsets, `${name}.onsets`, 0);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  const barOnsets = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.barOnsets, `${name}.barOnsets`);
+  for (let index = 0; index < barOnsets.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
+      barOnsets[index],
+      0,
+      Number.MAX_SAFE_INTEGER,
+      `${name}.barOnsets[${index}]`
+    );
+  }
+  assertMassDistribution(read.onsetLevels, 6, `${name}.onsetLevels`, onsets === 0);
+  const barPositions = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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
+  );
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.restRatio, 0, 1, `${name}.restRatio`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.syncopation, 0, 1, `${name}.syncopation`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.offGridRatio, 0, 1, `${name}.offGridRatio`);
+  assertString(read.rationale, `${name}.rationale`);
+  return read;
+}
+function assertFormSection(value, name, sectionCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  assertString(read.label, `${name}.label`);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.firstOccurrence, `${name}.firstOccurrence`, 0, Math.max(sectionCount - 1, 0));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.similarity, 0, 1, `${name}.similarity`);
+  assertString(read.rationale, `${name}.rationale`);
+  return read;
+}
+function assertReferenceCadence(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.atBeat, `${name}.atBeat`);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.type, CADENCE_TYPES, `${name}.type`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.weight, 0, 1, `${name}.weight`);
+  return read;
+}
+function assertReferencePhraseMelody(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.shape, MELODIC_CONTOUR_SHAPES, `${name}.shape`);
+  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, read.low, `${name}.low`);
+  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, read.high, `${name}.high`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.mean, 0, 127, `${name}.mean`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.peakPitch, 0, 127, `${name}.peakPitch`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.peakPosition, 0, 1, `${name}.peakPosition`);
+  const outline = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.outline, `${name}.outline`);
+  if (outline.length !== 8) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.outline must have length 8; received ${outline.length}`);
+  }
+  for (let index = 0; index < outline.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, outline[index], `${name}.outline[${index}]`);
+  }
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.restRatio, 0, 1, `${name}.restRatio`);
+  return read;
+}
+function assertReferencePhrase(value, name, sectionCount, nodeCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  assertNullable(
+    read.section,
+    `${name}.section`,
+    (v, n) => _chunkS5BKZZGMcjs.assertInteger.call(void 0, v, n, 0, Math.max(sectionCount - 1, 0))
+  );
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.confidence, 0, 1, `${name}.confidence`);
+  assertNullable(read.cadence, `${name}.cadence`, assertReferenceCadence);
+  assertNullable(read.melody, `${name}.melody`, assertReferencePhraseMelody);
+  const motifNodes = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.motifNodes, `${name}.motifNodes`);
+  for (let index = 0; index < motifNodes.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+      motifNodes[index],
+      `${name}.motifNodes[${index}]`,
+      0,
+      Math.max(nodeCount - 1, 0)
+    );
+  }
+  return read;
+}
+function assertReferenceForm(value, name, nodeCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const hypermeter = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+    read.hypermeter,
+    `${name}.hypermeter`
+  );
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, hypermeter.groupBars, 0, Number.MAX_SAFE_INTEGER, `${name}.hypermeter.groupBars`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, hypermeter.confidence, 0, 1, `${name}.hypermeter.confidence`);
+  const sections = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.sections, `${name}.sections`);
+  for (let index = 0; index < sections.length; index += 1) {
+    assertFormSection(sections[index], `${name}.sections[${index}]`, sections.length);
+  }
+  const phrases = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  try {
+    _chunk3R3QVKY5cjs.resolveKey.call(void 0, read);
+  } catch (error) {
+    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be a valid key: ${error.message}`);
+    }
+    throw error;
+  }
+  return read;
+}
+function assertReferenceKeyRegion(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  assertResolvedKeyField(read.key, `${name}.key`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.confidence, 0, 1, `${name}.confidence`);
+  return read;
+}
+function assertReferenceChord(value, name, keys) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  const keyIndex = _chunkS5BKZZGMcjs.assertInteger.call(void 0, 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 _chunkS5BKZZGMcjs.InvalidInputError) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}.roman must be readable by romanToChord; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, roman)}: ${error.message}`
+      );
+    }
+    throw error;
+  }
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.function, HARMONIC_FUNCTIONS, `${name}.function`);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.level, REDUCTION_LEVELS, `${name}.level`);
+  return read;
+}
+function assertReferenceHarmony(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const keys = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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 = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.kind, MOTIF_RELATION_KINDS, `${name}.kind`);
+  _chunkS5BKZZGMcjs.assertFlag.call(void 0, read.sequence, `${name}.sequence`);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.semitones, `${name}.semitones`);
+  if (read.degrees !== void 0) {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.degrees, `${name}.degrees`);
+  }
+  const timeRatio = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.timeRatio, `${name}.timeRatio`);
+  if (timeRatio <= 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.timeRatio must be positive; received ${timeRatio}`);
+  }
+  return read;
+}
+function assertMotifGraphNode(value, name, occurrenceCounts) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const motif = _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+    read.motif,
+    `${name}.motif`,
+    0,
+    Math.max(occurrenceCounts.length - 1, 0)
+  );
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+    read.occurrence,
+    `${name}.occurrence`,
+    0,
+    Math.max((_nullishCoalesce(occurrenceCounts[motif], () => ( 1))) - 1, 0)
+  );
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  return read;
+}
+function assertMotifGraphEdge(value, name, nodeCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const from = _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.from, `${name}.from`, 0, Math.max(nodeCount - 1, 0));
+  const to = _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.to, `${name}.to`, 0, Math.max(nodeCount - 1, 0));
+  if (from >= to) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.from must be less than ${name}.to; received from=${from}, to=${to}`
+    );
+  }
+  assertNullable(read.relation, `${name}.relation`, assertMotifRelationSummary);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.similarity, 0, 1, `${name}.similarity`);
+  return read;
+}
+function assertMotifGraph(value, name, occurrenceCounts) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const nodes = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.nodes, `${name}.nodes`);
+  for (let index = 0; index < nodes.length; index += 1) {
+    assertMotifGraphNode(nodes[index], `${name}.nodes[${index}]`, occurrenceCounts);
+  }
+  const edges = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.edges: node ${edge.to} has more than one incoming edge`);
+    }
+    seenTo.add(edge.to);
+  }
+  return read;
+}
+function assertReferenceMotif(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const intervals = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.intervals, `${name}.intervals`);
+  let pitch = 0;
+  let low = 0;
+  let high = 0;
+  for (let index = 0; index < intervals.length; index += 1) {
+    const interval = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, intervals[index], `${name}.intervals[${index}]`);
+    if (!Number.isInteger(interval)) {
+      throw new (0, _chunkS5BKZZGMcjs.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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.intervals must span at most 127 semitones; received ${high - low}`
+    );
+  }
+  const rhythm = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.rhythm, `${name}.rhythm`);
+  if (rhythm.length !== intervals.length) {
+    throw new (0, _chunkS5BKZZGMcjs.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 = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, rhythm[index], `${name}.rhythm[${index}]`);
+    if (!(ratio2 > 0)) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.rhythm[${index}] must be positive; received ${ratio2}`);
+    }
+  }
+  const unitBeats = _chunkS5BKZZGMcjs.assertRange.call(void 0, read.unitBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.unitBeats`);
+  if (unitBeats > 0 !== rhythm.length > 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.unitBeats must be positive exactly when rhythm is non-empty; received ${unitBeats} with ${rhythm.length} ratio(s)`
+    );
+  }
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.spanBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.spanBeats`);
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, read.occurrences, `${name}.occurrences`);
+  return read;
+}
+function assertReferenceMelody(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  assertNullable(read.register, `${name}.register`, (v, n) => {
+    const register = _chunkS5BKZZGMcjs.assertRecord.call(void 0, v, n);
+    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, register.low, `${n}.low`);
+    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, register.high, `${n}.high`);
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, register.mean, 0, 127, `${n}.mean`);
+    return register;
+  });
+  assertNullable(read.shape, `${name}.shape`, (v, n) => _chunkS5BKZZGMcjs.assertOneOf.call(void 0, v, MELODIC_CONTOUR_SHAPES, n));
+  const motifs = _chunkS5BKZZGMcjs.assertArray.call(void 0, 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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  if (read.profileVersion !== REFERENCE_PROFILE_VERSION) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.profileVersion must be ${REFERENCE_PROFILE_VERSION}; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, read.profileVersion)}`
+    );
+  }
+  const span = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+    read.span,
+    `${name}.span`
+  );
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, span.startBeat, `${name}.span.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, span.endBeat, `${name}.span.endBeat`);
+  assertSpanOrder(startBeat, endBeat, `${name}.span`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, span.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.span.bars`);
+  _chunkS5BKZZGMcjs.assertMeterMap.call(void 0, 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((_nullishCoalesce(a[i], () => ( 0))) / massA, (_nullishCoalesce(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) {
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 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] = (_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([keys, 'access', _115 => _115[0], 'optionalAccess', _116 => _116.scale, 'access', _117 => _117.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 = _nullishCoalesce(motif.rhythm[i], () => ( 1));
+    notes.push({ pitch, startBeat: beat, durationBeat: i < motif.intervals.length ? step : 1 });
+    pitch += _nullishCoalesce(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] = (_nullishCoalesce(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 = _optionalChain([edge, 'access', _118 => _118.relation, 'optionalAccess', _119 => _119.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 = _optionalChain([edge, 'access', _120 => _120.relation, 'optionalAccess', _121 => _121.kind]);
+      const keepsPitch = kind !== void 0 && PITCH_PRESERVING.has(kind);
+      depth[node] = (_nullishCoalesce(depth[edge.from], () => ( 0))) + (keepsPitch ? 0 : 1);
+      root[node] = _nullishCoalesce(root[edge.from], () => ( edge.from));
+    }
+  }
+  const familySize = /* @__PURE__ */ new Map();
+  for (const r of root) {
+    familySize.set(r, (_nullishCoalesce(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((_nullishCoalesce(left[i], () => ( 0))) - (_nullishCoalesce(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 = _nullishCoalesce(a.mean, () => ( 0));
+  const meanB = _nullishCoalesce(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 - _chunkS5BKZZGMcjs.BEAT_EPS && note.startBeat < endBeat - _chunkS5BKZZGMcjs.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 + _chunkS5BKZZGMcjs.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
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -3325,5 +5191,5 @@ function detectCadences(timeline, key) {
 
 
 
-exports.HUMANIZE_ADJACENCY = HUMANIZE_ADJACENCY; exports.sameInstant = sameInstant; exports.adjacent = adjacent; exports.hasEnded = hasEnded; exports.windowWeights = windowWeights; exports.MODAL_SCALE_NAMES = MODAL_SCALE_NAMES; exports.detectChord = detectChord; exports.detectChordBest = detectChordBest; exports.detectKey = detectKey; exports.detectKeyFromNotes = detectKeyFromNotes; exports.detectKeyBest = detectKeyBest; exports.augmentedSixthChord = augmentedSixthChord; exports.augmentedSixthKind = augmentedSixthKind; exports.augmentedSixthFromPitchClasses = augmentedSixthFromPitchClasses; exports.spellAugmentedSixth = spellAugmentedSixth; exports.isCadentialSixFour = isCadentialSixFour; exports.detectCadence = detectCadence; exports.isBorrowedChord = isBorrowedChord; exports.borrowedSource = borrowedSource; exports.isAppliedDominant = isAppliedDominant; exports.romanToChord = romanToChord; exports.chordToRoman = chordToRoman; exports.explainRoman = explainRoman; exports.isMinorKey = isMinorKey; exports.functionOf = functionOf; exports.isDiatonic = isDiatonic; exports.parallelKey = parallelKey; exports.analyzeChord = analyzeChord; exports.secondaryDominant = secondaryDominant; exports.secondaryDominantOf = secondaryDominantOf; exports.pivotChords = pivotChords; exports.clamp01 = clamp01; exports.floorMod = floorMod; exports.firstSoundingBeat = firstSoundingBeat; exports.lastBarOf = lastBarOf; exports.sliceBars = sliceBars; exports.weightSimilarity = weightSimilarity; exports.harmonicNovelty = harmonicNovelty; exports.combineEvidence = combineEvidence; exports.gridForNotes = gridForNotes; exports.barGridStart = barGridStart; exports.keyTimelineFromNotes = keyTimelineFromNotes; exports.detectModulations = detectModulations; exports.attachPivots = attachPivots; exports.keyLookup = keyLookup; exports.prevailingKeyOf = prevailingKeyOf; exports.keyScaleAt = keyScaleAt; exports.toVoiceNotes = toVoiceNotes; exports.analyzeVoice = analyzeVoice; exports.assertChordTimeline = assertChordTimeline; exports.chordTimelineFromChords = chordTimelineFromChords; exports.chordAtBeat = chordAtBeat; exports.segmentStartingAt = segmentStartingAt; exports.chordTimelineFromNotes = chordTimelineFromNotes; exports.dirtySlotsFor = dirtySlotsFor; exports.analyzeTimeline = analyzeTimeline; exports.detectCadences = detectCadences;
-//# sourceMappingURL=chunk-Q6R3QAZD.cjs.map
+exports.HUMANIZE_ADJACENCY = HUMANIZE_ADJACENCY; exports.sameInstant = sameInstant; exports.adjacent = adjacent; exports.hasEnded = hasEnded; exports.windowWeights = windowWeights; exports.MODAL_SCALE_NAMES = MODAL_SCALE_NAMES; exports.detectChord = detectChord; exports.detectChordBest = detectChordBest; exports.detectKey = detectKey; exports.detectKeyFromNotes = detectKeyFromNotes; exports.detectKeyBest = detectKeyBest; exports.augmentedSixthChord = augmentedSixthChord; exports.augmentedSixthKind = augmentedSixthKind; exports.augmentedSixthFromPitchClasses = augmentedSixthFromPitchClasses; exports.spellAugmentedSixth = spellAugmentedSixth; exports.CADENCE_TYPES = CADENCE_TYPES; exports.detectCadence = detectCadence; exports.isBorrowedChord = isBorrowedChord; exports.borrowedSource = borrowedSource; exports.romanToChord = romanToChord; exports.chordToRoman = chordToRoman; exports.explainRoman = explainRoman; exports.HARMONIC_FUNCTIONS = HARMONIC_FUNCTIONS; exports.isMinorKey = isMinorKey; exports.functionOf = functionOf; exports.isDiatonic = isDiatonic; exports.parallelKey = parallelKey; exports.analyzeChord = analyzeChord; exports.secondaryDominant = secondaryDominant; exports.secondaryDominantOf = secondaryDominantOf; exports.pivotChords = pivotChords; exports.barSpanOf = barSpanOf; exports.clamp01 = clamp01; exports.floorMod = floorMod; exports.firstSoundingBeat = firstSoundingBeat; exports.lastBarOf = lastBarOf; exports.sliceBars = sliceBars; exports.weightSimilarity = weightSimilarity; exports.harmonicNovelty = harmonicNovelty; exports.combineEvidence = combineEvidence; exports.gridForNotes = gridForNotes; exports.barGridStart = barGridStart; exports.keyTimelineFromNotes = keyTimelineFromNotes; exports.detectModulations = detectModulations; exports.attachPivots = attachPivots; exports.keyLookup = keyLookup; exports.prevailingKeyOf = prevailingKeyOf; exports.toVoiceNotes = toVoiceNotes; exports.analyzeVoice = analyzeVoice; exports.assertChordTimeline = assertChordTimeline; exports.chordTimelineFromChords = chordTimelineFromChords; exports.chordAtBeat = chordAtBeat; exports.segmentStartingAt = segmentStartingAt; exports.chordTimelineFromNotes = chordTimelineFromNotes; exports.dirtySlotsFor = dirtySlotsFor; exports.analyzeTimeline = analyzeTimeline; exports.detectCadences = detectCadences; exports.orderedNotes = orderedNotes; exports.MELODIC_CONTOUR_SHAPES = MELODIC_CONTOUR_SHAPES; exports.melodicContour = melodicContour; exports.extractMotifs = extractMotifs; exports.motifFromNotes = motifFromNotes; exports.MOTIF_RELATION_KINDS = MOTIF_RELATION_KINDS; exports.relateMotifs = relateMotifs; exports.compareMelodies = compareMelodies; exports.melodicSimilarity = melodicSimilarity; exports.DEFAULT_VARIATION_THRESHOLD = DEFAULT_VARIATION_THRESHOLD; exports.motifGraph = motifGraph; exports.REDUCTION_LEVELS = REDUCTION_LEVELS; exports.reduceProgression = reduceProgression; exports.sectionSequenceSimilarity = sectionSequenceSimilarity; exports.phraseLengthSimilarity = phraseLengthSimilarity; exports.progressionSimilarity = progressionSimilarity; exports.functionSimilarity = functionSimilarity; exports.cadenceSimilarity = cadenceSimilarity; exports.keyPlanSimilarity = keyPlanSimilarity; exports.onsetSimilarity = onsetSimilarity; exports.densitySimilarity = densitySimilarity; exports.durationSimilarity = durationSimilarity; exports.syncopationSimilarity = syncopationSimilarity; exports.surfaceSimilarity = surfaceSimilarity; exports.motifStructureSimilarity = motifStructureSimilarity; exports.contourSimilarity = contourSimilarity; exports.registerSimilarity = registerSimilarity; exports.rhythmLevel = rhythmLevel; exports.ioiBinIndex = ioiBinIndex; exports.RHYTHM_IOI_BINS = RHYTHM_IOI_BINS; exports.analyzeRhythm = analyzeRhythm; exports.REFERENCE_PROFILE_VERSION = REFERENCE_PROFILE_VERSION; exports.assertReferenceProfile = assertReferenceProfile; exports.weightedMean = weightedMean; exports.phraseMelody = phraseMelody;
+//# sourceMappingURL=chunk-IFZDWIKM.cjs.map