@libraz/libcantus 1.3.0 → 1.4.0

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

@@ -1,7 +1,7 @@
 "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 _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
 
+var _chunkKMYGRFZ6cjs = require('./chunk-KMYGRFZ6.cjs');
 
 
 
@@ -48,11 +48,11 @@ var _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
 
 
 
-var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
 
+var _chunkYDGMWH43cjs = require('./chunk-YDGMWH43.cjs');
 
 
 
@@ -90,18 +90,24 @@ var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
-var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
+
+
+
+
+
+
+var _chunkS3QELJUEcjs = require('./chunk-S3QELJUE.cjs');
 
 // src/analyze/detect/modes.ts
 var MODAL_CANDIDATES = Object.freeze([
-  { 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: "dorian", mode: "minor", mask: _chunkYDGMWH43cjs.DORIAN_MASK, substitutions: [[8, 9]] },
+  { scaleName: "phrygian", mode: "minor", mask: _chunkYDGMWH43cjs.PHRYGIAN_MASK, substitutions: [[2, 1]] },
+  { scaleName: "lydian", mode: "major", mask: _chunkYDGMWH43cjs.LYDIAN_MASK, substitutions: [[5, 6]] },
+  { scaleName: "mixolydian", mode: "major", mask: _chunkYDGMWH43cjs.MIXOLYDIAN_MASK, substitutions: [[11, 10]] },
   {
     scaleName: "locrian",
     mode: "minor",
-    mask: _chunk3R3QVKY5cjs.LOCRIAN_MASK,
+    mask: _chunkYDGMWH43cjs.LOCRIAN_MASK,
     substitutions: [
       [2, 1],
       [7, 6]
@@ -128,12 +134,12 @@ function resolveModalCandidates(modes) {
     return MODAL_CANDIDATES;
   }
   if (!Array.isArray(modes)) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("modes must be a boolean or an array of mode names");
+    throw new (0, _chunkS3QELJUEcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
         `unknown mode '${String(name)}'; expected one of ${MODAL_SCALE_NAMES.join(", ")}`
       );
     }
@@ -144,7 +150,7 @@ function resolveModalCandidates(modes) {
 // src/analyze/adjacency.ts
 var HUMANIZE_ADJACENCY = 0.05;
 function sameInstant(beat, other) {
-  return Math.abs(beat - other) <= _chunkS5BKZZGMcjs.BEAT_EPS;
+  return Math.abs(beat - other) <= _chunkS3QELJUEcjs.BEAT_EPS;
 }
 function adjacent(prevEnd, nextStart) {
   return Math.abs(nextStart - prevEnd) <= HUMANIZE_ADJACENCY;
@@ -158,7 +164,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 + _chunkS5BKZZGMcjs.metricWeight.call(void 0, note.startBeat, meter) / ACCENT_DIVISOR;
+  const accent = meter === void 0 ? 1 : 1 + _chunkS3QELJUEcjs.metricWeight.call(void 0, note.startBeat, meter) / ACCENT_DIVISOR;
   return beats * velocityFactor * accent;
 }
 function bucketNotesBySlot(notes, grid, slotCount, opts) {
@@ -171,7 +177,7 @@ function bucketNotesBySlot(notes, grid, slotCount, opts) {
       Math.ceil((note.startBeat + note.durationBeat - grid.origin) / grid.slotBeats)
     );
     memberships += Math.max(0, lastExclusive - first);
-    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, opts.name, opts.budget);
+    _chunkS3QELJUEcjs.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)]);
     }
@@ -184,14 +190,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 <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (overlap <= _chunkS3QELJUEcjs.BEAT_EPS) {
       continue;
     }
-    const onsetInWindow = note.startBeat >= windowStart - _chunkS5BKZZGMcjs.BEAT_EPS && note.startBeat < windowEnd - _chunkS5BKZZGMcjs.BEAT_EPS;
-    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch);
+    const onsetInWindow = note.startBeat >= windowStart - _chunkS3QELJUEcjs.BEAT_EPS && note.startBeat < windowEnd - _chunkS3QELJUEcjs.BEAT_EPS;
+    const pc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, note.pitch);
     const weight = noteWeight(note, overlap, onsetInWindow ? meter : void 0);
     weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + weight;
-    if (weight > _chunkS5BKZZGMcjs.BEAT_EPS && note.pitch < lowestPitch) {
+    if (weight > _chunkS3QELJUEcjs.BEAT_EPS && note.pitch < lowestPitch) {
       lowestPitch = note.pitch;
     }
   }
@@ -204,6 +210,30 @@ function windowWeights(notes, windowStart, windowEnd, meter) {
   return { weights, totalWeight, maxWeight, lowestPitch };
 }
 
+// src/analyze/detect/internal.ts
+var MINOR_VARIANTS = [
+  { variant: "natural", mask: _chunkYDGMWH43cjs.NATURAL_MINOR_MASK, scaleName: "naturalMinor" },
+  { variant: "harmonic", mask: _chunkYDGMWH43cjs.HARMONIC_MINOR_MASK, scaleName: "harmonicMinor" },
+  { variant: "melodic", mask: _chunkYDGMWH43cjs.MELODIC_MINOR_MASK, scaleName: "melodicMinor" }
+];
+var MAJOR_VARIANTS = [
+  { variant: "major", mask: _chunkYDGMWH43cjs.MAJOR_MASK, scaleName: "major" }
+];
+var SCALE_NAME_ORDER = [
+  "major",
+  "naturalMinor",
+  "harmonicMinor",
+  "melodicMinor",
+  "dorian",
+  "phrygian",
+  "lydian",
+  "mixolydian",
+  "locrian"
+];
+var EXPLAINED_RIVALS = 3;
+var SCORE_DIGITS = 2;
+var MAX_SCORE_DIGITS = 6;
+
 // src/analyze/detect/profiles.ts
 var KRUMHANSL_KESSLER_PROFILE = {
   major: [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88],
@@ -226,12 +256,12 @@ var NAMED_PROFILES = {
 };
 function assertProfileVector(vector, name) {
   if (vector.length !== PROFILE_LENGTH) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must have ${PROFILE_LENGTH} entries`);
+    throw new (0, _chunkS3QELJUEcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}[${index}] must be a finite number`);
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${name}[${index}] must be a finite number`);
     }
   }
 }
@@ -242,18 +272,18 @@ function resolveKeyProfile(profile) {
   if (typeof profile === "string") {
     const named = NAMED_PROFILES[profile];
     if (named === void 0) {
-      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
         `unknown key profile '${profile}'; expected one of ${Object.keys(NAMED_PROFILES).join(", ")}`
       );
     }
     return named;
   }
   if (typeof profile !== "object" || profile === null) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("profile must be a profile name or a { major, minor } pair");
+    throw new (0, _chunkS3QELJUEcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)("profile must carry a major and a minor vector");
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)("profile must carry a major and a minor vector");
   }
   assertProfileVector(major, "profile.major");
   assertProfileVector(minor, "profile.minor");
@@ -302,45 +332,54 @@ function profileScore(dist, vector, tonic) {
 }
 
 // src/analyze/detect/index.ts
+var CHORD_INPUT_KINDS = [
+  "auto",
+  "midi",
+  "pitchClass"
+];
 function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(_chunkS5BKZZGMcjs.pitchClassOf))].sort((a, b) => a - b);
+  return [...new Set(pitches.map(_chunkS3QELJUEcjs.pitchClassOf))].sort((a, b) => a - b);
 }
 function assertPitches(pitches, name, budget = void 0) {
-  _chunkS5BKZZGMcjs.assertArray.call(void 0, pitches, name);
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
+  _chunkS3QELJUEcjs.assertArray.call(void 0, pitches, name);
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, pitches.length, name, budget);
   for (let index = 0; index < pitches.length; index += 1) {
-    _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
+    _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, _nullishCoalesce(pitches[index], () => ( Number.NaN)), `pitches[${index}]`);
   }
 }
 function detectChord(pitches, opts = {}) {
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
   assertPitches(pitches, "chord detection pitches");
-  if (asked.bassPc !== void 0) _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, asked.bassPc, "bassPc");
+  const askedKind = _chunkS3QELJUEcjs.assertOneOf.call(void 0, _nullishCoalesce(asked.input, () => ( "auto")), CHORD_INPUT_KINDS, "input");
+  if (asked.bassPc !== void 0) _chunkS3QELJUEcjs.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 ? _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 inputKind = askedKind === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : askedKind;
+  const bassPc = asked.bassPc !== void 0 ? _chunkS3QELJUEcjs.pitchClassOf.call(void 0, asked.bassPc) : inputKind === "midi" ? _chunkS3QELJUEcjs.pitchClassOf.call(void 0, pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
   const inputSet = new Set(input);
   const matches = [];
-  const qualities = _chunk3R3QVKY5cjs.chordQualities.call(void 0, );
+  const qualities = _chunkYDGMWH43cjs.chordQualities.call(void 0, );
   const toneCounts = new Map(
-    qualities.map((quality) => [quality, _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 0, quality)).length])
+    qualities.map((quality) => [quality, _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, _chunkYDGMWH43cjs.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 = _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality);
-      const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
+      const chord = _chunkYDGMWH43cjs.makeChord.call(void 0, rootPc, quality);
+      const tones = _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, chord);
       const toneSet = new Set(tones);
       const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 7);
+      const fifthPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc + 7);
       if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
         continue;
       }
+      if (tones.length - missingPcs.length < 2) {
+        continue;
+      }
       const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + iv) === bassPc);
+      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc + iv) === bassPc);
       const inversion = bassPc === void 0 || bassIndex < 0 ? null : bassIndex;
       const match = {
         rootPc,
@@ -385,33 +424,11 @@ function detectChordBest(pitches, opts = {}) {
   if (!best) {
     return null;
   }
-  return _chunk3R3QVKY5cjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
+  return _chunkYDGMWH43cjs.makeChord.call(void 0, best.rootPc, best.quality, best.bassPc);
 }
-var MINOR_VARIANTS = [
-  { 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: _chunk3R3QVKY5cjs.MAJOR_MASK, scaleName: "major" }
-];
-var SCALE_NAME_ORDER = [
-  "major",
-  "naturalMinor",
-  "harmonicMinor",
-  "melodicMinor",
-  "dorian",
-  "phrygian",
-  "lydian",
-  "mixolydian",
-  "locrian"
-];
 function scaleNameRank(name) {
   return SCALE_NAME_ORDER.indexOf(name);
 }
-var EXPLAINED_RIVALS = 3;
-var SCORE_DIGITS = 2;
-var MAX_SCORE_DIGITS = 6;
 function quoteScores(rival, winner) {
   let digits = SCORE_DIGITS;
   while (digits < MAX_SCORE_DIGITS && rival.toFixed(digits) === winner.toFixed(digits)) {
@@ -420,7 +437,7 @@ function quoteScores(rival, winner) {
   return `${rival.toFixed(digits)} against ${winner.toFixed(digits)}`;
 }
 function keyLabel(match) {
-  const tonic = _chunkS5BKZZGMcjs.formatNote.call(void 0, _chunk3R3QVKY5cjs.spelledKeyOf.call(void 0, match.key).tonic);
+  const tonic = _chunkS3QELJUEcjs.formatNote.call(void 0, _chunkYDGMWH43cjs.spelledKeyOf.call(void 0, match.key).tonic);
   const scale = match.scaleName.replace(/([A-Z])/g, " $1").toLowerCase();
   return `${tonic} ${scale}`;
 }
@@ -451,11 +468,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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  const asked = _chunkS3QELJUEcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)("weights must have one entry per pitch");
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)("weights must have one entry per pitch");
   }
   const profile = resolveKeyProfile(opts.profile);
   const modalCandidates = resolveModalCandidates(opts.modes).map((candidate) => ({
@@ -466,11 +483,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));
-    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
+    _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, weight, `weights[${index}]`);
     if (weight <= 0) {
       continue;
     }
-    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(pitches[index], () => ( 0)));
+    const pc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(pitches[index], () => ( 0)));
     counts.set(pc, (_nullishCoalesce(counts.get(pc), () => ( 0))) + weight);
     total += weight;
   }
@@ -551,8 +568,8 @@ function detectKey(pitches, opts = {}) {
   return results;
 }
 function detectKeyFromNotes(notes, opts = {}) {
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, notes, "key detection notes", {
     allowNonPositiveDuration: true,
     budget: asked.budget
   });
@@ -574,40 +591,40 @@ function detectKeyBest(pitches, opts = {}) {
 
 // src/analyze/functional/internal.ts
 function isMinorScale(key) {
-  return _chunk3R3QVKY5cjs.isMinorMask.call(void 0, key.modeMask12);
+  return _chunkYDGMWH43cjs.isMinorMask.call(void 0, key.modeMask12);
 }
 function parallelScale(key) {
   return {
-    rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc),
-    modeMask12: isMinorScale(key) ? _chunk3R3QVKY5cjs.MAJOR_MASK : _chunk3R3QVKY5cjs.NATURAL_MINOR_MASK
+    rootPc: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc),
+    modeMask12: isMinorScale(key) ? _chunkYDGMWH43cjs.MAJOR_MASK : _chunkYDGMWH43cjs.NATURAL_MINOR_MASK
   };
 }
 function degreeRootPc(degreeNumber, key) {
-  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const tones = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, key);
   if (tones.length === 0) {
-    return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+    return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc);
   }
   const index = ((degreeNumber - 1) % tones.length + tones.length) % tones.length;
-  return _nullishCoalesce(tones[index], () => ( _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc)));
+  return _nullishCoalesce(tones[index], () => ( _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc)));
 }
 function loweredDegrees(key) {
-  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const tones = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, key);
   const out = /* @__PURE__ */ new Set();
   if (tones.length !== 7) {
     return out;
   }
-  const major = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunk3R3QVKY5cjs.MAJOR_MASK });
+  const major = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, { rootPc: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYDGMWH43cjs.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 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
+    if (tone !== void 0 && majorTone !== void 0 && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, majorTone - tone) === 1) {
       out.add(index + 1);
     }
   }
   return out;
 }
 function romanReference(key) {
-  return _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key);
+  return _chunkYDGMWH43cjs.heptatonicFrameOf.call(void 0, key);
 }
 
 // src/analyze/functional/augmented-sixth.ts
@@ -619,30 +636,31 @@ var TONES_ABOVE_BASS = {
   german: [0, 4, 7, 10]
 };
 var SPELLED_ABOVE_BASS = {
-  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))
+  italian: ["P1", "M3", "A6"].map((name) => _chunkS3QELJUEcjs.parseInterval.call(void 0, name)),
+  french: ["P1", "M3", "A4", "A6"].map((name) => _chunkS3QELJUEcjs.parseInterval.call(void 0, name)),
+  german: ["P1", "M3", "P5", "A6"].map((name) => _chunkS3QELJUEcjs.parseInterval.call(void 0, name))
 };
-var BASS_INTERVAL = _chunkS5BKZZGMcjs.parseInterval.call(void 0, "m6");
+var BASS_INTERVAL = _chunkS3QELJUEcjs.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] },
   german: { rootAboveBass: 0, quality: "dom7", intervals: [0, 4, 7, 10] }
 };
-var KIND_BY_SYMBOL = /* @__PURE__ */ new Map([
+var KIND_SYMBOLS = [
   ["It6", "italian"],
   ["Fr6", "french"],
   ["Ger6", "german"],
   // The German sixth's figures over its bass are 6/5; both spellings are in use.
   ["Ger65", "german"]
-]);
+];
+var KIND_BY_SYMBOL = new Map(KIND_SYMBOLS);
 var SYMBOL_BY_KIND = {
   italian: "It6",
   french: "Fr6",
   german: "Ger6"
 };
 function bassPcOf(key) {
-  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + BASS_ABOVE_TONIC);
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc + BASS_ABOVE_TONIC);
 }
 function bareSpelling(note) {
   return { letter: note.letter, alter: note.alter };
@@ -656,72 +674,74 @@ function augmentedSixthChord(kind, key) {
   return augmentedSixthOn(kind, key);
 }
 function augmentedSixthOn(kind, keyLike) {
-  const checked = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const checked = _chunkS3QELJUEcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
   const shape = CHORD_SHAPE[checked];
-  const { scale: key, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const { scale: key, tonic } = _chunkYDGMWH43cjs.resolveKey.call(void 0, keyLike);
   const bassPc = bassPcOf(key);
-  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, bassPc);
-  chord.intervals = [...shape.intervals];
-  const bass = _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
+  const bass = _chunkS3QELJUEcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
   const tones = spelledInChordOrder(checked, tonic);
   const [root = bass] = tones;
-  chord.rootSpelling = bareSpelling(root);
-  chord.bassSpelling = bareSpelling(bass);
-  chord.toneSpellings = tones.map(bareSpelling);
+  const chord = _chunkYDGMWH43cjs.makeSpelledChord.call(void 0, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, bassPc + shape.rootAboveBass), shape.quality, {
+    bassPc,
+    rootSpelling: bareSpelling(root),
+    bassSpelling: bareSpelling(bass),
+    toneSpellings: tones.map(bareSpelling)
+  });
+  chord.intervals = [...shape.intervals];
   return chord;
 }
 function kindOfPitchClasses(pcs, bass) {
   for (const kind of KINDS) {
     const tones = TONES_ABOVE_BASS[kind];
-    if (pcs.size === tones.length && tones.every((tone) => pcs.has(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bass + tone)))) {
+    if (pcs.size === tones.length && tones.every((tone) => pcs.has(_chunkS3QELJUEcjs.pitchClassOf.call(void 0, bass + tone)))) {
       return kind;
     }
   }
   return null;
 }
 function spellingId(note) {
-  return `${_chunkS5BKZZGMcjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
+  return `${_chunkS3QELJUEcjs.diatonicLetterOf.call(void 0, note.letter)}:${note.alter}`;
 }
 function spellsAugmentedSixth(chord, kind, key) {
   const tonic = key.tonic;
-  const written = new Set(_chunk3R3QVKY5cjs.spellChord.call(void 0, chord, tonic, key.scale).map(spellingId));
+  const written = new Set(_chunkYDGMWH43cjs.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(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key);
+  return augmentedSixthKindOf(_chunkYDGMWH43cjs.toChordData.call(void 0, chord), key);
 }
 function augmentedSixthKindOf(chord, keyLike) {
-  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunkYDGMWH43cjs.resolveKey.call(void 0, keyLike);
   const bass = bassPcOf(resolved.scale);
-  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
+  if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== bass) {
     return null;
   }
-  const kind = kindOfPitchClasses(new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord)), bass);
+  const kind = kindOfPitchClasses(new Set(_chunkYDGMWH43cjs.chordPitchClasses.call(void 0, chord)), bass);
   if (kind === null || !spellsAugmentedSixth(chord, kind, resolved)) {
     return null;
   }
   return kind;
 }
 function augmentedSixthFromPitchClasses(pcs, bassPc, key) {
-  return augmentedSixthOverBass(_chunkS5BKZZGMcjs.assertArray.call(void 0, pcs, "pcs"), bassPc, key);
+  return augmentedSixthOverBass(_chunkS3QELJUEcjs.assertArray.call(void 0, pcs, "pcs"), bassPc, key);
 }
 function augmentedSixthOverBass(pcs, bassPc, keyLike) {
-  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunkYDGMWH43cjs.resolveKey.call(void 0, keyLike);
   const bass = bassPcOf(resolved.scale);
-  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, bassPc) !== bass) {
+  if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, bassPc) !== bass) {
     return null;
   }
-  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkS5BKZZGMcjs.pitchClassOf)), bass);
+  const kind = kindOfPitchClasses(new Set(pcs.map(_chunkS3QELJUEcjs.pitchClassOf)), bass);
   return kind === null ? null : augmentedSixthOn(kind, resolved);
 }
 function spellAugmentedSixth(kind, tonic) {
-  return spelledFromTonic(kind, _chunkS5BKZZGMcjs.toNoteData.call(void 0, tonic));
+  return spelledFromTonic(kind, _chunkS3QELJUEcjs.toNoteData.call(void 0, tonic));
 }
 function spelledFromTonic(kind, tonic) {
-  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));
+  const checked = _chunkS3QELJUEcjs.assertOneOf.call(void 0, kind, KINDS, "augmented sixth kind");
+  const bass = _chunkS3QELJUEcjs.transposeByInterval.call(void 0, tonic, BASS_INTERVAL);
+  return SPELLED_ABOVE_BASS[checked].map((interval) => _chunkS3QELJUEcjs.transposeByInterval.call(void 0, bass, interval));
 }
 function augmentedSixthFromSymbol(symbol, key) {
   const kind = KIND_BY_SYMBOL.get(symbol);
@@ -737,11 +757,11 @@ var SUBDOMINANT_DEGREE = 4;
 var DOMINANT_DEGREE = 5;
 var SUBMEDIANT_DEGREE = 6;
 function degreeOffset(degreeNumber, key) {
-  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, degreeRootPc(degreeNumber, romanReference(key)) - key.rootPc);
 }
 function thirdBelongsToKey(chord, key) {
   return chord.intervals.some(
-    (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)
+    (interval) => (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, interval) === 3 || _chunkS3QELJUEcjs.pitchClassOf.call(void 0, interval) === 4) && _chunkYDGMWH43cjs.isScaleTone.call(void 0, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc + interval), key)
   );
 }
 function deceptiveTargets(key) {
@@ -753,25 +773,25 @@ function deceptiveTargets(key) {
   return borrowed === submediant ? [submediant] : [submediant, borrowed];
 }
 function restsOnDominant(to, key) {
-  if (_chunk3R3QVKY5cjs.hasMajorThird.call(void 0, to) || _chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, to, key)) {
+  if (_chunkYDGMWH43cjs.hasMajorThird.call(void 0, to) || _chunkYDGMWH43cjs.isDominantChordOf.call(void 0, to, key)) {
     return true;
   }
-  if (_chunk3R3QVKY5cjs.scaleSystemOf.call(void 0, key) !== "modal") {
+  if (_chunkYDGMWH43cjs.scaleSystemOf.call(void 0, key) !== "modal") {
     return false;
   }
-  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);
+  const dominantPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc + degreeOffset(DOMINANT_DEGREE, key));
+  const leadingToneDominant = _chunkYDGMWH43cjs.isScaleTone.call(void 0, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, dominantPc + 4), key);
   return !leadingToneDominant && thirdBelongsToKey(to, key);
 }
 function isTonicSixFour(chord, key) {
-  if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) !== 0 || chord.bassPc === void 0) {
+  if (_chunkS3QELJUEcjs.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) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === 7);
-  return isTriad && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
+  const isTriad = chord.intervals.length === 3 && chord.intervals.some((interval) => _chunkS3QELJUEcjs.pitchClassOf.call(void 0, interval) === 7);
+  return isTriad && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.bassPc - chord.rootPc) === 7;
 }
 function isCadentialSixFour(chord, next, key) {
-  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)));
+  return isTonicSixFour(chord, key) && _chunkYDGMWH43cjs.isDominantChordOf.call(void 0, next, key) && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(next.bassPc, () => ( next.rootPc)));
 }
 function outerPitches(voicing) {
   let bass;
@@ -790,7 +810,7 @@ function outerPitches(voicing) {
   return { bass, soprano };
 }
 function bassPcOf2(chord, voicedBass) {
-  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(voicedBass, () => ( chord.bassPc)), () => ( chord.rootPc)));
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(_nullishCoalesce(voicedBass, () => ( chord.bassPc)), () => ( chord.rootPc)));
 }
 var CADENCE_TYPES = Object.freeze([
   "authentic",
@@ -801,17 +821,17 @@ var CADENCE_TYPES = Object.freeze([
   "modal"
 ]);
 function cadenceType(from, to, key, fromBassPc, toBassPc) {
-  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) {
+  const tonic = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc);
+  const fromOffset = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, from.rootPc - tonic);
+  const toOffset = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, to.rootPc - tonic);
+  const dominant = _chunkYDGMWH43cjs.isDominantChordOf.call(void 0, from, key);
+  if ((dominant || _chunkYDGMWH43cjs.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 && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, from)) {
+  if (fromOffset === 10 && toOffset === 0 && _chunkYDGMWH43cjs.hasMajorThird.call(void 0, from)) {
     return "modal";
   }
   if (dominant && deceptiveTargets(key).includes(toOffset)) {
@@ -819,7 +839,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 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, toBassPc - tonic) === 7) {
+  if (half && isMinorScale(key) && fromOffset === 5 && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, fromBassPc - tonic) === 8 && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, toBassPc - tonic) === 7) {
     return "phrygian";
   }
   return half ? "half" : null;
@@ -921,12 +941,12 @@ function cadenceAlternatives(facts) {
   return out;
 }
 function detectCadence(from, to, key, opts = {}) {
-  const { approach, ...rest } = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const { approach, ...rest } = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
   return cadenceBetween(
-    _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) }
+    _chunkYDGMWH43cjs.toChordData.call(void 0, from),
+    _chunkYDGMWH43cjs.toChordData.call(void 0, to),
+    _chunkYDGMWH43cjs.toKeyScale.call(void 0, key),
+    approach === void 0 ? rest : { ...rest, approach: _chunkYDGMWH43cjs.toChordData.call(void 0, approach) }
   );
 }
 function cadenceBetween(from, to, key, opts = {}) {
@@ -935,11 +955,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 === _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 toRootPosition = toBassPc === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, to.rootPc);
+  const rootPosition = fromBassPc === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, from.rootPc) && toRootPosition;
+  const soprano = toOuter.soprano === void 0 ? null : _chunkYDGMWH43cjs.chordToneRole.call(void 0, toOuter.soprano, to);
   const type = cadenceType(from, to, key, fromBassPc, toBassPc);
-  const leadingTone = _chunk3R3QVKY5cjs.isLeadingToneChordOf.call(void 0, from, key);
+  const leadingTone = _chunkYDGMWH43cjs.isLeadingToneChordOf.call(void 0, from, key);
   const facts = {
     type,
     strength: type === "authentic" ? authenticStrength(leadingTone, rootPosition, toOuter.soprano !== void 0, soprano) : null,
@@ -948,10 +968,10 @@ function cadenceBetween(from, to, key, opts = {}) {
     // promised is the one it does not get.
     evaded: type === "authentic" && !toRootPosition,
     leadingTone,
-    fromOffset: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
-    toOffset: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
+    fromOffset: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, from.rootPc - key.rootPc),
+    toOffset: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc),
     minor: isMinorScale(key),
-    onFifthDegree: _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, to.rootPc - key.rootPc) === degreeOffset(DOMINANT_DEGREE, key),
+    onFifthDegree: _chunkS3QELJUEcjs.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)
   };
@@ -972,53 +992,45 @@ function cadenceBetween(from, to, key, opts = {}) {
 // src/analyze/functional/borrowed.ts
 function isMinorScaleAlteration(chord, key) {
   if (!isMinorScale(key)) return false;
-  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 });
+  const alteredKey = { rootPc: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYDGMWH43cjs.HARMONIC_MINOR_MASK };
+  if (_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, alteredKey)) return true;
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 11 && _chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, { rootPc: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc), modeMask12: _chunkYDGMWH43cjs.MELODIC_MINOR_MASK });
 }
 function isBorrowed(chord, key) {
-  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, key)) {
     return false;
   }
-  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+  if (_chunkYDGMWH43cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return true;
   }
   if (isMinorScaleAlteration(chord, key)) {
     return false;
   }
-  return _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, parallelScale(key));
+  return _chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, parallelScale(key));
 }
 function borrowedSourceOf(chord, key) {
-  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, key)) {
     return null;
   }
-  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) return "neapolitan";
+  if (_chunkYDGMWH43cjs.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(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+  return isBorrowed(_chunkYDGMWH43cjs.toChordData.call(void 0, chord), _chunkYDGMWH43cjs.toKeyScale.call(void 0, key));
 }
 function borrowedSource(chord, key) {
-  return borrowedSourceOf(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+  return borrowedSourceOf(_chunkYDGMWH43cjs.toChordData.call(void 0, chord), _chunkYDGMWH43cjs.toKeyScale.call(void 0, key));
 }
 
 // src/analyze/functional/tonicization.ts
 function isTonicizableRoot(rootPc, key) {
-  return _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key).some((degree) => degree.rootPc === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc));
-}
-function appliedTarget(chord, key) {
-  const dominant = _chunk3R3QVKY5cjs.hasDominantSonority.call(void 0, chord);
-  const leadingTone = _chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(chord.quality);
-  if (!dominant && !leadingTone) {
-    return null;
-  }
-  return _chunk3R3QVKY5cjs.appliedDominantTarget.call(void 0, chord.rootPc + (dominant ? 5 : 1), key);
+  return _chunkYDGMWH43cjs.tonicizableDegrees.call(void 0, key).some((degree) => degree.rootPc === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc));
 }
 function isAppliedDominant(chord, key) {
-  if (_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+  if (_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, key)) {
     return false;
   }
   const source = borrowedSourceOf(chord, key);
@@ -1028,10 +1040,10 @@ function isAppliedDominant(chord, key) {
   return pointsAtTonicizableDegree(chord, key);
 }
 function pointsAtTonicizableDegree(chord, key) {
-  if (appliedTarget(chord, key) !== null) {
+  if (_chunkYDGMWH43cjs.appliedChordTarget.call(void 0, chord, key) !== null) {
     return true;
   }
-  return _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord) && isTonicizableRoot(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - 1), key);
+  return _chunkYDGMWH43cjs.soundsDominantSeventh.call(void 0, chord) && isTonicizableRoot(_chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - 1), key);
 }
 
 // src/analyze/functional/roman.ts
@@ -1071,7 +1083,8 @@ function seventhQuality(base, halfDim) {
   }
   return base === "maj" ? "dom7" : "min7";
 }
-var INVERSION_FIGURES = /* @__PURE__ */ new Set(["6", "64", "65", "43", "42", "2", "7"]);
+var INVERSION_FIGURE_LIST = ["6", "64", "65", "43", "42", "2", "7"];
+var INVERSION_FIGURES = new Set(INVERSION_FIGURE_LIST);
 var ROMAN_STYLE = {
   maj: { lower: false, suffix: "" },
   min: { lower: true, suffix: "" },
@@ -1143,36 +1156,50 @@ function parseInversion(figures) {
   }
   return { inversion: 0, seventh: false };
 }
-function parseSimpleRoman(text, key) {
+function numeralRootSpelling(tonic, degreeNumber, rootPc) {
+  const spelling = _chunkYDGMWH43cjs.spellingAbove.call(void 0, tonic, degreeNumber - 1, rootPc);
+  return Math.abs(spelling.alter) <= 2 ? spelling : void 0;
+}
+function parseSimpleRoman(text, resolved) {
+  const key = resolved.scale;
   const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
   if (!match) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
   }
   const glyphText = _nullishCoalesce(match[2], () => ( ""));
   if (glyphText !== glyphText.toUpperCase() && glyphText !== glyphText.toLowerCase()) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Roman numeral must use one case: ${text}`);
+    throw new (0, _chunkS3QELJUEcjs.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, _chunkS5BKZZGMcjs.InvalidInputError)(`Invalid Roman numeral: ${text}`);
+    throw new (0, _chunkS3QELJUEcjs.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 = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 
+  const diatonicRootPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, 
     degreeRootPc(degreeNumber, frame) + (redundantFlat ? 0 : accidental)
   );
-  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 rootForQuality = (quality2) => accidental === 0 && degreeNumber === 7 && loweredDegrees(frame).has(7) && _chunkYDGMWH43cjs.LEADING_TONE_QUALITIES.has(quality2) ? _chunkS3QELJUEcjs.pitchClassOf.call(void 0, diatonicRootPc + 1) : diatonicRootPc;
   const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
+  const parsed = (quality2, inversion2) => {
+    const rootPc = rootForQuality(quality2);
+    return {
+      rootPc,
+      rootSpelling: numeralRootSpelling(resolved.tonic, degreeNumber, rootPc),
+      quality: quality2,
+      inversion: inversion2
+    };
+  };
   if (canonical !== void 0) {
-    return { rootPc: rootForQuality(canonical), quality: canonical, inversion: 0 };
+    return parsed(canonical, 0);
   }
   const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
   if (!parsedSuffix) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
   }
   const qualityMarker = _nullishCoalesce(parsedSuffix[1], () => ( ""));
   const isDim = qualityMarker === "o" || qualityMarker === "\xB0" || qualityMarker === "dim";
@@ -1181,7 +1208,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, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
       `Unsupported figured-bass or extension "${figures}" in Roman numeral: ${text}`
     );
   }
@@ -1207,27 +1234,30 @@ function parseSimpleRoman(text, key) {
   } else {
     quality = base;
   }
-  return { rootPc: rootForQuality(quality), quality, inversion };
+  return parsed(quality, inversion);
 }
 var NEAPOLITAN_SIXTH = "N6";
 function chromaticSymbolChord(text, key) {
   if (text === NEAPOLITAN_SIXTH) {
-    const rootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.scale.rootPc + 1);
-    return _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "maj", _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc + 4));
+    const rootPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.scale.rootPc + 1);
+    return _chunkYDGMWH43cjs.makeSpelledChord.call(void 0, rootPc, "maj", {
+      bassPc: _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc + 4),
+      rootSpelling: numeralRootSpelling(key.tonic, 2, rootPc)
+    });
   }
   return augmentedSixthFromSymbol(text, key);
 }
-function tonicizedKey(targetRoot, key) {
-  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 tonicizedKey(targetRoot, key, written) {
+  return _chunkYDGMWH43cjs.resolveKey.call(void 0, {
+    scale: _chunkYDGMWH43cjs.majorKey.call(void 0, targetRoot),
+    tonic: _nullishCoalesce(written, () => ( _chunkYDGMWH43cjs.spellPitchClass.call(void 0, targetRoot, key.tonic, key.scale)))
   });
 }
 function augmentedSixthTarget(chord, key) {
-  if (_chunk3R3QVKY5cjs.chordToneSpellings.call(void 0, chord) === void 0) {
+  if (_chunkYDGMWH43cjs.chordToneSpellings.call(void 0, chord) === void 0) {
     return null;
   }
-  for (const degree of _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key.scale)) {
+  for (const degree of _chunkYDGMWH43cjs.tonicizableDegrees.call(void 0, key.scale)) {
     if (degree.degreeNumber === 1) {
       continue;
     }
@@ -1238,60 +1268,64 @@ function augmentedSixthTarget(chord, key) {
   return null;
 }
 function chordFromParsed(parsed) {
-  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, parsed.rootPc, parsed.quality);
-  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, parsed.rootPc + (_nullishCoalesce(chord.intervals[parsed.inversion], () => ( 0))));
-  }
-  return chord;
+  const bassInterval = parsed.inversion > 0 ? _chunkYDGMWH43cjs.QUALITY_INTERVALS[parsed.quality][parsed.inversion] : void 0;
+  return _chunkYDGMWH43cjs.makeSpelledChord.call(void 0, parsed.rootPc, parsed.quality, {
+    bassPc: bassInterval === void 0 ? void 0 : _chunkS3QELJUEcjs.pitchClassOf.call(void 0, parsed.rootPc + bassInterval),
+    rootSpelling: parsed.rootSpelling
+  });
 }
 function romanToChord(text, key) {
-  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
-  const scale = resolved.scale;
+  const resolved = _chunkYDGMWH43cjs.resolveKey.call(void 0, key);
+  if (typeof text !== "string") {
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `Roman numeral must be a string; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, text)}`
+    );
+  }
   const trimmed = text.trim().replace(/(\d)\/(?=\d)/g, "$1");
   const slash = trimmed.indexOf("/");
   if (slash >= 0) {
     const applied = trimmed.slice(0, slash);
     const target = trimmed.slice(slash + 1);
-    const targetRoot = parseSimpleRoman(target, scale).rootPc;
-    const localKey = tonicizedKey(targetRoot, resolved);
-    return _nullishCoalesce(chromaticSymbolChord(applied, localKey), () => ( chordFromParsed(parseSimpleRoman(applied, localKey.scale))));
+    const targetNumeral = parseSimpleRoman(target, resolved);
+    const localKey = tonicizedKey(targetNumeral.rootPc, resolved, targetNumeral.rootSpelling);
+    return _nullishCoalesce(chromaticSymbolChord(applied, localKey), () => ( chordFromParsed(parseSimpleRoman(applied, localKey))));
   }
-  return _nullishCoalesce(chromaticSymbolChord(trimmed, resolved), () => ( chordFromParsed(parseSimpleRoman(trimmed, scale))));
+  return _nullishCoalesce(chromaticSymbolChord(trimmed, resolved), () => ( chordFromParsed(parseSimpleRoman(trimmed, resolved))));
 }
 function romanStyle(quality) {
   return ROMAN_STYLE[quality];
 }
-function romanSpelling(rootPc, key) {
-  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
-  const diatonic = tones.indexOf(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc));
+function romanSpelling(rootPc, key, quality) {
+  const tones = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, romanReference(key));
+  const diatonic = tones.indexOf(_chunkS3QELJUEcjs.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) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
+    if (lowered.has(i + 1) && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
-  for (let i = 0; i < tones.length; i += 1) {
+  for (let i = 0; i < tones.length && !_chunkYDGMWH43cjs.LEADING_TONE_QUALITIES.has(quality); i += 1) {
     const degreeNumber2 = i + 1;
     if (degreeNumber2 === 1 || degreeNumber2 === 5) {
       continue;
     }
-    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
+    if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) - 1) === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: degreeNumber2, accidental: "b" };
     }
   }
   for (let i = 0; i < tones.length; i += 1) {
-    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc)) {
+    if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, (_nullishCoalesce(tones[i], () => ( 0))) + 1) === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc)) {
       return { degreeNumber: i + 1, accidental: "#" };
     }
   }
-  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
+  const [degreeNumber, accidental] = _nullishCoalesce(OFFSET_SPELLING[_chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc - key.rootPc)], () => ( [1, ""]));
   return { degreeNumber, accidental };
 }
 function seventhDegreeAccidental(accidental, degreeNumber, quality, key) {
-  if (degreeNumber !== 7 || !_chunk3R3QVKY5cjs.LEADING_TONE_QUALITIES.has(quality) || !loweredDegrees(romanReference(key)).has(7)) {
+  if (degreeNumber !== 7 || !_chunkYDGMWH43cjs.LEADING_TONE_QUALITIES.has(quality) || !loweredDegrees(romanReference(key)).has(7)) {
     return accidental;
   }
   if (accidental === "#") {
@@ -1319,8 +1353,9 @@ function baseMarker(quality) {
 }
 var TRIAD_FIGURES = { 1: "6", 2: "64" };
 var SEVENTH_FIGURES = { 1: "65", 2: "43", 3: "42" };
-var TRIAD_FIGURE_QUALITIES = /* @__PURE__ */ new Set(["maj", "min", "dim", "aug"]);
-var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
+var TRIAD_FIGURE_QUALITY_NAMES = ["maj", "min", "dim", "aug"];
+var TRIAD_FIGURE_QUALITIES = new Set(TRIAD_FIGURE_QUALITY_NAMES);
+var SEVENTH_FIGURE_QUALITY_NAMES = [
   "maj7",
   "min7",
   "dom7",
@@ -1329,50 +1364,90 @@ var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
   "minMaj7",
   "aug7",
   "augMaj7"
-]);
+];
+var SEVENTH_FIGURE_QUALITIES = new Set(SEVENTH_FIGURE_QUALITY_NAMES);
 function numeralFor(degreeNumber, lower) {
   const glyph = ROMAN[degreeNumber - 1];
   if (glyph === void 0) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`no Roman numeral for scale degree ${degreeNumber}`);
   }
   return lower ? glyph.toLowerCase() : glyph;
 }
 function chordToRoman(chord, key, opts = {}) {
-  return renderRoman(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), key, _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts")).roman;
+  return renderRoman(_chunkYDGMWH43cjs.toChordData.call(void 0, chord), key, _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts")).roman;
+}
+function readNumeral(chord, resolved, applied) {
+  const key = resolved.scale;
+  const written = writtenRoot(chord);
+  if (applied) {
+    const target = _nullishCoalesce(augmentedSixthTarget(chord, resolved), () => ( (isAppliedDominant(chord, key) ? _chunkYDGMWH43cjs.appliedChordTarget.call(void 0, chord, key) : null)));
+    if (target !== null && leadsByLetter(chord, written, target, resolved)) {
+      return { kind: "applied", target };
+    }
+  }
+  return {
+    kind: "root",
+    ..._nullishCoalesce(writtenSpelling(chord.rootPc, written, resolved), () => ( romanSpelling(chord.rootPc, key, chord.quality)))
+  };
+}
+function writtenRoot(chord) {
+  const hint = chord.rootSpelling;
+  if (typeof hint !== "object" || hint === null || !Number.isInteger(hint.letter) || hint.letter < 0 || hint.letter > 6 || !Number.isInteger(hint.alter) || _chunkS3QELJUEcjs.pitchClassOf.call(void 0, _chunkS3QELJUEcjs.naturalPitchClassOf.call(void 0, hint.letter) + hint.alter) !== _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc)) {
+    return void 0;
+  }
+  return hint;
+}
+function writtenSpelling(rootPc, written, resolved) {
+  const tones = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, romanReference(resolved.scale));
+  if (written === void 0 || tones.includes(_chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc))) {
+    return void 0;
+  }
+  const degreeNumber = _chunkS3QELJUEcjs.diatonicLetterOf.call(void 0, written.letter - resolved.tonic.letter) + 1;
+  const degreePc = tones[degreeNumber - 1];
+  if (degreePc === void 0) {
+    return void 0;
+  }
+  const offset = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, rootPc - degreePc + 6) - 6;
+  return Math.abs(offset) > 1 ? void 0 : { degreeNumber, accidental: offset < 0 ? "b" : offset > 0 ? "#" : "" };
+}
+function leadsByLetter(chord, written, target, resolved) {
+  if (written === void 0 || !_chunkYDGMWH43cjs.LEADING_TONE_QUALITIES.has(chord.quality)) {
+    return true;
+  }
+  const targetLetter = _chunkYDGMWH43cjs.spellPitchClass.call(void 0, target.rootPc, resolved.tonic, resolved.scale).letter;
+  return _chunkS3QELJUEcjs.diatonicLetterOf.call(void 0, targetLetter - written.letter) === 1;
 }
 function renderRoman(chord, keyLike, opts) {
-  const resolved = _chunk3R3QVKY5cjs.resolveKey.call(void 0, keyLike);
+  const resolved = _chunkYDGMWH43cjs.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), () => ( (_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);
-      return {
-        roman: `${local}/${numeral}`,
-        derivation: { kind: "applied", target: numeral }
-      };
-    }
+  const reading = readNumeral(chord, resolved, opts.applied === true);
+  if (reading.kind === "applied") {
+    const local = renderRoman(chord, tonicizedKey(reading.target.rootPc, resolved), {}).roman;
+    const numeral = numeralFor(reading.target.degreeNumber, reading.target.lower);
+    return {
+      roman: `${local}/${numeral}`,
+      derivation: { kind: "applied", target: numeral }
+    };
   }
-  const { degreeNumber, accidental: spelledAccidental } = romanSpelling(chord.rootPc, key);
+  const { degreeNumber, accidental: spelledAccidental } = reading;
   const { lower, suffix } = romanStyle(chord.quality);
   const cased = numeralFor(degreeNumber, lower);
   const accidental = seventhDegreeAccidental(spelledAccidental, degreeNumber, chord.quality, key);
   let inversion = 0;
   let bass = "root";
   if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === chord.bassPc);
+    const idx = chord.intervals.findIndex((iv) => _chunkS3QELJUEcjs.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 && _chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+  if (opts.neapolitan === true && inversion === 1 && _chunkYDGMWH43cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return { roman: NEAPOLITAN_SIXTH, derivation: { kind: "neapolitan" } };
   }
   if (inversion > 0) {
@@ -1405,7 +1480,15 @@ function renderRoman(chord, keyLike, opts) {
     }
   };
 }
-var DEGREE_NAMES = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh"];
+var DEGREE_NAMES = [
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh"
+];
 function describeDegree(degreeNumber, accidental, literal) {
   const name = _nullishCoalesce(DEGREE_NAMES[degreeNumber - 1], () => ( `${degreeNumber}th`));
   if (accidental !== literal) {
@@ -1471,8 +1554,8 @@ function romanAlternatives(chord, key, opts) {
   return out;
 }
 function explainRoman(chord, key, opts = {}) {
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
-  const data = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunkYDGMWH43cjs.toChordData.call(void 0, chord);
   const { roman, derivation } = renderRoman(data, key, asked);
   return {
     roman,
@@ -1541,27 +1624,28 @@ var MINOR_FUNCTION_BY_OFFSET = [
   // 11 viio
 ];
 function isMinorKey(key) {
-  return isMinorScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+  return isMinorScale(_chunkYDGMWH43cjs.toKeyScale.call(void 0, key));
 }
 function functionOf(chord, key) {
-  return functionWithReason(_chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key)).function;
+  return functionWithReason(_chunkYDGMWH43cjs.toChordData.call(void 0, chord), _chunkYDGMWH43cjs.resolveKey.call(void 0, key)).function;
 }
 function degreeFunction(chord, key) {
   const functions = isMinorScale(key) ? MINOR_FUNCTION_BY_OFFSET : FUNCTION_BY_OFFSET;
-  return _nullishCoalesce(functions[_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
+  return _nullishCoalesce(functions[_chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc)], () => ( "tonic"));
 }
-function functionWithReason(chord, key) {
-  const offset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
-  if (_chunk3R3QVKY5cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
+function functionWithReason(chord, resolved) {
+  const key = resolved.scale;
+  const offset = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc);
+  if (_chunkYDGMWH43cjs.isNeapolitanChordOf.call(void 0, chord, key)) {
     return { function: "subdominant", reason: "neapolitan" };
   }
-  if (augmentedSixthKindOf(chord, key) !== null) {
+  if (augmentedSixthKindOf(chord, resolved) !== null) {
     return { function: "subdominant", reason: "augmentedSixth" };
   }
   if (isAppliedDominant(chord, key)) {
     return { function: "dominant", reason: "applied" };
   }
-  if (!isMinorScale(key) && !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key) && _chunk3R3QVKY5cjs.hasMajorThird.call(void 0, chord) && (offset === 8 || offset === 10)) {
+  if (!isMinorScale(key) && !_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, key) && _chunkYDGMWH43cjs.hasMajorThird.call(void 0, chord) && (offset === 8 || offset === 10)) {
     return { function: "subdominant", reason: "flatSideMajor" };
   }
   return { function: degreeFunction(chord, key), reason: "degree" };
@@ -1581,10 +1665,11 @@ function describeChord(fn, reason, roman, source) {
   const head = reason === "degree" ? `${capitalize(fn)}: ${roman} takes the ${fn} function of its degree in the key` : `${capitalize(fn)}: ${roman} is ${FUNCTION_REASON_PHRASE[reason]}`;
   return source === null || reason === "neapolitan" ? head : `${head}, ${BORROWED_SOURCE_PHRASE[source]}`;
 }
-function functionAlternatives(chord, key, reason, accepted) {
+function functionAlternatives(chord, resolved, reason, accepted) {
+  const key = resolved.scale;
   const out = [];
   if (reason === "degree") {
-    if (pointsAtTonicizableDegree(chord, key) && _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, key)) {
+    if (pointsAtTonicizableDegree(chord, key) && _chunkYDGMWH43cjs.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"
@@ -1599,7 +1684,7 @@ function functionAlternatives(chord, key, reason, accepted) {
       });
     }
   }
-  if (augmentedSixthKindOf(chord, key) === "german") {
+  if (augmentedSixthKindOf(chord, resolved) === "german") {
     out.push({
       label: "tritone substitute",
       reason: "The German sixth sounds a dominant seventh, but the lowered submediant under it fixes the reading as an augmented sixth"
@@ -1608,18 +1693,18 @@ function functionAlternatives(chord, key, reason, accepted) {
   return out;
 }
 function isDiatonic(chord, key) {
-  return _chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, _chunk3R3QVKY5cjs.toChordData.call(void 0, chord), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+  return _chunkYDGMWH43cjs.isDiatonicChord.call(void 0, _chunkYDGMWH43cjs.toChordData.call(void 0, chord), _chunkYDGMWH43cjs.toKeyScale.call(void 0, key));
 }
 function parallelKey(key) {
-  return parallelScale(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, key));
+  return parallelScale(_chunkYDGMWH43cjs.toKeyScale.call(void 0, key));
 }
 function analyzeChord(chord, key, opts = {}) {
-  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;
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
+  const data = _chunkYDGMWH43cjs.toChordData.call(void 0, chord);
+  const resolved = _chunkYDGMWH43cjs.resolveKey.call(void 0, key);
+  const source = borrowedSourceOf(data, resolved.scale);
+  const { function: fn, reason } = functionWithReason(data, resolved);
+  const roman = renderRoman(data, resolved, asked).roman;
   return {
     function: fn,
     borrowed: source !== null,
@@ -1627,43 +1712,41 @@ function analyzeChord(chord, key, opts = {}) {
     roman,
     rationale: describeChord(fn, reason, roman, source),
     alternatives: asked.alternatives === true ? [
-      ...functionAlternatives(data, scale, reason, fn),
-      ...romanAlternatives(data, scale, asked)
+      ...functionAlternatives(data, resolved, reason, fn),
+      ...romanAlternatives(data, resolved, asked)
     ] : []
   };
 }
 function secondaryDominant(targetDegree, key) {
-  const scale = _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 resolved = _chunkYDGMWH43cjs.resolveKey.call(void 0, key);
+  const scale = resolved.scale;
+  const degreeCount = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, scale).length;
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, targetDegree, "targetDegree", 1, degreeCount);
   const targetRoot = degreeRootPc(targetDegree, scale);
-  return _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7");
+  const rootSpelling = _chunkS3QELJUEcjs.transposeByInterval.call(void 0, _chunkYDGMWH43cjs.keySpelling.call(void 0, targetRoot, resolved), "P5");
+  return _chunkYDGMWH43cjs.makeSpelledChord.call(void 0, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, targetRoot + 7), "dom7", { rootSpelling });
 }
 function secondaryDominantOf(target) {
-  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 = _chunkS5BKZZGMcjs.transposeNote.call(void 0, data.rootSpelling, 7);
-    dominant.rootSpelling = { letter: moved.letter, alter: moved.alter };
-  }
-  return dominant;
+  const data = _chunkYDGMWH43cjs.toChordData.call(void 0, target);
+  _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, data.rootPc, "target chord rootPc");
+  const rootSpelling = data.rootSpelling === void 0 ? void 0 : _chunkS3QELJUEcjs.transposeNote.call(void 0, data.rootSpelling, 7);
+  return _chunkYDGMWH43cjs.makeSpelledChord.call(void 0, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, data.rootPc + 7), "dom7", { rootSpelling });
 }
 
 // src/analyze/functional/pivot.ts
 var HEPTATONIC_DEGREES = 7;
 function pivotChords(from, to) {
-  return pivotsBetween(_chunk3R3QVKY5cjs.toKeyScale.call(void 0, from), _chunk3R3QVKY5cjs.toKeyScale.call(void 0, to));
+  return pivotsBetween(_chunkYDGMWH43cjs.resolveKey.call(void 0, from), _chunkYDGMWH43cjs.resolveKey.call(void 0, to));
 }
 function pivotsBetween(from, to) {
-  if (_chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, from).length !== HEPTATONIC_DEGREES) {
+  if (_chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, from.scale).length !== HEPTATONIC_DEGREES) {
     return [];
   }
   const pivots = [];
   const seen = /* @__PURE__ */ new Set();
   for (let degree = 1; degree <= HEPTATONIC_DEGREES; degree += 1) {
     const chord = stackedTriad(degree, from);
-    if (chord === null || !_chunk3R3QVKY5cjs.isDiatonicChord.call(void 0, chord, to)) {
+    if (chord === null || !_chunkYDGMWH43cjs.isDiatonicChord.call(void 0, chord, to.scale)) {
       continue;
     }
     const identity = `${chord.rootPc}:${chord.quality}`;
@@ -1681,9 +1764,9 @@ function pivotsBetween(from, to) {
 }
 function stackedTriad(degree, key) {
   try {
-    return _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key);
+    return _chunkYDGMWH43cjs.diatonicTriad.call(void 0, degree, key);
   } catch (error) {
-    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
+    if (error instanceof _chunkS3QELJUEcjs.InvalidInputError) {
       return null;
     }
     throw error;
@@ -1692,11 +1775,11 @@ 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 firstBar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, startBeat, meter);
+  const lastBar = _chunkS3QELJUEcjs.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);
+    const barStart = _chunkS3QELJUEcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
+    const barLength = _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, barStart, meter);
     return barLength > 0 ? (beat - barStart) / barLength : 0;
   };
   return lastBar - firstBar + partOf(endBeat, lastBar) - partOf(startBeat, firstBar);
@@ -1714,35 +1797,43 @@ function firstSoundingBeat(notes, fallback = 0) {
   }
   return Number.isFinite(first) ? first : fallback;
 }
+function resolveSpanEnd(totalBeats, startBeat, soundingEnd, name) {
+  const given = _nullishCoalesce(totalBeats, () => ( null));
+  if (given === null) {
+    return Math.max(startBeat, soundingEnd);
+  }
+  _chunkS3QELJUEcjs.assertRange.call(void 0, given, Math.min(0, startBeat), Number.MAX_SAFE_INTEGER, name);
+  return Math.max(startBeat, given);
+}
 function lastBarOf(meter, spanStart, spanEnd) {
-  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) {
+  const firstBar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, spanStart, meter);
+  const bar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, Math.max(spanStart, spanEnd), meter);
+  if (bar > firstBar && _chunkS3QELJUEcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter) >= spanEnd - _chunkS3QELJUEcjs.BEAT_EPS) {
     return bar - 1;
   }
   return bar;
 }
 function sliceBars(notes, meter, spanStart, spanEnd, budget) {
-  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, spanStart, meter);
+  const firstBar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, spanStart, meter);
   const lastBar = lastBarOf(meter, spanStart, spanEnd);
   const barCount = lastBar - firstBar + 1;
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, barCount, "form bars", budget);
+  _chunkS3QELJUEcjs.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, _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));
+    const from = Math.max(firstBar, _chunkS3QELJUEcjs.barIndexAt.call(void 0, note.startBeat, meter));
+    const to = Math.min(lastBar, _chunkS3QELJUEcjs.barIndexAt.call(void 0, Math.max(note.startBeat, noteEnd - _chunkS3QELJUEcjs.BEAT_EPS), meter));
     memberships += Math.max(0, to - from + 1);
-    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, "form note-to-bar memberships", budget);
+    _chunkS3QELJUEcjs.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 = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
-    const endBeat = _chunkS5BKZZGMcjs.barPositionToBeat.call(void 0, { bar: bar + 1, beat: 0 }, meter);
+    const startBeat = _chunkS3QELJUEcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
+    const endBeat = _chunkS3QELJUEcjs.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 });
@@ -1760,10 +1851,10 @@ function weightSimilarity(a, b) {
     normA += x * x;
     normB += y * y;
   }
-  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS && normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+  if (normA <= _chunkS3QELJUEcjs.BEAT_EPS && normB <= _chunkS3QELJUEcjs.BEAT_EPS) {
     return 1;
   }
-  if (normA <= _chunkS5BKZZGMcjs.BEAT_EPS || normB <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+  if (normA <= _chunkS3QELJUEcjs.BEAT_EPS || normB <= _chunkS3QELJUEcjs.BEAT_EPS) {
     return 0;
   }
   return clamp01(dot / Math.sqrt(normA * normB));
@@ -1790,13 +1881,23 @@ 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 + _chunkS5BKZZGMcjs.BEAT_EPS) * slotBeats, startBeat };
+  return { origin: Math.floor(startBeat / slotBeats + _chunkS3QELJUEcjs.BEAT_EPS) * slotBeats, startBeat };
 }
 function gridForNotes(notes, slotBeats) {
   return gridOriginOf(firstSoundingBeat(notes), slotBeats);
 }
+function latestSoundingEnd(notes, fallback = 0) {
+  if (notes.length === 0) {
+    return fallback;
+  }
+  let end = Number.NEGATIVE_INFINITY;
+  for (const note of notes) {
+    end = Math.max(end, note.startBeat + note.durationBeat);
+  }
+  return end;
+}
 function barGridStart(firstOnset, meter) {
-  return gridOriginOf(firstOnset, _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, firstOnset, meter)).startBeat;
+  return gridOriginOf(firstOnset, _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, firstOnset, meter)).startBeat;
 }
 
 // src/analyze/keys/index.ts
@@ -1816,13 +1917,13 @@ var FIFTHS_DISTANCE_COST = 0.18;
 var KEY_CANDIDATES = (() => {
   const candidates = [];
   for (let rootPc = 0; rootPc < 12; rootPc += 1) {
-    candidates.push({ key: _chunk3R3QVKY5cjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
-    candidates.push({ key: _chunk3R3QVKY5cjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
+    candidates.push({ key: _chunkYDGMWH43cjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
+    candidates.push({ key: _chunkYDGMWH43cjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
   }
   return candidates;
 })();
 function fifthsOf(rootPc, minor) {
-  const majorRoot = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
+  const majorRoot = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
   const raw = majorRoot * 7 % 12;
   return raw > 6 ? raw - 12 : raw;
 }
@@ -1840,9 +1941,9 @@ function chooseKeys(slots, changeCost, meter, budget) {
   if (slots.length === 0) {
     return [];
   }
-  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 back = _chunkS3QELJUEcjs.allocateChoiceTable.call(void 0, slots.length, count, "key search choices", budget);
+  let costs = _chunkS3QELJUEcjs.allocateCandidateTable.call(void 0, 1, count, "key search costs", budget);
+  let spare = _chunkS3QELJUEcjs.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)));
@@ -1851,7 +1952,7 @@ function chooseKeys(slots, changeCost, meter, budget) {
     const slot = slots[i];
     const previous = costs;
     const next = spare;
-    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, _nullishCoalesce(_optionalChain([slot, 'optionalAccess', _13 => _13.startBeat]), () => ( 0)), meter);
+    const accent = _chunkS3QELJUEcjs.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) {
@@ -1921,7 +2022,7 @@ function enforceMinimumRegion(slots, path, minBeats, budget) {
     return chosen;
   }
   const candidates = KEY_CANDIDATES.length;
-  const totals = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, slots.length, candidates, "key region scores", budget);
+  const totals = _chunkS3QELJUEcjs.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;
@@ -1952,13 +2053,13 @@ function enforceMinimumRegion(slots, path, minBeats, budget) {
       return chosen;
     }
     const length = region.endBeat - region.startBeat;
-    if (region.merged || length >= minBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (region.merged || length >= minBeats - _chunkS3QELJUEcjs.BEAT_EPS) {
       continue;
     }
     const previous = region.previous;
     const next = region.next;
-    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;
+    const before = previous !== void 0 && Math.abs(previous.endBeat - region.startBeat) < _chunkS3QELJUEcjs.BEAT_EPS ? previous : void 0;
+    const after = next !== void 0 && Math.abs(next.startBeat - region.endBeat) < _chunkS3QELJUEcjs.BEAT_EPS ? next : void 0;
     if (before === void 0 && after === void 0) {
       continue;
     }
@@ -2068,7 +2169,7 @@ function withRelations(regions) {
     if (previous === void 0 || current === void 0) {
       continue;
     }
-    const relation = _chunk3R3QVKY5cjs.keyRelationBetween.call(void 0, previous.key, current.key);
+    const relation = _chunkYDGMWH43cjs.keyRelationBetween.call(void 0, previous.key, current.key);
     if (relation !== null && relation !== "same") {
       current.modulation = relation;
     }
@@ -2076,22 +2177,26 @@ function withRelations(regions) {
   return regions;
 }
 function keyTimelineFromNotes(notes, opts = {}) {
-  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "key timeline meters");
-  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
+  const meters = _chunkS3QELJUEcjs.resolveMeters.call(void 0, opts, "key timeline meters");
+  const bar = _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, 0, meters);
   const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  _chunkS3QELJUEcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
   const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  _chunkS3QELJUEcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
   const budget = opts.budget;
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "key timeline notes", { allowNonPositiveDuration: true, budget });
+  _chunkS3QELJUEcjs.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));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
+  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( latestSoundingEnd(sounding)));
+  _chunkS3QELJUEcjs.assertRange.call(void 0, 
+    totalBeats,
+    Math.min(0, firstSoundingBeat(sounding)),
+    Number.MAX_SAFE_INTEGER,
+    "key timeline totalBeats"
+  );
   const slotBeats = Math.min(minKeyBeats, expectedKeyBeats);
   const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
-  const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slotCount * KEY_CANDIDATES.length, "key timeline slots", budget);
+  const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - _chunkS3QELJUEcjs.BEAT_EPS));
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, slotCount * KEY_CANDIDATES.length, "key timeline slots", budget);
   if (slotCount === 0 || sounding.length === 0) {
     return [];
   }
@@ -2129,7 +2234,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 > _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (totalWeight > _chunkS3QELJUEcjs.BEAT_EPS) {
       weightSum += totalWeight;
       soundingSlots += 1;
     }
@@ -2143,14 +2248,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 - _chunkS5BKZZGMcjs.BEAT_EPS) {
+  if (head !== void 0 && next !== void 0 && head.endBeat - Math.max(head.startBeat, musicStart) < slotBeats - _chunkS3QELJUEcjs.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 = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _24 => _24.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+    const key = _chunkYDGMWH43cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _24 => _24.key]), () => ( _chunkYDGMWH43cjs.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) {
@@ -2170,7 +2275,7 @@ function keyTimelineFromNotes(notes, opts = {}) {
     return {
       startBeat,
       endBeat: region.endBeat,
-      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, key),
+      key: _chunkYDGMWH43cjs.resolveKey.call(void 0, key),
       confidence: Math.max(0, correlation)
     };
   });
@@ -2182,20 +2287,20 @@ var TONIC_CREDIT = 0.4;
 var CADENCE_CREDIT = 0.6;
 var CHORD_MODULATION_COST = 0.6;
 function chordFitsKey(chord, candidate) {
-  const tones = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
+  const tones = _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, chord);
   if (tones.length === 0) {
     return 0;
   }
   let inKey = 0;
   for (const pc of tones) {
-    if (_chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, candidate.key)) {
+    if (_chunkYDGMWH43cjs.isScaleTone.call(void 0, pc, candidate.key)) {
       inKey += 1;
     }
   }
   let score = CHORD_TONE_CREDIT * ((inKey - (tones.length - inKey)) / tones.length);
-  const rootDegree = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
+  const rootDegree = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
   if (rootDegree === 7) {
-    if (_chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, chord)) {
+    if (_chunkYDGMWH43cjs.soundsDominantSeventh.call(void 0, chord)) {
       score += DOMINANT_CREDIT;
     } else if (chord.quality === "maj") {
       score += DOMINANT_CREDIT * 0.5;
@@ -2207,25 +2312,26 @@ function chordFitsKey(chord, candidate) {
   return score;
 }
 function detectModulations(chords, opts = {}) {
-  _chunkS5BKZZGMcjs.assertArray.call(void 0, chords, "modulation chord segments");
+  _chunkS3QELJUEcjs.assertArray.call(void 0, chords, "modulation chord segments");
   chords.forEach((segment, index) => {
-    _chunkS5BKZZGMcjs.assertRecord.call(void 0, segment, `modulation chord segments[${index}]`);
+    _chunkS3QELJUEcjs.assertRecord.call(void 0, segment, `modulation chord segments[${index}]`);
   });
-  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "modulation meters");
-  const bar = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, 0, meters);
+  const meters = _chunkS3QELJUEcjs.resolveMeters.call(void 0, opts, "modulation meters");
+  const bar = _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, 0, meters);
   const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  _chunkS3QELJUEcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
   const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+  _chunkS3QELJUEcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, 
     chords.length * KEY_CANDIDATES.length,
     "modulation chord segments",
     opts.budget
   );
   const sorted = [...chords].filter((segment) => segment.endBeat > segment.startBeat).sort((a, b) => a.startBeat - b.startBeat);
-  const lastChordEnd = sorted.reduce((end, segment) => Math.max(end, segment.endBeat), 0);
+  const lastChordEnd = sorted.length === 0 ? 0 : sorted.reduce((end, segment) => Math.max(end, segment.endBeat), Number.NEGATIVE_INFINITY);
   const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastChordEnd));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
+  const lowest = totalBeats < 0 ? Math.min(0, _nullishCoalesce(_optionalChain([sorted, 'access', _27 => _27[0], 'optionalAccess', _28 => _28.startBeat]), () => ( 0))) : 0;
+  _chunkS3QELJUEcjs.assertRange.call(void 0, totalBeats, lowest, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
   const ordered = sorted.map((segment) => ({ ...segment, endBeat: Math.min(segment.endBeat, totalBeats) })).filter((segment) => segment.endBeat > segment.startBeat);
   if (ordered.length === 0) {
     return [];
@@ -2242,20 +2348,20 @@ function detectModulations(chords, opts = {}) {
     };
   });
   for (let i = 1; i < slots.length; i += 1) {
-    const arriving = _optionalChain([ordered, 'access', _27 => _27[i], 'optionalAccess', _28 => _28.chord]);
-    const approaching = _optionalChain([ordered, 'access', _29 => _29[i - 1], 'optionalAccess', _30 => _30.chord]);
+    const arriving = _optionalChain([ordered, 'access', _29 => _29[i], 'optionalAccess', _30 => _30.chord]);
+    const approaching = _optionalChain([ordered, 'access', _31 => _31[i - 1], 'optionalAccess', _32 => _32.chord]);
     const slot = slots[i];
     if (arriving === void 0 || approaching === void 0 || slot === void 0) {
       continue;
     }
-    const isDominantMotion = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && _chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, approaching);
+    const isDominantMotion = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && _chunkYDGMWH43cjs.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 && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
+      if (candidate !== void 0 && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
         slot.scores[c] = (_nullishCoalesce(slot.scores[c], () => ( 0))) + CADENCE_CREDIT * length;
       }
     }
@@ -2269,7 +2375,7 @@ function detectModulations(chords, opts = {}) {
   const profile = resolveKeyProfile(opts.profile);
   const regions = grouped.map((region) => {
     const candidate = KEY_CANDIDATES[region.candidate];
-    const key = _chunk3R3QVKY5cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _31 => _31.key]), () => ( _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+    const key = _chunkYDGMWH43cjs.resolveKey.call(void 0, _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _33 => _33.key]), () => ( _chunkYDGMWH43cjs.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];
@@ -2277,17 +2383,17 @@ function detectModulations(chords, opts = {}) {
         continue;
       }
       const overlap = segment.endBeat - segment.startBeat;
-      if (overlap <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      if (overlap <= _chunkS3QELJUEcjs.BEAT_EPS) {
         continue;
       }
-      for (const pc of _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, segment.chord)) {
+      for (const pc of _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, segment.chord)) {
         weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + overlap;
       }
     }
     const correlation = profileScore(
       weights,
-      _optionalChain([candidate, 'optionalAccess', _32 => _32.minor]) ? profile.minor : profile.major,
-      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _33 => _33.rootPc]), () => ( 0))
+      _optionalChain([candidate, 'optionalAccess', _34 => _34.minor]) ? profile.minor : profile.major,
+      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _35 => _35.rootPc]), () => ( 0))
     );
     return {
       startBeat: region.startBeat,
@@ -2305,7 +2411,7 @@ function detectModulations(chords, opts = {}) {
 var THIRD_SEMITONES = [3, 4];
 var FIFTH_SEMITONES = [6, 7, 8];
 function triadCore(chord) {
-  const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc);
+  const root = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc);
   let third;
   let fifth;
   for (const interval of chord.intervals) {
@@ -2321,10 +2427,10 @@ function triadCore(chord) {
   if (third === void 0 || fifth === void 0) {
     return null;
   }
-  return [root, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + third), _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, root + fifth)].sort((a, b) => a - b);
+  return [root, _chunkS3QELJUEcjs.pitchClassOf.call(void 0, root + third), _chunkS3QELJUEcjs.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))));
+  const byEnd = chords.map((_, index) => index).sort((a, b) => (_nullishCoalesce(_optionalChain([chords, 'access', _36 => _36[a], 'optionalAccess', _37 => _37.endBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([chords, 'access', _38 => _38[b], 'optionalAccess', _39 => _39.endBeat]), () => ( 0))));
   const latest = new Int32Array(byEnd.length);
   let running = 0;
   for (let i = 0; i < byEnd.length; i += 1) {
@@ -2336,7 +2442,7 @@ function lastChordFinishedBy(chords) {
     let high = byEnd.length;
     while (low < high) {
       const mid = low + high >> 1;
-      if ((_nullishCoalesce(_optionalChain([chords, 'access', _38 => _38[_nullishCoalesce(byEnd[mid], () => ( 0))], 'optionalAccess', _39 => _39.endBeat]), () => ( 0))) <= beat) {
+      if ((_nullishCoalesce(_optionalChain([chords, 'access', _40 => _40[_nullishCoalesce(byEnd[mid], () => ( 0))], 'optionalAccess', _41 => _41.endBeat]), () => ( 0))) <= beat) {
         low = mid + 1;
       } else {
         high = mid;
@@ -2359,7 +2465,7 @@ function attachPivots(regions, chords) {
     if (previous === void 0 || current === void 0) {
       continue;
     }
-    const last = finished(current.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS);
+    const last = finished(current.startBeat + _chunkS3QELJUEcjs.BEAT_EPS);
     if (last === void 0) {
       continue;
     }
@@ -2367,9 +2473,9 @@ function attachPivots(regions, chords) {
     if (core === null) {
       continue;
     }
-    const root = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, last.chord.rootPc);
+    const root = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, last.chord.rootPc);
     const pivot = pivotChords(previous.key, current.key).find(
-      (entry) => entry.chord.rootPc === root && sameTones(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, entry.chord), core)
+      (entry) => entry.chord.rootPc === root && sameTones(_chunkYDGMWH43cjs.chordPitchClasses.call(void 0, entry.chord), core)
     );
     if (pivot !== void 0) {
       current.pivot = pivot;
@@ -2383,7 +2489,7 @@ function keyLookup(regions, fallback) {
     let high = regions.length;
     while (low < high) {
       const middle = Math.floor((low + high) / 2);
-      if ((_nullishCoalesce(_optionalChain([regions, 'access', _40 => _40[middle], 'optionalAccess', _41 => _41.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+      if ((_nullishCoalesce(_optionalChain([regions, 'access', _42 => _42[middle], 'optionalAccess', _43 => _43.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
         low = middle + 1;
       } else {
         high = middle;
@@ -2394,12 +2500,12 @@ function keyLookup(regions, fallback) {
   };
 }
 function prevailingKeyOf(regions) {
-  _chunkS5BKZZGMcjs.assertArray.call(void 0, regions, "key regions");
+  _chunkS3QELJUEcjs.assertArray.call(void 0, regions, "key regions");
   const totals = /* @__PURE__ */ new Map();
   for (const [index, given] of regions.entries()) {
-    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 region = _chunkS3QELJUEcjs.assertRecord.call(void 0, given, `key regions[${index}]`);
+    _chunkS3QELJUEcjs.assertRecord.call(void 0, region.key, `key regions[${index}].key`);
+    const id = `${_chunkS3QELJUEcjs.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) {
@@ -2422,13 +2528,13 @@ function prevailingKeyOf(regions) {
 // src/analyze/voice/index.ts
 function keyScaleAt(key) {
   if (typeof key === "function") {
-    return key;
+    return (beat) => _chunkYDGMWH43cjs.toKeyScale.call(void 0, key(beat));
   }
-  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  const scale = _chunkYDGMWH43cjs.toKeyScale.call(void 0, key);
   return () => scale;
 }
 function toVoiceNotes(events) {
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "voice notes", { allowNonPositiveDuration: true });
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, events, "voice notes", { allowNonPositiveDuration: true });
   return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
 }
 function intervalAboveBass(pitch, others, chord) {
@@ -2440,7 +2546,7 @@ function intervalAboveBass(pitch, others, chord) {
     return ((pitch - bass) % 12 + 12) % 12;
   }
   const ref = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
-  return ((_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
+  return ((_chunkS3QELJUEcjs.pitchClassOf.call(void 0, pitch) - _chunkS3QELJUEcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
 }
 var TENSION_DEGREE_BY_INTERVAL = {
   1: 9,
@@ -2451,7 +2557,8 @@ var TENSION_DEGREE_BY_INTERVAL = {
   8: 13,
   9: 13
 };
-var NATURAL_TENSION_INTERVALS = /* @__PURE__ */ new Set([2, 5, 9]);
+var NATURAL_TENSION_INTERVAL_LIST = [2, 5, 9];
+var NATURAL_TENSION_INTERVALS = new Set(NATURAL_TENSION_INTERVAL_LIST);
 function tensionDegree(ic) {
   return TENSION_DEGREE_BY_INTERVAL[ic];
 }
@@ -2459,18 +2566,29 @@ function asSounded(chord) {
   if (chord.bassPc === void 0) {
     return chord;
   }
-  return { ...chord, intervals: [...chord.intervals, _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, chord.bassPc, chord)] };
+  return { ...chord, intervals: [...chord.intervals, _chunkYDGMWH43cjs.intervalAboveRoot.call(void 0, chord.bassPc, chord)] };
 }
 function isStep(a, b) {
   const d = Math.abs(a - b);
   return d === 1 || d === 2;
 }
 var LEAP_SEMITONES = 3;
-function suspensionType(ic, delta) {
+function suspensionType(ic, delta, resolvedIc) {
+  const figure = suspendedFigure(ic, delta);
+  return figure !== null && SUSPENSION_RESOLUTIONS[figure].includes(resolvedIc) ? figure : null;
+}
+var SUSPENSION_RESOLUTIONS = {
+  "sus4-3": [3, 4],
+  "sus6-5": [7],
+  "sus7-6": [8, 9],
+  "sus9-8": [0],
+  "sus2-3": [3, 4]
+};
+function suspendedFigure(ic, delta) {
   if (delta > 0) {
     return ic === 1 || ic === 2 ? "sus2-3" : null;
   }
-  if (ic === 2) {
+  if (ic === 1 || ic === 2) {
     return "sus9-8";
   }
   if (ic === 10 || ic === 11) {
@@ -2484,43 +2602,58 @@ function suspensionType(ic, delta) {
   }
   return null;
 }
+function clashesWithChord(pitch, chord) {
+  if (!_chunkS3QELJUEcjs.isConsonantInterval.call(void 0, intervalAboveBass(pitch, [], chord), true)) {
+    return true;
+  }
+  const tones = chord.intervals.map((interval) => chord.rootPc + interval);
+  if (chord.bassPc !== void 0) {
+    tones.push(chord.bassPc);
+  }
+  return tones.some(
+    (tone) => !_chunkS3QELJUEcjs.isConsonantInterval.call(void 0, ((_chunkS3QELJUEcjs.pitchClassOf.call(void 0, pitch) - tone) % 12 + 12) % 12, false)
+  );
+}
 var STEP_RESOLUTION = 2;
 var NEAREST_CHORD_TONE_REACH = 12;
 function nearestChordTone(pitch, chord, maxDistance) {
   for (let delta = 1; delta <= maxDistance; delta += 1) {
-    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch - delta, chord)) {
+    if (_chunkYDGMWH43cjs.isChordMember.call(void 0, pitch - delta, chord)) {
       return pitch - delta;
     }
-    if (_chunk3R3QVKY5cjs.isChordMember.call(void 0, pitch + delta, chord)) {
+    if (_chunkYDGMWH43cjs.isChordMember.call(void 0, pitch + delta, chord)) {
       return pitch + delta;
     }
   }
   return void 0;
 }
 function analyzeVoice(voice, chordAtBeat2, key, 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");
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
+  _chunkS3QELJUEcjs.assertFunction.call(void 0, chordAtBeat2, "chordAtBeat");
+  _chunkS3QELJUEcjs.assertFunction.call(void 0, otherVoicesAtBeat, "otherVoicesAtBeat");
   const keyAt = keyScaleAt(key);
   const result = [];
+  const sounding = _chunkKMYGRFZ6cjs.soundingIndices.call(void 0, voice);
+  const line = new Map(sounding.map((index, position) => [index, position]));
   for (let i = 0; i < voice.length; i += 1) {
     const note = voice[i];
     if (!note) {
       continue;
     }
-    const prevNote = i > 0 ? voice[i - 1] : void 0;
-    const nextNote = i + 1 < voice.length ? voice[i + 1] : void 0;
-    const prevEnd = prevNote === void 0 ? Number.NEGATIVE_INFINITY : prevNote.startBeat + prevNote.durationBeat;
-    const noteEnd = note.startBeat + note.durationBeat;
-    const prev = prevNote !== void 0 && adjacent(prevEnd, note.startBeat) ? prevNote : void 0;
-    const next = nextNote !== void 0 && adjacent(noteEnd, nextNote.startBeat) ? nextNote : void 0;
+    const position = line.get(i);
+    const prevIndex = position === void 0 ? void 0 : sounding[position - 1];
+    const nextIndex = position === void 0 ? void 0 : sounding[position + 1];
+    const prevNote = prevIndex === void 0 ? void 0 : voice[prevIndex];
+    const nextNote = nextIndex === void 0 ? void 0 : voice[nextIndex];
+    const prev = prevNote !== void 0 && !sameInstant(prevNote.startBeat, note.startBeat) && adjacent(prevNote.startBeat + prevNote.durationBeat, note.startBeat) ? prevNote : void 0;
+    const next = nextNote !== void 0 && !sameInstant(nextNote.startBeat, note.startBeat) && adjacent(note.startBeat + note.durationBeat, nextNote.startBeat) ? nextNote : void 0;
     const chord = chordAtBeat2(note.startBeat);
     const labels = [];
-    const member = _chunk3R3QVKY5cjs.isChordMember.call(void 0, note.pitch, chord);
+    const member = _chunkYDGMWH43cjs.isChordMember.call(void 0, note.pitch, chord);
     let handled = false;
     if (chord && member) {
-      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;
+      const role = _chunkYDGMWH43cjs.chordToneRole.call(void 0, note.pitch, chord);
+      const degree = role === null ? tensionDegree(_chunkYDGMWH43cjs.intervalAboveRoot.call(void 0, note.pitch, chord)) : void 0;
       if (role) {
         labels.push({ kind: "chordTone", role });
         handled = true;
@@ -2528,7 +2661,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         labels.push({ kind: "tension", degree });
         handled = true;
       } else {
-        const bassRole = _chunk3R3QVKY5cjs.chordToneRole.call(void 0, note.pitch, asSounded(chord));
+        const bassRole = _chunkYDGMWH43cjs.chordToneRole.call(void 0, note.pitch, asSounded(chord));
         if (bassRole !== null) {
           labels.push({ kind: "chordTone", role: bassRole });
           handled = true;
@@ -2537,15 +2670,14 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
     }
     if (!handled && chord && prev && next) {
       const prevChord = chordAtBeat2(prev.startBeat);
-      const prepared = prev.pitch === note.pitch && _chunk3R3QVKY5cjs.isChordMember.call(void 0, prev.pitch, prevChord);
+      const prepared = prev.pitch === note.pitch && _chunkYDGMWH43cjs.isChordMember.call(void 0, prev.pitch, prevChord);
       const resolves = isStep(next.pitch, note.pitch);
       const others = otherVoicesAtBeat(note.startBeat);
-      const verticallyDissonant = others.some(
-        (ov) => _chunk3R3QVKY5cjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
-      );
+      const verticallyDissonant = others.length > 0 ? others.some((ov) => _chunkYDGMWH43cjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)) : clashesWithChord(note.pitch, chord);
       if (prepared && verticallyDissonant && resolves) {
         const ic = intervalAboveBass(note.pitch, others, chord);
-        const type = suspensionType(ic, next.pitch - note.pitch);
+        const resolvedIc = intervalAboveBass(next.pitch, others, chord);
+        const type = suspensionType(ic, next.pitch - note.pitch, resolvedIc);
         if (type !== null) {
           labels.push({ kind: "suspension", type, resolveTo: next.pitch });
           handled = true;
@@ -2553,8 +2685,8 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && prev && next) {
-      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 prevMember = _chunkYDGMWH43cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunkYDGMWH43cjs.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;
@@ -2563,20 +2695,20 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         handled = true;
       }
     }
-    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)) {
+    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunkYDGMWH43cjs.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 (_chunk3R3QVKY5cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
+      if (_chunkYDGMWH43cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
         labels.push({ kind: "anticipation" });
         handled = true;
       }
     }
     if (!handled && chord && prev && next && !member) {
-      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 prevMember = _chunkYDGMWH43cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunkYDGMWH43cjs.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;
@@ -2586,8 +2718,8 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && prev && next && !member) {
-      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 prevMember = _chunkYDGMWH43cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat2(prev.startBeat));
+      const nextMember = _chunkYDGMWH43cjs.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;
@@ -2597,7 +2729,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && !member) {
-      const ic = _chunk3R3QVKY5cjs.intervalAboveRoot.call(void 0, note.pitch, chord);
+      const ic = _chunkYDGMWH43cjs.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);
@@ -2616,7 +2748,7 @@ function analyzeVoice(voice, chordAtBeat2, key, otherVoicesAtBeat = () => []) {
         );
       }
     }
-    if (next && _chunk3R3QVKY5cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
+    if (next && _chunkYDGMWH43cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
       labels.push({ kind: "leadingTone", resolveTo: next.pitch });
     }
     const analyzed = {
@@ -2667,23 +2799,49 @@ function describe(labels) {
 
 // src/analyze/timeline/index.ts
 function assertChordTimeline(timeline, name = "timeline") {
-  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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, timeline, name);
+  _chunkS3QELJUEcjs.assertFunction.call(void 0, read.at, `${name}.at`);
+  const segments = _chunkS3QELJUEcjs.assertArray.call(void 0, read.segments, `${name}.segments`);
   for (let index = 0; index < segments.length; index += 1) {
-    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`);
+    const segment = _chunkS3QELJUEcjs.assertRecord.call(void 0, segments[index], `${name}.segments[${index}]`);
+    _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, segment.startBeat, `${name}.segments[${index}].startBeat`);
+    _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, segment.endBeat, `${name}.segments[${index}].endBeat`);
   }
+  assertSpansInOrder(segments, `${name}.segments`);
   return read;
 }
+function assertSpansInOrder(spans, name) {
+  for (let index = 0; index < spans.length; index += 1) {
+    const span = spans[index];
+    if (span === void 0) {
+      continue;
+    }
+    if (!(span.endBeat > span.startBeat)) {
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+        `${name}[${index}] must end after it starts; received [${span.startBeat}, ${span.endBeat})`
+      );
+    }
+    const previous = spans[index - 1];
+    if (previous !== void 0 && span.startBeat < previous.endBeat) {
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+        `${name}[${index}] must not start before ${name}[${index - 1}] ends; received ${span.startBeat} before ${previous.endBeat}`
+      );
+    }
+  }
+}
+function statedKeyRegions(key, startBeat, endBeat) {
+  if (!(endBeat > startBeat)) {
+    return [];
+  }
+  return [{ startBeat, endBeat, key, confidence: 1 }];
+}
 function chordTimelineFromChords(chords, totalBeats) {
-  _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");
+  _chunkS3QELJUEcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkS3QELJUEcjs.assertArray.call(void 0, chords, "chords");
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
   for (let index = 0; index < chords.length; index += 1) {
-    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
-      _nullishCoalesce(_optionalChain([chords, 'access', _42 => _42[index], 'optionalAccess', _43 => _43.startBeat]), () => ( Number.NaN)),
+    _chunkS3QELJUEcjs.assertRange.call(void 0, 
+      _nullishCoalesce(_optionalChain([chords, 'access', _44 => _44[index], 'optionalAccess', _45 => _45.startBeat]), () => ( Number.NaN)),
       -Number.MAX_SAFE_INTEGER,
       Number.MAX_SAFE_INTEGER,
       `chords[${index}].startBeat`
@@ -2697,13 +2855,13 @@ function chordTimelineFromChords(chords, totalBeats) {
     return {
       startBeat: gc.startBeat,
       endBeat,
-      chord: _chunk3R3QVKY5cjs.chordFromSpan.call(void 0, gc)
+      chord: _chunkYDGMWH43cjs.chordFromSpan.call(void 0, gc)
     };
   }).filter((seg) => seg.endBeat > seg.startBeat);
   return { at: segmentLookup(segments), segments };
 }
 function chordAtBeat(segments, beat) {
-  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
+  _chunkS3QELJUEcjs.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;
 }
@@ -2712,7 +2870,7 @@ function firstAfter(segments, beat) {
   let high = segments.length;
   while (low < high) {
     const middle = Math.floor((low + high) / 2);
-    if ((_nullishCoalesce(_optionalChain([segments, 'access', _44 => _44[middle], 'optionalAccess', _45 => _45.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+    if ((_nullishCoalesce(_optionalChain([segments, 'access', _46 => _46[middle], 'optionalAccess', _47 => _47.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
       low = middle + 1;
     } else {
       high = middle;
@@ -2723,7 +2881,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) < _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (candidate !== void 0 && Math.abs(candidate.startBeat - beat) < _chunkS3QELJUEcjs.BEAT_EPS) {
       return candidate;
     }
   }
@@ -2741,13 +2899,14 @@ var EXTRA_TONE_PENALTY = 0.6;
 var OMITTED_TONE_PENALTY = 0.15;
 var BASS_ROOT_STANDING = 0.95;
 var OCTAVE = 12;
+var CHORD_SEGMENTATIONS = ["dynamic", "grid"];
 function scoreMatch(match, weights, maxWeight, key, pedalPc) {
   const rootWeight = maxWeight > 0 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
   const rootStanding = match.inversion === 0 ? Math.max(rootWeight, BASS_ROOT_STANDING) : rootWeight;
-  const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, match.rootPc, match.quality);
+  const chord = _chunkYDGMWH43cjs.makeChord.call(void 0, match.rootPc, match.quality);
   const account = matchAccount(match, chord, pedalPc);
   let score = rootStanding;
-  if (_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunk3R3QVKY5cjs.isScaleTone.call(void 0, pc, key))) {
+  if (_chunkYDGMWH43cjs.chordPitchClasses.call(void 0, chord).every((pc) => _chunkYDGMWH43cjs.isScaleTone.call(void 0, pc, key))) {
     score += DIATONIC_BONUS;
   }
   if (account.exact) {
@@ -2757,12 +2916,15 @@ function scoreMatch(match, weights, maxWeight, key, pedalPc) {
   score -= OMITTED_TONE_PENALTY * account.missing;
   return score;
 }
-var SLASH_UPPER_QUALITIES = /* @__PURE__ */ new Set(["maj", "min"]);
+var SLASH_UPPER_QUALITY_LIST = ["maj", "min"];
+var SLASH_UPPER_QUALITIES = new Set(
+  SLASH_UPPER_QUALITY_LIST
+);
 function isSlashReading(match, pedalPc) {
   return pedalPc !== null && match.inversion === null && match.missingPcs.length === 0 && match.extraPcs.length === 1 && match.extraPcs[0] === pedalPc && SLASH_UPPER_QUALITIES.has(match.quality);
 }
 function namesAsExtension(chord, pc) {
-  return chord.intervals.some((iv) => iv >= OCTAVE && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === pc);
+  return chord.intervals.some((iv) => iv >= OCTAVE && _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc + iv) === pc);
 }
 function matchAccount(match, chord, pedalPc) {
   const unvoiced = pedalPc !== null && namesAsExtension(chord, pedalPc) ? 1 : 0;
@@ -2778,10 +2940,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 <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (overlap <= _chunkS3QELJUEcjs.BEAT_EPS) {
       continue;
     }
-    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note.pitch) === bassPc) {
+    if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, note.pitch) === bassPc) {
       highestBass = Math.max(highestBass, note.pitch);
     } else {
       upperFloor = Math.min(upperFloor, note.pitch);
@@ -2789,8 +2951,32 @@ function bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) {
   }
   return highestBass <= upperFloor;
 }
+function windowBass(notes, windowStart, windowEnd, meters, harmonicRhythm) {
+  const counted = [];
+  let firstSounding = Number.POSITIVE_INFINITY;
+  for (const note of notes) {
+    const overlap = Math.min(note.startBeat + note.durationBeat, windowEnd) - Math.max(note.startBeat, windowStart);
+    if (overlap <= _chunkS3QELJUEcjs.BEAT_EPS) {
+      continue;
+    }
+    const onsetInWindow = note.startBeat >= windowStart - _chunkS3QELJUEcjs.BEAT_EPS && note.startBeat < windowEnd - _chunkS3QELJUEcjs.BEAT_EPS;
+    if (noteWeight(note, overlap, onsetInWindow ? meters : void 0) <= _chunkS3QELJUEcjs.BEAT_EPS) {
+      continue;
+    }
+    counted.push({ note, overlap });
+    firstSounding = Math.min(firstSounding, Math.max(note.startBeat, windowStart));
+  }
+  const half = (windowEnd - windowStart) / 2;
+  let bass = Number.POSITIVE_INFINITY;
+  for (const { note, overlap } of counted) {
+    if (note.startBeat <= firstSounding + _chunkS3QELJUEcjs.BEAT_EPS || overlap > half || overlap >= harmonicRhythm - _chunkS3QELJUEcjs.BEAT_EPS) {
+      bass = Math.min(bass, note.pitch);
+    }
+  }
+  return bass;
+}
 function chordConfidence(chord, weights, totalWeight, exact) {
-  const tones = new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord));
+  const tones = new Set(_chunkYDGMWH43cjs.chordPitchClasses.call(void 0, chord));
   let chordWeight = 0;
   for (let pc = 0; pc < 12; pc += 1) {
     if (tones.has(pc)) {
@@ -2801,43 +2987,56 @@ function chordConfidence(chord, weights, totalWeight, exact) {
   const confidence = Math.min(1, Math.max(0, raw));
   return exact ? confidence : confidence * INEXACT_CONFIDENCE_FACTOR;
 }
-function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
-  const { weights, totalWeight, maxWeight, lowestPitch } = windowWeights(
-    notes,
-    windowStart,
-    windowEnd,
-    meters
-  );
-  if (totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+function analyzeWindow(notes, windowStart, windowEnd, meters, key, harmonicRhythm) {
+  const { weights, totalWeight, maxWeight } = windowWeights(notes, windowStart, windowEnd, meters);
+  if (totalWeight <= _chunkS3QELJUEcjs.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 = _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;
-  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
+  const bassPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, windowBass(notes, windowStart, windowEnd, meters, harmonicRhythm));
+  const sounding = ranked.slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
+  const significant = ranked.filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO).slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
+  let detection = detectWindow(significant, bassPc, notes, windowStart, windowEnd);
+  if (detection.matches.length === 0 && significant.length < sounding.length) {
+    detection = detectWindow(sounding, bassPc, notes, windowStart, windowEnd);
+  }
+  const { selected, hasBass, pedalPc, matches } = detection;
   let bestMatch = null;
   let bestScore = Number.NEGATIVE_INFINITY;
   for (const match of matches) {
-    const score = scoreMatch(match, weights, maxWeight, _chunk3R3QVKY5cjs.scaleOf.call(void 0, key), pedalPc);
+    const score = scoreMatch(match, weights, maxWeight, _chunkYDGMWH43cjs.scaleOf.call(void 0, key), pedalPc);
     if (score > bestScore) {
       bestScore = score;
       bestMatch = match;
     }
   }
   if (bestMatch) {
-    const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
+    const chord = _chunkYDGMWH43cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
     const account = matchAccount(
       bestMatch,
-      _chunk3R3QVKY5cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality),
+      _chunkYDGMWH43cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality),
       pedalPc
     );
+    const explained = account.exact || isSlashReading(bestMatch, pedalPc);
     const reading = {
       chord: shared(chord),
-      confidence: chordConfidence(chord, weights, totalWeight, account.exact)
+      confidence: chordConfidence(chord, weights, totalWeight, explained)
     };
+    if (bestMatch.quality === SYMMETRIC_QUALITY) {
+      reading.rootings = _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, _chunkYDGMWH43cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality)).map(
+        (rootPc) => {
+          const rooted = _chunkYDGMWH43cjs.makeChord.call(void 0, 
+            rootPc,
+            bestMatch.quality,
+            hasBass && bassPc !== rootPc ? bassPc : void 0
+          );
+          return {
+            chord: shared(rooted),
+            confidence: chordConfidence(rooted, weights, totalWeight, explained)
+          };
+        }
+      );
+    }
     const augmented = hasBass ? augmentedSixthFromPitchClasses(selected, bassPc, key) : null;
     if (augmented !== null) {
       reading.augmented = {
@@ -2849,14 +3048,21 @@ function analyzeWindow(notes, windowStart, windowEnd, meters, key) {
   }
   return null;
 }
+function detectWindow(selected, bassPc, notes, windowStart, windowEnd) {
+  const hasBass = selected.includes(bassPc);
+  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
+  const pedalPc = hasBass && bassSoundsOnlyBelow(notes, windowStart, windowEnd, bassPc) ? bassPc : null;
+  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
+  return { selected, hasBass, pedalPc, matches };
+}
 function shared(chord) {
   Object.freeze(chord.intervals);
   return Object.freeze(chord);
 }
 var DOMINANT_ABOVE_TONIC = 7;
 function resolvesOntoDominant(readings, index, key) {
-  const dominantPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc + DOMINANT_ABOVE_TONIC);
-  const candidate = _optionalChain([readings, 'access', _46 => _46[index], 'optionalAccess', _47 => _47.chord]);
+  const dominantPc = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc + DOMINANT_ABOVE_TONIC);
+  const candidate = _optionalChain([readings, 'access', _48 => _48[index], 'optionalAccess', _49 => _49.chord]);
   for (let i = index + 1; i < readings.length; i += 1) {
     const next = readings[i];
     if (!next) {
@@ -2866,15 +3072,38 @@ function resolvesOntoDominant(readings, index, key) {
     if (candidate !== void 0 && sameChord(chord, candidate)) {
       continue;
     }
-    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== dominantPc) {
+    if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc))) !== dominantPc) {
       return false;
     }
-    if (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc) === dominantPc) {
+    if (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc) === dominantPc) {
       return true;
     }
   }
   return true;
 }
+var SYMMETRIC_QUALITY = "dim7";
+function settledDiminishedRoot(readings, index, key) {
+  const reading = readings[index];
+  const rootings = _optionalChain([reading, 'optionalAccess', _50 => _50.rootings]);
+  if (!reading || rootings === void 0) {
+    return null;
+  }
+  const roots = rootings.map((rooting) => rooting.chord.rootPc);
+  const tones = _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, reading.chord).join();
+  for (let i = index + 1; i < readings.length; i += 1) {
+    const next = readings[i];
+    if (!next || _chunkYDGMWH43cjs.chordPitchClasses.call(void 0, next.chord).join() === tones) {
+      continue;
+    }
+    const leading = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, next.chord.rootPc - 1);
+    if (roots.includes(leading)) {
+      return leading;
+    }
+    break;
+  }
+  const leadingTone = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc - 1);
+  return roots.includes(leadingTone) ? leadingTone : null;
+}
 function sameChord(a, b) {
   return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;
 }
@@ -2902,7 +3131,7 @@ var LEXICON_TONES = (() => {
     for (const quality of SEGMENTATION_QUALITIES) {
       LEXICON_ROOTS[candidate] = rootPc;
       LEXICON_TONE_START[candidate] = tones.length;
-      tones.push(..._chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality)));
+      tones.push(..._chunkYDGMWH43cjs.chordPitchClasses.call(void 0, _chunkYDGMWH43cjs.makeChord.call(void 0, rootPc, quality)));
       candidate += 1;
     }
   }
@@ -2923,7 +3152,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 <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (weight <= _chunkS3QELJUEcjs.BEAT_EPS) {
       missing += 1;
     }
   }
@@ -2939,16 +3168,16 @@ function slotOfBeat(grid, beat) {
 }
 function createBoundaryTables(slotCount, budget) {
   return {
-    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)
+    scores: _chunkS3QELJUEcjs.allocateCandidateTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window scores", budget),
+    back: _chunkS3QELJUEcjs.allocateChoiceTable.call(void 0, slotCount, LEXICON_SIZE, "timeline window choices", budget),
+    costs: _chunkS3QELJUEcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    spare: _chunkS3QELJUEcjs.allocateCandidateTable.call(void 0, 1, LEXICON_SIZE, "timeline window costs", budget),
+    path: _chunkS3QELJUEcjs.allocateChoiceTable.call(void 0, slotCount, 1, "timeline window path", budget)
   };
 }
 function scoreSlot(tables, slot, index) {
   const base = index * LEXICON_SIZE;
-  if (slot.totalWeight <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+  if (slot.totalWeight <= _chunkS3QELJUEcjs.BEAT_EPS) {
     tables.scores.fill(0, base, base + LEXICON_SIZE);
     return;
   }
@@ -2978,7 +3207,7 @@ function chooseBoundaries(tables, from, to, grid, meters, changeCost) {
       }
     }
     const slotStart = beatOfSlot(grid, from + i);
-    const accent = _chunkS5BKZZGMcjs.metricWeight.call(void 0, slotStart, meters);
+    const accent = _chunkS3QELJUEcjs.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;
@@ -3020,7 +3249,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 - _chunkS5BKZZGMcjs.BEAT_EPS));
+  const divisions = Math.max(1, Math.ceil(gridUnit / resolution - _chunkS3QELJUEcjs.BEAT_EPS));
   return gridUnit / divisions;
 }
 function gridSpans(slotCount, grid) {
@@ -3035,8 +3264,8 @@ function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
   let soundingSlots = 0;
   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 > _chunkS5BKZZGMcjs.BEAT_EPS) {
+    const weight = _nullishCoalesce(_optionalChain([slotWeights, 'access', _51 => _51[i], 'optionalAccess', _52 => _52.totalWeight]), () => ( 0));
+    if (weight > _chunkS3QELJUEcjs.BEAT_EPS) {
       soundingSlots += 1;
       weightSum += weight;
     }
@@ -3046,7 +3275,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 <= _chunkS5BKZZGMcjs.BEAT_EPS);
+  const silent = slotWeights.map((slot) => slot.totalWeight <= _chunkS3QELJUEcjs.BEAT_EPS);
   const breaks = new Array(slotCount).fill(false);
   for (let i = 0; i < slotCount; ) {
     if (!silent[i]) {
@@ -3057,7 +3286,7 @@ function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
     while (end < slotCount && silent[end]) {
       end += 1;
     }
-    if ((end - i) * slotBeats >= harmonicRhythm - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if ((end - i) * slotBeats >= harmonicRhythm - _chunkS3QELJUEcjs.BEAT_EPS) {
       for (let k = i; k < end; k += 1) {
         breaks[k] = true;
       }
@@ -3120,45 +3349,46 @@ 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 = _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 = _chunkS5BKZZGMcjs.metricGridUnit.call(void 0, meters);
+  const meters = _chunkS3QELJUEcjs.resolveMeters.call(void 0, opts, "timeline meters");
+  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, 0, meters)));
+  _chunkS3QELJUEcjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  const segmentation = _chunkS3QELJUEcjs.assertOneOf.call(void 0, 
+    _nullishCoalesce(opts.segmentation, () => ( "dynamic")),
+    CHORD_SEGMENTATIONS,
+    "timeline segmentation"
+  );
+  const gridUnit = _chunkS3QELJUEcjs.metricGridUnit.call(void 0, meters);
   const minChordBeats = _nullishCoalesce(opts.minChordBeats, () => ( gridUnit));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
+  _chunkS3QELJUEcjs.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) {
-    _chunkS5BKZZGMcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
+    _chunkS3QELJUEcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
     noteOptions.minStartBeat = -opts.pickupBeats;
   }
-  _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));
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, notes, "timeline notes", noteOptions);
+  const sounding = _chunkKMYGRFZ6cjs.sortedNoteEvents.call(void 0, notes.filter((note) => note.durationBeat > 0));
+  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( latestSoundingEnd(sounding)));
+  _chunkS3QELJUEcjs.assertRange.call(void 0, 
+    totalBeats,
+    Math.min(0, firstSoundingBeat(sounding)),
+    Number.MAX_SAFE_INTEGER,
+    "timeline totalBeats"
+  );
   const slotBeats = segmentation === "grid" ? harmonicRhythm : slotBeatsWithin(gridUnit, minChordBeats, harmonicRhythm);
   const { origin, startBeat: musicStart } = gridForNotes(sounding, slotBeats);
   const grid = { origin, slotBeats };
-  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - _chunkS5BKZZGMcjs.BEAT_EPS));
+  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - _chunkS3QELJUEcjs.BEAT_EPS));
   const dynamic = segmentation === "dynamic";
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, 
     dynamic ? slotCount * LEXICON_SIZE : slotCount,
     "timeline windows",
     budget
   );
-  const keys = opts.key !== void 0 ? [
-    {
-      startBeat: musicStart,
-      endBeat: totalBeats,
-      key: _chunk3R3QVKY5cjs.resolveKey.call(void 0, opts.key),
-      confidence: 1
-    }
-  ] : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
-  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunk3R3QVKY5cjs.resolveKey.call(void 0, _chunk3R3QVKY5cjs.majorKey.call(void 0, 0))));
+  const keys = opts.key !== void 0 ? statedKeyRegions(_chunkYDGMWH43cjs.resolveKey.call(void 0, opts.key), musicStart, totalBeats) : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
+  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunkYDGMWH43cjs.resolveKey.call(void 0, _chunkYDGMWH43cjs.majorKey.call(void 0, 0))));
   const keyAt = keyLookup(keys, prevailingKey);
-  const scaleAt = (beat) => _chunk3R3QVKY5cjs.scaleOf.call(void 0, keyAt(beat));
+  const scaleAt = (beat) => _chunkYDGMWH43cjs.scaleOf.call(void 0, keyAt(beat));
   const segments = [];
   const segmentConfidence = [];
   const slotNotes = bucketNotesBySlot(sounding, grid, slotCount, {
@@ -3174,15 +3404,15 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     harmonicRhythm,
     opts.key !== void 0
   ) ? previous : void 0;
-  const dirtyFrom = carried === void 0 ? 0 : Math.max(0, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _50 => _50.from]), () => ( 0)));
-  const dirtyTo = carried === void 0 ? slotCount : Math.min(slotCount, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _51 => _51.to]), () => ( slotCount)));
-  const tables = _nullishCoalesce(_optionalChain([carried, 'optionalAccess', _52 => _52.tables]), () => ( createBoundaryTables(dynamic ? slotCount : 0, budget)));
+  const dirtyFrom = carried === void 0 ? 0 : Math.max(0, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _53 => _53.from]), () => ( 0)));
+  const dirtyTo = carried === void 0 ? slotCount : Math.min(slotCount, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _54 => _54.to]), () => ( slotCount)));
+  const tables = _nullishCoalesce(_optionalChain([carried, 'optionalAccess', _55 => _55.tables]), () => ( createBoundaryTables(dynamic ? slotCount : 0, budget)));
   if (carried !== void 0) {
     carried.tables = void 0;
   }
   const slotWeights = new Array(slotCount);
   for (let i = 0; i < slotCount; i += 1) {
-    const reusable = i < dirtyFrom || i >= dirtyTo ? _optionalChain([carried, 'optionalAccess', _53 => _53.slotWeights, 'access', _54 => _54[i]]) : void 0;
+    const reusable = i < dirtyFrom || i >= dirtyTo ? _optionalChain([carried, 'optionalAccess', _56 => _56.slotWeights, 'access', _57 => _57[i]]) : void 0;
     if (reusable !== void 0) {
       slotWeights[i] = reusable;
       continue;
@@ -3211,14 +3441,29 @@ function analyzeTimeline(notes, opts = {}, previous, dirty) {
     const spanKeyWhole = keyAt(start);
     const id = windowId(start, end, spanKey);
     const cached = carried !== void 0 && spanIsClean(grid, span, dirtyFrom, dirtyTo) ? carried.windows.get(id) : void 0;
-    const inferred = cached !== void 0 ? cached : analyzeWindow(notesOfSpan(slotNotes, span, grid), start, end, meters, spanKeyWhole);
+    const inferred = cached !== void 0 ? cached : analyzeWindow(
+      notesOfSpan(slotNotes, span, grid),
+      start,
+      end,
+      meters,
+      spanKeyWhole,
+      harmonicRhythm
+    );
     windows.set(id, inferred);
     readings.push(inferred);
     readingKeys.push(spanKey);
     readingBounds.push({ start, end });
   }
+  for (let i = readings.length - 1; i >= 0; i -= 1) {
+    const spanKey = readingKeys[i];
+    const root = spanKey === void 0 ? null : settledDiminishedRoot(readings, i, spanKey);
+    const rooting = _optionalChain([readings, 'access', _58 => _58[i], 'optionalAccess', _59 => _59.rootings, 'optionalAccess', _60 => _60.find, 'call', _61 => _61((option) => option.chord.rootPc === root)]);
+    if (rooting !== void 0 && root !== _optionalChain([readings, 'access', _62 => _62[i], 'optionalAccess', _63 => _63.chord, 'access', _64 => _64.rootPc])) {
+      readings[i] = rooting;
+    }
+  }
   for (let i = 0; i < readings.length; i += 1) {
-    const offered = _optionalChain([readings, 'access', _55 => _55[i], 'optionalAccess', _56 => _56.augmented]);
+    const offered = _optionalChain([readings, 'access', _65 => _65[i], 'optionalAccess', _66 => _66.augmented]);
     const spanKey = readingKeys[i];
     if (offered !== void 0 && spanKey !== void 0 && resolvesOntoDominant(readings, i, spanKey)) {
       readings[i] = offered;
@@ -3232,7 +3477,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) < _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < _chunkS3QELJUEcjs.BEAT_EPS) {
       const lastLength = last.endBeat - last.startBeat;
       const length = end - start;
       const lastConfidence = _nullishCoalesce(segmentConfidence[segmentConfidence.length - 1], () => ( 0));
@@ -3273,11 +3518,11 @@ function detectCadences(timeline, key) {
     if (!prev || !cur) {
       continue;
     }
-    if (Math.abs(cur.startBeat - prev.endBeat) > _chunkS5BKZZGMcjs.BEAT_EPS) {
+    if (Math.abs(cur.startBeat - prev.endBeat) > _chunkS3QELJUEcjs.BEAT_EPS) {
       continue;
     }
     const before = timeline.segments[i - 2];
-    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS ? before.chord : void 0;
+    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= _chunkS3QELJUEcjs.BEAT_EPS ? before.chord : void 0;
     const key2 = keyAt(cur.startBeat);
     const cadence = detectCadence(prev.chord, cur.chord, key2, {
       ...approach === void 0 ? {} : { approach }
@@ -3287,7 +3532,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) <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      if (next !== void 0 && Math.abs(next.startBeat - cur.endBeat) <= _chunkS3QELJUEcjs.BEAT_EPS) {
         const onward = detectCadence(cur.chord, next.chord, keyAt(next.startBeat)).type;
         if (onward === "authentic" || onward === "deceptive") {
           continue;
@@ -3305,15 +3550,15 @@ function phraseNotes(phrase) {
   if (Array.isArray(phrase)) {
     return phrase;
   }
-  return _chunkS5BKZZGMcjs.assertRecord.call(void 0, phrase, "melodic phrase").notes;
+  return _chunkS3QELJUEcjs.assertRecord.call(void 0, phrase, "melodic phrase").notes;
 }
 function orderedNotes(notes, name, budget) {
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, name, { allowNonPositiveDuration: true, budget });
+  _chunkS3QELJUEcjs.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) {
+    if (previous !== void 0 && Math.abs(note.startBeat - previous.startBeat) <= _chunkS3QELJUEcjs.BEAT_EPS) {
       line[line.length - 1] = note;
       continue;
     }
@@ -3324,14 +3569,14 @@ function orderedNotes(notes, name, budget) {
 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))));
+    out.push((_nullishCoalesce(_optionalChain([notes, 'access', _67 => _67[i], 'optionalAccess', _68 => _68.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _69 => _69[i - 1], 'optionalAccess', _70 => _70.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))));
+    out.push((_nullishCoalesce(_optionalChain([notes, 'access', _71 => _71[i], 'optionalAccess', _72 => _72.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _73 => _73[i - 1], 'optionalAccess', _74 => _74.startBeat]), () => ( 0))));
   }
   return out;
 }
@@ -3341,14 +3586,14 @@ function retrogradeGaps(notes) {
     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))))
+      (_nullishCoalesce(_optionalChain([later, 'optionalAccess', _75 => _75.startBeat]), () => ( 0))) + (_nullishCoalesce(_optionalChain([later, 'optionalAccess', _76 => _76.durationBeat]), () => ( 0))) - ((_nullishCoalesce(_optionalChain([earlier, 'optionalAccess', _77 => _77.startBeat]), () => ( 0))) + (_nullishCoalesce(_optionalChain([earlier, 'optionalAccess', _78 => _78.durationBeat]), () => ( 0))))
     );
   }
   return out;
 }
 function rhythmProfile(gaps) {
   const unit = _nullishCoalesce(gaps[0], () => ( 0));
-  if (!(unit > _chunkS5BKZZGMcjs.BEAT_EPS)) {
+  if (!(unit > _chunkS3QELJUEcjs.BEAT_EPS)) {
     return gaps.length === 0 ? [] : null;
   }
   return gaps.map((gap) => Math.round(gap / unit * RHYTHM_GRID) / RHYTHM_GRID);
@@ -3358,7 +3603,7 @@ function sameNumbers(a, b) {
     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) {
+    if (Math.abs((_nullishCoalesce(a[i], () => ( 0))) - (_nullishCoalesce(b[i], () => ( 0)))) > _chunkS3QELJUEcjs.BEAT_EPS) {
       return false;
     }
   }
@@ -3369,17 +3614,13 @@ function roundTo(value, digits) {
   return Math.round(value * scale) / scale;
 }
 function endBeatOf(notes) {
-  let end = 0;
-  for (const note of notes) {
-    end = Math.max(end, note.startBeat + note.durationBeat);
-  }
-  return end;
+  return latestSoundingEnd(notes);
 }
 function onsetSpan(notes) {
   if (notes.length < 2) {
     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)));
+  return (_nullishCoalesce(_optionalChain([notes, 'access', _79 => _79[notes.length - 1], 'optionalAccess', _80 => _80.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _81 => _81[0], 'optionalAccess', _82 => _82.startBeat]), () => ( 0)));
 }
 
 // src/analyze/melody/contour.ts
@@ -3398,10 +3639,10 @@ function extremes(notes) {
   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)))) {
+    if ((_nullishCoalesce(_optionalChain([notes, 'access', _83 => _83[i], 'optionalAccess', _84 => _84.pitch]), () => ( 0))) > (_nullishCoalesce(_optionalChain([notes, 'access', _85 => _85[peak], 'optionalAccess', _86 => _86.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)))) {
+    if ((_nullishCoalesce(_optionalChain([notes, 'access', _87 => _87[i], 'optionalAccess', _88 => _88.pitch]), () => ( 0))) < (_nullishCoalesce(_optionalChain([notes, 'access', _89 => _89[trough], 'optionalAccess', _90 => _90.pitch]), () => ( 0)))) {
       trough = i;
     }
   }
@@ -3414,7 +3655,7 @@ function melodicContour(notes) {
     (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 range = (_nullishCoalesce(_optionalChain([line, 'access', _91 => _91[peak], 'optionalAccess', _92 => _92.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([line, 'access', _93 => _93[trough], 'optionalAccess', _94 => _94.pitch]), () => ( 0)));
   const motion = intervals.reduce((sum, step) => sum + Math.abs(step), 0);
   if (motion === 0) {
     return {
@@ -3426,8 +3667,8 @@ function melodicContour(notes) {
       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 first = _nullishCoalesce(_optionalChain([line, 'access', _95 => _95[0], 'optionalAccess', _96 => _96.pitch]), () => ( 0));
+  const last = _nullishCoalesce(_optionalChain([line, 'access', _97 => _97[line.length - 1], 'optionalAccess', _98 => _98.pitch]), () => ( 0));
   const net = last - first;
   const directness = Math.abs(net) / motion;
   const share = Math.round(directness * 100);
@@ -3439,10 +3680,10 @@ function melodicContour(notes) {
       peakIndex: peak,
       troughIndex: trough,
       range,
-      rationale: `${share}% of the motion runs ${net > 0 ? "up" : "down"}, so the line is ${shape}`
+      rationale: `The net ${net > 0 ? "rise" : "fall"} is ${share}% of the motion, so the line is ${shape}`
     };
   }
-  const peakPitch = _nullishCoalesce(_optionalChain([line, 'access', _89 => _89[peak], 'optionalAccess', _90 => _90.pitch]), () => ( 0));
+  const peakPitch = _nullishCoalesce(_optionalChain([line, 'access', _99 => _99[peak], 'optionalAccess', _100 => _100.pitch]), () => ( 0));
   const archMotion = peakPitch - first + (peakPitch - last);
   if (peak > 0 && peak < line.length - 1 && archMotion >= DIRECTIONAL_SHARE * motion) {
     return {
@@ -3460,7 +3701,7 @@ function melodicContour(notes) {
     peakIndex: peak,
     troughIndex: trough,
     range,
-    rationale: `Changes direction without settling either way (${share}% of the motion nets out), so the line is a wave`
+    rationale: `Changes direction without settling either way (the net movement is ${share}% of the motion), so the line is a wave`
   };
 }
 
@@ -3506,22 +3747,22 @@ function listBeats(occurrences) {
 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 primePitch = _nullishCoalesce(_optionalChain([prime, 'access', _101 => _101[0], 'optionalAccess', _102 => _102.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)),
+      startBeat: _nullishCoalesce(_optionalChain([statement, 'access', _103 => _103[0], 'optionalAccess', _104 => _104.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
+      transpose: (_nullishCoalesce(_optionalChain([statement, 'access', _105 => _105[0], 'optionalAccess', _106 => _106.pitch]), () => ( 0))) - primePitch,
+      timeRatio: primeSpan > _chunkS3QELJUEcjs.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 stretched = occurrences.some((occurrence) => Math.abs(occurrence.timeRatio - 1) > _chunkS3QELJUEcjs.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" : ""
@@ -3535,15 +3776,15 @@ function motifFromGroup(group, notes) {
   };
 }
 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);
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, opts, "opts");
+  const minNotes = _chunkS3QELJUEcjs.assertInteger.call(void 0, _nullishCoalesce(asked.minNotes, () => ( MIN_CELL_NOTES)), "motif minNotes", 2, 64);
+  const maxNotes = _chunkS3QELJUEcjs.assertInteger.call(void 0, _nullishCoalesce(asked.maxNotes, () => ( MAX_CELL_NOTES)), "motif maxNotes", 2, 64);
   if (maxNotes < minNotes) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
       `motif maxNotes must be at least minNotes ${minNotes}; received ${maxNotes}`
     );
   }
-  const minOccurrences = _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+  const minOccurrences = _chunkS3QELJUEcjs.assertInteger.call(void 0, 
     _nullishCoalesce(asked.minOccurrences, () => ( MIN_OCCURRENCES)),
     "motif minOccurrences",
     2
@@ -3552,7 +3793,7 @@ function extractMotifs(notes, opts = {}) {
   if (sounding.length < minNotes) {
     return [];
   }
-  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, 
     sounding.length * (maxNotes - minNotes + 1),
     "motif windows",
     asked.budget
@@ -3599,7 +3840,7 @@ function extractMotifs(notes, opts = {}) {
         }
       }
     }
-    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, comparisons, "motif subsumption comparisons", asked.budget);
+    _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, comparisons, "motif subsumption comparisons", asked.budget);
     if (!covered) {
       kept.push(candidate);
       let byStart = keptByLength.get(candidate.length);
@@ -3637,18 +3878,18 @@ function spellingOf(key) {
   if (key === void 0) {
     return "sharp";
   }
-  return _chunk3R3QVKY5cjs.keySignatureFifths.call(void 0, key.tonic, key.scale) < 0 ? "flat" : "sharp";
+  return _chunkYDGMWH43cjs.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));
+  const start = _chunkS3QELJUEcjs.midiToNote.call(void 0, from, spellingOf(key));
+  return _chunkS3QELJUEcjs.spelledInterval.call(void 0, start, _chunkS3QELJUEcjs.transposeNote.call(void 0, start, to - from));
 }
 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));
+  const root = _chunkS3QELJUEcjs.pitchClassOf.call(void 0, key.rootPc);
+  const offsets = _chunkYDGMWH43cjs.scaleTonesInDegreeOrder.call(void 0, key).map((pc) => _chunkS3QELJUEcjs.pitchClassOf.call(void 0, pc - root));
   if (offsets.length === 0) {
     return null;
   }
@@ -3699,15 +3940,15 @@ function totalGap(gaps) {
 }
 function stretchRatio(modelGaps, answerGaps) {
   const span = totalGap(modelGaps);
-  return span > _chunkS5BKZZGMcjs.BEAT_EPS ? totalGap(answerGaps) / span : 1;
+  return span > _chunkS3QELJUEcjs.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");
+  const key = keyLike === void 0 ? void 0 : _chunkYDGMWH43cjs.resolveKey.call(void 0, keyLike);
+  const model = _chunkS3QELJUEcjs.assertArray.call(void 0, _chunkS3QELJUEcjs.assertRecord.call(void 0, a, "a").notes, "a.notes");
+  const answer = _chunkS3QELJUEcjs.assertArray.call(void 0, _chunkS3QELJUEcjs.assertRecord.call(void 0, b, "b").notes, "b.notes");
   if (model.length === 0 || model.length !== answer.length) {
     return null;
   }
@@ -3722,12 +3963,12 @@ function relateMotifs(a, b, keyLike) {
   }
   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 semitones = (_nullishCoalesce(_optionalChain([answer, 'access', _107 => _107[0], 'optionalAccess', _108 => _108.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([model, 'access', _109 => _109[0], 'optionalAccess', _110 => _110.pitch]), () => ( 0)));
+  const interval = intervalBetween(_nullishCoalesce(_optionalChain([model, 'access', _111 => _111[0], 'optionalAccess', _112 => _112.pitch]), () => ( 0)), _nullishCoalesce(_optionalChain([answer, 'access', _113 => _113[0], 'optionalAccess', _114 => _114.pitch]), () => ( 0)), key);
+  const gap = (_nullishCoalesce(_optionalChain([answer, 'access', _115 => _115[0], 'optionalAccess', _116 => _116.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 stretched = Math.abs(timeRatio - 1) > _chunkS3QELJUEcjs.BEAT_EPS;
   const shapes = pitchShapes(intervalsOf(model), intervalsOf(answer));
   const base = { sequence, semitones, interval, timeRatio };
   const backwardBase = { ...base, timeRatio: stretchRatio(retroGaps, answerGaps) };
@@ -3771,11 +4012,12 @@ function relateMotifs(a, b, keyLike) {
       }
     }
   }
-  if (forward && shapes.includes("inversion")) {
+  const literalRetrograde = backward && shapes.includes("retrograde") && _optionalChain([answer, 'access', _117 => _117[0], 'optionalAccess', _118 => _118.pitch]) === _optionalChain([model, 'access', _119 => _119[model.length - 1], 'optionalAccess', _120 => _120.pitch]);
+  if (forward && shapes.includes("inversion") && !(literalRetrograde && semitones !== 0)) {
     return {
       ...base,
       kind: "inversion",
-      rationale: "Inversion: every interval turned upside down about the first note" + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
+      rationale: `Inversion: every interval turned upside down${semitones === 0 ? " about the first note" : ""}` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
     };
   }
   if (backward && shapes.includes("retrograde")) {
@@ -3829,8 +4071,8 @@ 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;
+  if (!(x > _chunkS3QELJUEcjs.BEAT_EPS) || !(y > _chunkS3QELJUEcjs.BEAT_EPS)) {
+    return Math.abs(x - y) > _chunkS3QELJUEcjs.BEAT_EPS ? 1 : 0;
   }
   return Math.min(1, Math.abs(Math.log2(x / y)));
 }
@@ -3839,6 +4081,7 @@ function compareMelodies(a, b) {
   const right = orderedNotes(phraseNotes(b), "melody b");
   const leftIntervals = intervalsOf(left);
   const rightIntervals = intervalsOf(right);
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, leftIntervals.length * rightIntervals.length, "melody alignment");
   const pitchSimilarity = distanceToSimilarity(
     gradedEditDistance(leftIntervals, rightIntervals, intervalCost),
     leftIntervals.length,
@@ -3884,28 +4127,28 @@ function betterParent(candidate, current) {
   return candidate.index < current.index;
 }
 function motifGraph(line, motifs, opts = {}) {
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS3QELJUEcjs.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");
+  _chunkS3QELJUEcjs.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 motifList = _chunkS3QELJUEcjs.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, 
+    const motif = _chunkS3QELJUEcjs.assertRecord.call(void 0, motifList[mi], `motifs[${mi}]`);
+    const notes = _chunkS3QELJUEcjs.assertArray.call(void 0, motif.notes, `motifs[${mi}].notes`);
+    const occurrences = _chunkS3QELJUEcjs.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, 
+      const occurrence = _chunkS3QELJUEcjs.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;
+      const onLine = Number.isInteger(noteIndex) && noteIndex >= 0 && noteIndex + notes.length <= ordered.length && Math.abs((_nullishCoalesce(_optionalChain([ordered, 'access', _121 => _121[noteIndex], 'optionalAccess', _122 => _122.startBeat]), () => ( Number.NaN))) - occurrence.startBeat) <= _chunkS3QELJUEcjs.BEAT_EPS;
       if (!onLine) {
-        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
           `motif occurrence motifs[${mi}].occurrences[${oi}] does not lie on the line`
         );
       }
@@ -3922,7 +4165,7 @@ function motifGraph(line, motifs, opts = {}) {
   }
   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);
+  _chunkS3QELJUEcjs.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];
@@ -3953,16 +4196,22 @@ function motifGraph(line, motifs, opts = {}) {
 
 // src/analyze/reduction/index.ts
 var REDUCTION_LEVELS = Object.freeze(["structural", "passing", "neighbor"]);
-var TONIC_ARRIVING = /* @__PURE__ */ new Set(["authentic", "plagal", "modal", "deceptive"]);
+var TONIC_ARRIVING_CADENCES = [
+  "authentic",
+  "plagal",
+  "modal",
+  "deceptive"
+];
+var TONIC_ARRIVING = new Set(TONIC_ARRIVING_CADENCES);
 function signedStep(fromPc, toPc) {
-  return (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, toPc) - _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, fromPc) + 18) % 12 - 6;
+  return (_chunkS3QELJUEcjs.pitchClassOf.call(void 0, toPc) - _chunkS3QELJUEcjs.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;
+  return Math.abs(after.startBeat - before.endBeat) <= _chunkS3QELJUEcjs.BEAT_EPS;
 }
 function salienceFloors(durations) {
   const order = durations.map((_, index) => index).sort((a, b) => {
@@ -3989,7 +4238,7 @@ function salienceFloors(durations) {
   return floors;
 }
 function isTonicChord(chord, key) {
-  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 0 && !isAppliedDominant(chord, key);
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 0 && !isAppliedDominant(chord, key);
 }
 function functionalReason(segment, before, after, keyAt) {
   const key = keyAt(segment.startBeat);
@@ -3999,7 +4248,7 @@ function functionalReason(segment, before, after, keyAt) {
   if (isTonicChord(segment.chord, key)) {
     return { kind: "tonic" };
   }
-  if (_chunk3R3QVKY5cjs.isDominantChordOf.call(void 0, segment.chord, key)) {
+  if (_chunkYDGMWH43cjs.isDominantChordOf.call(void 0, segment.chord, key)) {
     return { kind: "dominant" };
   }
   if (before !== void 0) {
@@ -4028,7 +4277,7 @@ function figureReason(segment, before, after) {
   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;
+  return _chunkS3QELJUEcjs.pitchClassOf.call(void 0, before.chord.rootPc) === _chunkS3QELJUEcjs.pitchClassOf.call(void 0, after.chord.rootPc) ? { kind: "neighbor" } : null;
 }
 function describe2(reason) {
   switch (reason.kind) {
@@ -4069,9 +4318,9 @@ function levelOf(reason) {
 }
 function reduceProgression(timeline, key, opts = {}) {
   assertChordTimeline(timeline);
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const asked = _chunkS3QELJUEcjs.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 basis = _chunkS3QELJUEcjs.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)) : [];
@@ -4104,27 +4353,38 @@ function reduceProgression(timeline, key, opts = {}) {
   return result;
 }
 
+// src/analyze/reference/types.ts
+var REFERENCE_PROFILE_VERSION = 1;
+var PHRASE_OUTLINE_POINTS = 8;
+var MIDI_MAX = 127;
+
 // src/analyze/rhythm/internal.ts
 function isMultipleOf(value, unit) {
   if (unit <= 0) {
     return false;
   }
   const ratio2 = value / unit;
-  return Math.abs(ratio2 - Math.round(ratio2)) < _chunkS5BKZZGMcjs.BEAT_EPS;
+  return Math.abs(ratio2 - Math.round(ratio2)) < _chunkS3QELJUEcjs.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);
+  const ts = _chunkS3QELJUEcjs.meterAt.call(void 0, beatInQuarters, meters);
+  const offset = beatInQuarters - _chunkS3QELJUEcjs.barStartBeat.call(void 0, beatInQuarters, meters);
+  const pulse = _chunkS3QELJUEcjs.pulseBeats.call(void 0, ts);
   if (isMultipleOf(offset, pulse)) {
-    return _chunkS5BKZZGMcjs.metricWeight.call(void 0, beatInQuarters, meters) + 2;
+    return _chunkS3QELJUEcjs.metricWeight.call(void 0, beatInQuarters, meters) + 2;
   }
-  const subUnit = pulse / (_chunkS5BKZZGMcjs.isCompound.call(void 0, ts) ? 3 : 2);
+  const subUnit = pulse / (_chunkS3QELJUEcjs.isCompound.call(void 0, ts) ? 3 : 2);
   return isMultipleOf(offset, subUnit) ? 1 : 0;
 }
+var IOI_MIN_EXPONENT = -4;
+var IOI_MAX_EXPONENT = 4;
+var IOI_EXPONENT_STEP = 0.5;
 function ioiBinIndex(ioi) {
-  const exponent = Math.min(4, Math.max(-4, Math.round(2 * Math.log2(ioi)) / 2));
-  return Math.round((exponent + 4) / 0.5);
+  const exponent = Math.min(
+    IOI_MAX_EXPONENT,
+    Math.max(IOI_MIN_EXPONENT, Math.round(2 * Math.log2(ioi)) / 2)
+  );
+  return Math.round((exponent - IOI_MIN_EXPONENT) / IOI_EXPONENT_STEP);
 }
 
 // src/analyze/rhythm/index.ts
@@ -4134,6 +4394,8 @@ var RHYTHM_OFF_GRID_TOLERANCE = 1 / 32;
 var RHYTHM_IOI_BINS = Object.freeze(
   Array.from({ length: 17 }, (_, i) => 2 ** (-4 + i * 0.5))
 );
+var BUDGET_SLOTS_PER_BAR = 48;
+var RHYTHM_LEVEL_COUNT = 6;
 function emptyAnalysis() {
   return {
     startBeat: 0,
@@ -4142,7 +4404,7 @@ function emptyAnalysis() {
     onsets: 0,
     onsetDensity: 0,
     barOnsets: [],
-    onsetLevels: new Array(6).fill(0),
+    onsetLevels: new Array(RHYTHM_LEVEL_COUNT).fill(0),
     barPositions: [],
     interOnsetShares: new Array(RHYTHM_IOI_BINS.length).fill(0),
     restRatio: 0,
@@ -4166,8 +4428,8 @@ function foldOnsets(sounding) {
   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 ts = _chunkS3QELJUEcjs.meterAt.call(void 0, onset.beat, meters);
+  const barStart = _chunkS3QELJUEcjs.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;
@@ -4177,13 +4439,47 @@ function snapOnset(onset, meters) {
 function tsKey(ts) {
   return ts.grouping === void 0 ? `${ts.numerator}/${ts.denominator}` : `${ts.numerator}/${ts.denominator}:${ts.grouping.join("+")}`;
 }
-function barGridBeats(bar, meters) {
-  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);
+function pulseKey(bar, index) {
+  return `${bar}/${index}`;
+}
+function otherDivisionPulses(snapped, meters) {
+  const pulses = /* @__PURE__ */ new Set();
+  for (const onset of snapped) {
+    const pulse = _chunkS3QELJUEcjs.pulseBeats.call(void 0, onset.ts);
+    const offset = onset.snapped - onset.barStart;
+    const index = Math.floor(offset / pulse + _chunkS3QELJUEcjs.BEAT_EPS);
+    const within = offset - index * pulse;
+    const [used, other] = _chunkS3QELJUEcjs.isCompound.call(void 0, onset.ts) ? [3, 2] : [2, 3];
+    if (isMultipleOf(within, pulse / other) && !isMultipleOf(within, pulse / used)) {
+      pulses.add(pulseKey(_chunkS3QELJUEcjs.barIndexAt.call(void 0, onset.beat, meters), index));
+    }
+  }
+  return pulses;
+}
+function barGridPoints(bar, meters, otherPulses) {
+  const barStart = _chunkS3QELJUEcjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meters);
+  const ts = _chunkS3QELJUEcjs.meterAt.call(void 0, barStart, meters);
+  const barLength = _chunkS3QELJUEcjs.beatsPerBarAt.call(void 0, barStart, meters);
+  const pulse = _chunkS3QELJUEcjs.pulseBeats.call(void 0, ts);
+  const [used, other] = _chunkS3QELJUEcjs.isCompound.call(void 0, ts) ? [3, 2] : [2, 3];
+  const subUnit = pulse / used;
   const steps = Math.max(1, Math.round(barLength / subUnit));
-  return Array.from({ length: steps }, (_, k) => barStart + k * subUnit);
+  const points = [];
+  for (let k = 0; k < steps; k += 1) {
+    const index = Math.floor(k * subUnit / pulse + _chunkS3QELJUEcjs.BEAT_EPS);
+    if (k % used === 0 || !otherPulses.has(pulseKey(bar, index))) {
+      const beat = barStart + k * subUnit;
+      points.push({ beat, level: rhythmLevel(beat, meters) });
+    }
+  }
+  for (let index = 0; index * pulse < steps * subUnit - _chunkS3QELJUEcjs.BEAT_EPS; index += 1) {
+    if (otherPulses.has(pulseKey(bar, index))) {
+      for (let m = 1; m < other; m += 1) {
+        points.push({ beat: barStart + index * pulse + m * pulse / other, level: 1 });
+      }
+    }
+  }
+  return points.sort((a, b) => a.beat - b.beat);
 }
 function restRatioOf(sounding, windowStart, windowEnd) {
   const span = windowEnd - windowStart;
@@ -4217,13 +4513,14 @@ 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 firstBar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, startBeat, meters);
+  const lastBar = _chunkS3QELJUEcjs.barIndexAt.call(void 0, endBeat, meters);
+  const otherPulses = otherDivisionPulses(snapped, meters);
   const points = [];
   for (let bar = firstBar; bar <= lastBar; bar += 1) {
-    for (const beat of barGridBeats(bar, meters)) {
-      if (beat > startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && beat <= endBeat + _chunkS5BKZZGMcjs.BEAT_EPS) {
-        points.push({ beat, level: rhythmLevel(beat, meters) });
+    for (const point of barGridPoints(bar, meters, otherPulses)) {
+      if (point.beat > startBeat + _chunkS3QELJUEcjs.BEAT_EPS && point.beat <= endBeat + _chunkS3QELJUEcjs.BEAT_EPS) {
+        points.push(point);
       }
     }
   }
@@ -4240,51 +4537,59 @@ function syncopationOf(snapped, startBeat, endBeat, meters) {
     }
     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) {
+    while (ptr < points.length && (_nullishCoalesce(_optionalChain([points, 'access', _123 => _123[ptr], 'optionalAccess', _124 => _124.beat]), () => ( Number.POSITIVE_INFINITY))) <= onset.snapped + _chunkS3QELJUEcjs.BEAT_EPS) {
       ptr += 1;
     }
+    const here = ptr > 0 ? points[ptr - 1] : void 0;
+    const onsetLevel = here !== void 0 && Math.abs(here.beat - onset.snapped) < _chunkS3QELJUEcjs.BEAT_EPS ? Math.max(onset.level, here.level) : onset.level;
     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)));
+    while (scan < points.length && (_nullishCoalesce(_optionalChain([points, 'access', _125 => _125[scan], 'optionalAccess', _126 => _126.beat]), () => ( Number.POSITIVE_INFINITY))) < windowEnd - _chunkS3QELJUEcjs.BEAT_EPS) {
+      maxLevel = Math.max(maxLevel, _nullishCoalesce(_optionalChain([points, 'access', _127 => _127[scan], 'optionalAccess', _128 => _128.level]), () => ( 0)));
       scan += 1;
     }
-    if (maxLevel > onset.level) {
-      numerator += maxLevel - onset.level;
+    if (maxLevel > onsetLevel) {
+      numerator += maxLevel - onsetLevel;
     }
     ptr = scan;
   }
   return numerator / normalizer;
 }
 function analyzeRhythm(notes, opts = {}) {
-  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, opts, "rhythm meters");
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "rhythm notes", { allowNonPositiveDuration: true, budget: opts.budget });
+  return rhythmOver(notes, opts, void 0);
+}
+function rhythmOver(notes, opts, windowStart) {
+  const meters = _chunkS3QELJUEcjs.resolveMeters.call(void 0, opts, "rhythm meters");
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, notes, "rhythm notes", { allowNonPositiveDuration: true, budget: opts.budget });
   const sounding = notes.filter((note) => note.durationBeat > 0);
+  const startBeat = _nullishCoalesce(windowStart, () => ( barGridStart(firstSoundingBeat(sounding), meters)));
+  const endBeat = resolveSpanEnd(
+    opts.totalBeats,
+    startBeat,
+    latestSoundingEnd(sounding),
+    "rhythm totalBeats"
+  );
   if (sounding.length === 0) {
     return emptyAnalysis();
   }
-  const firstOnset = sounding.reduce(
-    (min, n) => Math.min(min, n.startBeat),
-    Number.POSITIVE_INFINITY
-  );
-  const startBeat = barGridStart(firstOnset, meters);
-  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const endBeat = Math.max(startBeat, _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);
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, 
+    Math.ceil(bars) * BUDGET_SLOTS_PER_BAR,
+    "rhythm analysis slots",
+    opts.budget
+  );
   const onsets = foldOnsets(sounding);
   const snapped = onsets.map((onset) => snapOnset(onset, meters));
   const onsetDensity = bars > 0 ? onsets.length / bars : 0;
-  const firstBar = _chunkS5BKZZGMcjs.barIndexAt.call(void 0, startBeat, meters);
+  const firstBar = _chunkS3QELJUEcjs.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;
+    const index = _chunkS3QELJUEcjs.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);
+  const onsetLevels = new Array(RHYTHM_LEVEL_COUNT).fill(0);
   let offGridCount = 0;
   for (const onset of snapped) {
     onsetLevels[onset.level] = (_nullishCoalesce(onsetLevels[onset.level], () => ( 0))) + 1;
@@ -4303,7 +4608,7 @@ function analyzeRhythm(notes, opts = {}) {
     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);
+      const slotsPerBar = Math.ceil(_chunkS3QELJUEcjs.beatsPerBar.call(void 0, onset.ts) * RHYTHM_SLOTS_PER_BEAT);
       profiles.push({
         ts: onset.ts,
         slotsPerBar,
@@ -4357,40 +4662,37 @@ function analyzeRhythm(notes, opts = {}) {
   };
 }
 
-// src/analyze/reference/types.ts
-var REFERENCE_PROFILE_VERSION = 1;
-
 // src/analyze/reference/validate.ts
 var MASS_TOLERANCE = 1e-9;
 function assertString(value, name) {
   if (typeof value !== "string") {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be a string; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, value)}`);
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${name} must be a string; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, value)}`);
   }
   return value;
 }
 function assertSpanOrder(startBeat, endBeat, name) {
   if (endBeat < startBeat) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.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`);
+    throw new (0, _chunkS3QELJUEcjs.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);
+  const shares = _chunkS3QELJUEcjs.assertArray.call(void 0, value, name);
   if (shares.length !== length) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must have length ${length}; received ${shares.length}`);
+    throw new (0, _chunkS3QELJUEcjs.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}]`);
+    const share = _chunkS3QELJUEcjs.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}`);
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(`${name}[${index}] must be at least 0; received ${share}`);
     }
     sum += share;
   }
@@ -4398,37 +4700,37 @@ function assertMassDistribution(value, length, name, allowAllZero) {
     return shares;
   }
   if (Math.abs(sum - 1) > MASS_TOLERANCE) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must sum to 1; received ${sum}`);
+    throw new (0, _chunkS3QELJUEcjs.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);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  _chunkS3QELJUEcjs.assertTimeSignature.call(void 0, read.ts, `${name}.ts`);
+  const slotsPerBar = _chunkS3QELJUEcjs.assertPositiveInt.call(void 0, read.slotsPerBar, `${name}.slotsPerBar`);
+  const onsets = _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  const onsets = _chunkS3QELJUEcjs.assertInteger.call(void 0, read.onsets, `${name}.onsets`, 0);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  const barOnsets = _chunkS3QELJUEcjs.assertArray.call(void 0, read.barOnsets, `${name}.barOnsets`);
   for (let index = 0; index < barOnsets.length; index += 1) {
-    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
+    _chunkS3QELJUEcjs.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`);
+  assertMassDistribution(read.onsetLevels, RHYTHM_LEVEL_COUNT, `${name}.onsetLevels`, onsets === 0);
+  const barPositions = _chunkS3QELJUEcjs.assertArray.call(void 0, read.barPositions, `${name}.barPositions`);
   for (let index = 0; index < barPositions.length; index += 1) {
     assertBarPositionProfile(barPositions[index], `${name}.barPositions[${index}]`);
   }
@@ -4438,67 +4740,71 @@ function assertRhythmAnalysis(value, name) {
     `${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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.restRatio, 0, 1, `${name}.restRatio`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.syncopation, 0, 1, `${name}.syncopation`);
+  _chunkS3QELJUEcjs.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);
+  const read = _chunkS3QELJUEcjs.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`);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.bars`);
+  _chunkS3QELJUEcjs.assertInteger.call(void 0, read.firstOccurrence, `${name}.firstOccurrence`, 0, Math.max(sectionCount - 1, 0));
+  _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.atBeat, `${name}.atBeat`);
+  _chunkS3QELJUEcjs.assertOneOf.call(void 0, read.type, CADENCE_TYPES, `${name}.type`);
+  _chunkS3QELJUEcjs.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}`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  _chunkS3QELJUEcjs.assertOneOf.call(void 0, read.shape, MELODIC_CONTOUR_SHAPES, `${name}.shape`);
+  _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, read.low, `${name}.low`);
+  _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, read.high, `${name}.high`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.mean, 0, MIDI_MAX, `${name}.mean`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.peakPitch, 0, MIDI_MAX, `${name}.peakPitch`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.peakPosition, 0, 1, `${name}.peakPosition`);
+  const outline = _chunkS3QELJUEcjs.assertArray.call(void 0, read.outline, `${name}.outline`);
+  if (outline.length !== PHRASE_OUTLINE_POINTS) {
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `${name}.outline must have length ${PHRASE_OUTLINE_POINTS}; received ${outline.length}`
+    );
   }
   for (let index = 0; index < outline.length; index += 1) {
-    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, outline[index], `${name}.outline[${index}]`);
+    _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  _chunkS3QELJUEcjs.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`);
+function assertReferencePhrase(value, name, span, sectionCount, nodeCount) {
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, startBeat, span.startBeat, span.endBeat, `${name}.startBeat`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, endBeat, span.startBeat, span.endBeat, `${name}.endBeat`);
+  _chunkS3QELJUEcjs.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))
+    (v, n) => _chunkS3QELJUEcjs.assertInteger.call(void 0, v, n, 0, Math.max(sectionCount - 1, 0))
   );
-  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.confidence, 0, 1, `${name}.confidence`);
+  _chunkS3QELJUEcjs.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`);
+  const motifNodes = _chunkS3QELJUEcjs.assertArray.call(void 0, read.motifNodes, `${name}.motifNodes`);
   for (let index = 0; index < motifNodes.length; index += 1) {
-    _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+    _chunkS3QELJUEcjs.assertInteger.call(void 0, 
       motifNodes[index],
       `${name}.motifNodes[${index}]`,
       0,
@@ -4507,74 +4813,80 @@ function assertReferencePhrase(value, name, sectionCount, nodeCount) {
   }
   return read;
 }
-function assertReferenceForm(value, name, nodeCount) {
-  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
-  const hypermeter = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+function assertReferenceForm(value, name, span, nodeCount) {
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const hypermeter = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, hypermeter.groupBars, 0, Number.MAX_SAFE_INTEGER, `${name}.hypermeter.groupBars`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, hypermeter.confidence, 0, 1, `${name}.hypermeter.confidence`);
+  const sections = _chunkS3QELJUEcjs.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`);
+  const phrases = _chunkS3QELJUEcjs.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);
+    assertReferencePhrase(
+      phrases[index],
+      `${name}.phrases[${index}]`,
+      span,
+      sections.length,
+      nodeCount
+    );
   }
   return read;
 }
 function assertResolvedKeyField(value, name) {
-  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
   try {
-    _chunk3R3QVKY5cjs.resolveKey.call(void 0, read);
+    _chunkYDGMWH43cjs.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}`);
+    if (error instanceof _chunkS3QELJUEcjs.InvalidInputError) {
+      throw new (0, _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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 keyIndex = _chunkS3QELJUEcjs.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}`
+    if (error instanceof _chunkS3QELJUEcjs.InvalidInputError) {
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+        `${name}.roman must be readable by romanToChord; received ${_chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertOneOf.call(void 0, read.function, HARMONIC_FUNCTIONS, `${name}.function`);
+  _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const keys = _chunkS3QELJUEcjs.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`);
+  const chords = _chunkS3QELJUEcjs.assertArray.call(void 0, read.chords, `${name}.chords`);
   for (let index = 0; index < chords.length; index += 1) {
     assertReferenceChord(chords[index], `${name}.chords[${index}]`, resolvedKeys);
   }
@@ -4582,78 +4894,78 @@ function assertReferenceHarmony(value, name) {
   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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  _chunkS3QELJUEcjs.assertOneOf.call(void 0, read.kind, MOTIF_RELATION_KINDS, `${name}.kind`);
+  _chunkS3QELJUEcjs.assertFlag.call(void 0, read.sequence, `${name}.sequence`);
+  _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.semitones, `${name}.semitones`);
   if (read.degrees !== void 0) {
-    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.degrees, `${name}.degrees`);
+    _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.degrees, `${name}.degrees`);
   }
-  const timeRatio = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.timeRatio, `${name}.timeRatio`);
+  const timeRatio = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.timeRatio, `${name}.timeRatio`);
   if (timeRatio <= 0) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.timeRatio must be positive; received ${timeRatio}`);
+    throw new (0, _chunkS3QELJUEcjs.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, 
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const motif = _chunkS3QELJUEcjs.assertInteger.call(void 0, 
     read.motif,
     `${name}.motif`,
     0,
     Math.max(occurrenceCounts.length - 1, 0)
   );
-  _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+  _chunkS3QELJUEcjs.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`);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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));
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const from = _chunkS3QELJUEcjs.assertInteger.call(void 0, read.from, `${name}.from`, 0, Math.max(nodeCount - 1, 0));
+  const to = _chunkS3QELJUEcjs.assertInteger.call(void 0, read.to, `${name}.to`, 0, Math.max(nodeCount - 1, 0));
   if (from >= to) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const nodes = _chunkS3QELJUEcjs.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 edges = _chunkS3QELJUEcjs.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`);
+      throw new (0, _chunkS3QELJUEcjs.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`);
+  const read = _chunkS3QELJUEcjs.assertRecord.call(void 0, value, name);
+  const intervals = _chunkS3QELJUEcjs.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}]`);
+    const interval = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, intervals[index], `${name}.intervals[${index}]`);
     if (!Number.isInteger(interval)) {
-      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
         `${name}.intervals[${index}] must be a whole number of semitones; received ${interval}`
       );
     }
@@ -4661,44 +4973,44 @@ function assertReferenceMotif(value, name) {
     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}`
+  if (high - low > MIDI_MAX) {
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `${name}.intervals must span at most ${MIDI_MAX} semitones; received ${high - low}`
     );
   }
-  const rhythm = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.rhythm, `${name}.rhythm`);
+  const rhythm = _chunkS3QELJUEcjs.assertArray.call(void 0, read.rhythm, `${name}.rhythm`);
   if (rhythm.length !== intervals.length) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.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}]`);
+    const ratio2 = _chunkS3QELJUEcjs.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}`);
+      throw new (0, _chunkS3QELJUEcjs.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`);
+  const unitBeats = _chunkS3QELJUEcjs.assertRange.call(void 0, read.unitBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.unitBeats`);
   if (unitBeats > 0 !== rhythm.length > 0) {
-    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+    throw new (0, _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, read.spanBeats, 0, Number.MAX_SAFE_INTEGER, `${name}.spanBeats`);
+  _chunkS3QELJUEcjs.assertPositiveInt.call(void 0, read.occurrences, `${name}.occurrences`);
   return read;
 }
 function assertReferenceMelody(value, name) {
-  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const read = _chunkS3QELJUEcjs.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`);
+    const register = _chunkS3QELJUEcjs.assertRecord.call(void 0, v, n);
+    _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, register.low, `${n}.low`);
+    _chunkS3QELJUEcjs.assertMidiPitch.call(void 0, register.high, `${n}.high`);
+    _chunkS3QELJUEcjs.assertRange.call(void 0, register.mean, 0, MIDI_MAX, `${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`);
+  assertNullable(read.shape, `${name}.shape`, (v, n) => _chunkS3QELJUEcjs.assertOneOf.call(void 0, v, MELODIC_CONTOUR_SHAPES, n));
+  const motifs = _chunkS3QELJUEcjs.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}]`);
@@ -4709,23 +5021,23 @@ function assertReferenceMelody(value, name) {
   return read;
 }
 function assertReferenceProfile(value, name = "reference profile") {
-  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const read = _chunkS3QELJUEcjs.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)}`
+    throw new (0, _chunkS3QELJUEcjs.InvalidInputError)(
+      `${name}.profileVersion must be ${REFERENCE_PROFILE_VERSION}; received ${_chunkS3QELJUEcjs.describeRejected.call(void 0, read.profileVersion)}`
     );
   }
-  const span = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+  const span = _chunkS3QELJUEcjs.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`);
+  const startBeat = _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, span.startBeat, `${name}.span.startBeat`);
+  const endBeat = _chunkS3QELJUEcjs.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`);
+  _chunkS3QELJUEcjs.assertRange.call(void 0, span.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.span.bars`);
+  _chunkS3QELJUEcjs.assertMeterMap.call(void 0, read.meters, `${name}.meters`);
   const melody = assertReferenceMelody(read.melody, `${name}.melody`);
-  assertReferenceForm(read.form, `${name}.form`, melody.graph.nodes.length);
+  assertReferenceForm(read.form, `${name}.form`, { startBeat, endBeat }, melody.graph.nodes.length);
   assertReferenceHarmony(read.harmony, `${name}.harmony`);
   return read;
 }
@@ -4742,11 +5054,12 @@ var PEAK_POSITION_WEIGHT = 0.5;
 var FAMILY_SIZE_BINS = 5;
 var DEPTH_BINS = 4;
 var NAMED_CHORDS = ["Ger", "It", "Fr", "N"];
-var PITCH_PRESERVING = /* @__PURE__ */ new Set([
+var PITCH_PRESERVING_KINDS = [
   "repetition",
   "augmentation",
   "diminution"
-]);
+];
+var PITCH_PRESERVING = new Set(PITCH_PRESERVING_KINDS);
 var CELL_START_PITCH = 60;
 function whenBoth(hasA, hasB, measure) {
   if (!hasA && !hasB) {
@@ -4821,7 +5134,7 @@ function chordCost(x, y) {
   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);
+  _chunkS3QELJUEcjs.assertGenerationBudget.call(void 0, a.length * b.length, "reference progression alignment", budget);
   return alignedSimilarity(a, b, chordCost, PROGRESSION_GAP);
 }
 function functionMass(chords) {
@@ -4845,7 +5158,7 @@ function cadenceSimilarity(a, b) {
   });
 }
 function keyTokens(keys) {
-  const home = _nullishCoalesce(_optionalChain([keys, 'access', _115 => _115[0], 'optionalAccess', _116 => _116.scale, 'access', _117 => _117.rootPc]), () => ( 0));
+  const home = _nullishCoalesce(_optionalChain([keys, 'access', _129 => _129[0], 'optionalAccess', _130 => _130.scale, 'access', _131 => _131.rootPc]), () => ( 0));
   return keys.map((key) => ({
     distance: ((key.scale.rootPc - home) % 12 + 12) % 12,
     mask: key.scale.modeMask12
@@ -4899,7 +5212,7 @@ function cellNotes(motif) {
     low = Math.min(low, offset);
     high = Math.max(high, offset);
   }
-  let pitch = Math.min(127 - high, Math.max(-low, CELL_START_PITCH));
+  let pitch = Math.min(MIDI_MAX - high, Math.max(-low, CELL_START_PITCH));
   let beat = 0;
   for (let i = 0; i <= motif.intervals.length; i += 1) {
     const step = _nullishCoalesce(motif.rhythm[i], () => ( 1));
@@ -4955,7 +5268,7 @@ 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]);
+    const kind = _optionalChain([edge, 'access', _132 => _132.relation, 'optionalAccess', _133 => _133.kind]);
     bump(
       kinds,
       kind === void 0 ? MOTIF_RELATION_KINDS.length : MOTIF_RELATION_KINDS.indexOf(kind)
@@ -4967,7 +5280,7 @@ function summarise({ graph, spanBeats }) {
   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 kind = _optionalChain([edge, 'access', _134 => _134.relation, 'optionalAccess', _135 => _135.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));
@@ -5055,7 +5368,7 @@ function weightedMean(notes) {
   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) => ({
+  const inside = line.filter((note) => note.startBeat >= startBeat - _chunkS3QELJUEcjs.BEAT_EPS && note.startBeat < endBeat - _chunkS3QELJUEcjs.BEAT_EPS).map((note) => ({
     ...note,
     durationBeat: Math.min(note.startBeat + note.durationBeat, endBeat) - note.startBeat
   }));
@@ -5073,18 +5386,18 @@ function phraseMelody(line, startBeat, endBeat, lineMean, meters, budget) {
   }
   const length = endBeat - startBeat;
   const outline = [];
-  for (let k = 0; k < 8; k += 1) {
-    const at = startBeat + (k + 0.5) * length / 8;
+  for (let k = 0; k < PHRASE_OUTLINE_POINTS; k += 1) {
+    const at = startBeat + (k + 0.5) * length / PHRASE_OUTLINE_POINTS;
     let held = first;
     for (const note of inside) {
-      if (note.startBeat > at + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      if (note.startBeat > at + _chunkS3QELJUEcjs.BEAT_EPS) {
         break;
       }
       held = note;
     }
     outline.push(held.pitch - lineMean);
   }
-  const rhythm = analyzeRhythm(inside, { meters, totalBeats: endBeat, budget });
+  const rhythm = rhythmOver(inside, { meters, totalBeats: endBeat, budget }, startBeat);
   return {
     shape: melodicContour(inside).shape,
     low,
@@ -5191,5 +5504,10 @@ function phraseMelody(line, startBeat, endBeat, lineMean, meters, budget) {
 
 
 
-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
+
+
+
+
+
+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.barSpanOf = barSpanOf; exports.clamp01 = clamp01; exports.floorMod = floorMod; exports.firstSoundingBeat = firstSoundingBeat; exports.resolveSpanEnd = resolveSpanEnd; exports.lastBarOf = lastBarOf; exports.sliceBars = sliceBars; exports.weightSimilarity = weightSimilarity; exports.harmonicNovelty = harmonicNovelty; exports.combineEvidence = combineEvidence; 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.gridForNotes = gridForNotes; exports.latestSoundingEnd = latestSoundingEnd; 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.assertSpansInOrder = assertSpansInOrder; exports.statedKeyRegions = statedKeyRegions; 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.REFERENCE_PROFILE_VERSION = REFERENCE_PROFILE_VERSION; 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.rhythmOver = rhythmOver; exports.assertReferenceProfile = assertReferenceProfile; exports.weightedMean = weightedMean; exports.phraseMelody = phraseMelody;
+//# sourceMappingURL=chunk-LQZQDBCD.cjs.map