@libraz/libcantus 1.0.1 → 1.2.0

package/dist/chunk-B6XNKWZV.cjs

@@ -1,3224 +0,0 @@
-"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 _chunkOE6WK2Y2cjs = require('./chunk-OE6WK2Y2.cjs');
-
-
-
-
-
-
-
-
-var _chunkK4ZJUGF4cjs = require('./chunk-K4ZJUGF4.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkQ2WGKJNNcjs = require('./chunk-Q2WGKJNN.cjs');
-
-// src/analyze/grid.ts
-var EPS = 1e-9;
-var PICKUP_JITTER = 0.05;
-function gridOriginOf(firstOnset, slotBeats) {
-  if (firstOnset >= -PICKUP_JITTER) {
-    return { origin: 0, startBeat: 0 };
-  }
-  return { origin: Math.floor(firstOnset / slotBeats + EPS) * slotBeats, startBeat: firstOnset };
-}
-
-// src/analyze/histogram.ts
-var EPS2 = 1e-9;
-function bucketNotesBySlot(notes, grid, slotCount, opts) {
-  const buckets = Array.from({ length: slotCount }, () => []);
-  let memberships = 0;
-  for (const note of notes) {
-    const first = Math.max(0, Math.floor((note.startBeat - grid.origin) / grid.slotBeats));
-    const lastExclusive = Math.min(
-      slotCount,
-      Math.ceil((note.startBeat + note.durationBeat - grid.origin) / grid.slotBeats)
-    );
-    memberships += Math.max(0, lastExclusive - first);
-    _chunkQ2WGKJNNcjs.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)]);
-    }
-  }
-  return buckets;
-}
-function windowWeights(notes, windowStart, windowEnd, meter) {
-  const weights = new Array(12).fill(0);
-  let lowestPitch = Number.POSITIVE_INFINITY;
-  for (const note of notes) {
-    const noteEnd = note.startBeat + note.durationBeat;
-    const overlap = Math.min(noteEnd, windowEnd) - Math.max(note.startBeat, windowStart);
-    if (overlap <= EPS2) {
-      continue;
-    }
-    const velocityFactor = note.velocity !== void 0 ? note.velocity / 127 : 1;
-    const onsetInWindow = note.startBeat >= windowStart - EPS2 && note.startBeat < windowEnd - EPS2;
-    const accent = onsetInWindow ? 1 + _chunkK4ZJUGF4cjs.metricWeight.call(void 0, note.startBeat, meter) / 3 : 1;
-    const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, note.pitch);
-    weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + overlap * velocityFactor * accent;
-    if (note.pitch < lowestPitch) {
-      lowestPitch = note.pitch;
-    }
-  }
-  let totalWeight = 0;
-  let maxWeight = 0;
-  for (const w of weights) {
-    totalWeight += w;
-    maxWeight = Math.max(maxWeight, w);
-  }
-  return { weights, totalWeight, maxWeight, lowestPitch };
-}
-
-// src/analyze/keys/index.ts
-var EPS3 = 1e-9;
-var PITCH_CLASSES = 12;
-var EMPTY_WEIGHTS = {
-  weights: new Array(PITCH_CLASSES).fill(0),
-  totalWeight: 0,
-  maxWeight: 0,
-  lowestPitch: Number.POSITIVE_INFINITY
-};
-var MAX_METRIC_WEIGHT = 3;
-var MODULATION_COST = 0.15;
-var PAST_CONTEXT_SHARE = 0.5;
-var FUTURE_CONTEXT_SHARE = 0.25;
-var STRONG_BEAT_DISCOUNT = 0.4;
-var FIFTHS_DISTANCE_COST = 0.18;
-var KEY_CANDIDATES = (() => {
-  const candidates = [];
-  for (let rootPc = 0; rootPc < 12; rootPc += 1) {
-    candidates.push({ key: _chunkUADYAYATcjs.majorKey.call(void 0, rootPc), rootPc, minor: false });
-    candidates.push({ key: _chunkUADYAYATcjs.minorKey.call(void 0, rootPc), rootPc, minor: true });
-  }
-  return candidates;
-})();
-function fifthsOf(rootPc, minor) {
-  const majorRoot = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, minor ? rootPc + 3 : rootPc);
-  const raw = majorRoot * 7 % 12;
-  return raw > 6 ? raw - 12 : raw;
-}
-function fifthsDistance(a, b) {
-  const diff = Math.abs(a - b) % 12;
-  return Math.min(diff, 12 - diff);
-}
-var CANDIDATE_DISTANCE = KEY_CANDIDATES.map(
-  (from) => KEY_CANDIDATES.map(
-    (to) => fifthsDistance(fifthsOf(from.rootPc, from.minor), fifthsOf(to.rootPc, to.minor))
-  )
-);
-function chooseKeys(slots, changeCost, meter) {
-  const count = KEY_CANDIDATES.length;
-  if (slots.length === 0) {
-    return [];
-  }
-  let costs = (_nullishCoalesce(_optionalChain([slots, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.scores]), () => ( []))).map((score) => -score);
-  const cameFrom = [];
-  for (let i = 1; i < slots.length; i += 1) {
-    const slot = slots[i];
-    const previous = costs;
-    const accent = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, _nullishCoalesce(_optionalChain([slot, 'optionalAccess', _7 => _7.startBeat]), () => ( 0)), meter);
-    const metricFactor = 1 - STRONG_BEAT_DISCOUNT * accent / MAX_METRIC_WEIGHT;
-    const next = new Array(count).fill(0);
-    const back = new Int32Array(count);
-    for (let to = 0; to < count; to += 1) {
-      let best2 = _nullishCoalesce(previous[to], () => ( Number.POSITIVE_INFINITY));
-      let bestFrom = to;
-      for (let from = 0; from < count; from += 1) {
-        if (from === to) {
-          continue;
-        }
-        const distance = _nullishCoalesce(_optionalChain([CANDIDATE_DISTANCE, 'access', _8 => _8[from], 'optionalAccess', _9 => _9[to]]), () => ( 0));
-        const penalty = changeCost * metricFactor * (1 + FIFTHS_DISTANCE_COST * distance);
-        const cost = (_nullishCoalesce(previous[from], () => ( Number.POSITIVE_INFINITY))) + penalty;
-        if (cost < best2) {
-          best2 = cost;
-          bestFrom = from;
-        }
-      }
-      back[to] = bestFrom;
-      next[to] = best2 - (_nullishCoalesce(_optionalChain([slot, 'optionalAccess', _10 => _10.scores, 'access', _11 => _11[to]]), () => ( 0)));
-    }
-    costs = next;
-    cameFrom.push(back);
-  }
-  let best = 0;
-  for (let c = 1; c < count; c += 1) {
-    if ((_nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY))) < (_nullishCoalesce(costs[best], () => ( Number.POSITIVE_INFINITY)))) {
-      best = c;
-    }
-  }
-  const path = new Array(slots.length);
-  let current = best;
-  for (let i = slots.length - 1; i >= 0; i -= 1) {
-    path[i] = current;
-    if (i > 0) {
-      current = _nullishCoalesce(_optionalChain([cameFrom, 'access', _12 => _12[i - 1], 'optionalAccess', _13 => _13[current]]), () => ( current));
-    }
-  }
-  return path;
-}
-function regionsFromPath(slots, path) {
-  const regions = [];
-  for (let i = 0; i < slots.length; i += 1) {
-    const last = regions[regions.length - 1];
-    const slot = slots[i];
-    if (slot === void 0) {
-      continue;
-    }
-    if (last !== void 0 && last.candidate === path[i]) {
-      last.endBeat = slot.endBeat;
-      last.toExclusive = i + 1;
-      continue;
-    }
-    regions.push({
-      startBeat: slot.startBeat,
-      endBeat: slot.endBeat,
-      candidate: _nullishCoalesce(path[i], () => ( 0)),
-      from: i,
-      toExclusive: i + 1
-    });
-  }
-  return regions;
-}
-function enforceMinimumRegion(slots, path, minBeats) {
-  const chosen = [...path];
-  for (; ; ) {
-    const regions = regionsFromPath(slots, chosen);
-    let shortest;
-    let before;
-    let after;
-    for (let i = 0; i < regions.length; i += 1) {
-      const region = regions[i];
-      if (region === void 0 || region.endBeat - region.startBeat >= minBeats - EPS3) {
-        continue;
-      }
-      const previous = regions[i - 1];
-      const next = regions[i + 1];
-      const left2 = previous !== void 0 && Math.abs(previous.endBeat - region.startBeat) < EPS3 ? previous : void 0;
-      const right2 = next !== void 0 && Math.abs(next.startBeat - region.endBeat) < EPS3 ? next : void 0;
-      if (left2 === void 0 && right2 === void 0) {
-        continue;
-      }
-      if (shortest !== void 0 && region.endBeat - region.startBeat >= shortest.endBeat - shortest.startBeat) {
-        continue;
-      }
-      shortest = region;
-      before = left2;
-      after = right2;
-    }
-    if (shortest === void 0) {
-      return chosen;
-    }
-    const merging = shortest;
-    const scoreOver = (candidate) => {
-      let total = 0;
-      for (let i = merging.from; i < merging.toExclusive; i += 1) {
-        total += _nullishCoalesce(_optionalChain([slots, 'access', _14 => _14[i], 'optionalAccess', _15 => _15.scores, 'access', _16 => _16[candidate]]), () => ( 0));
-      }
-      return total;
-    };
-    const left = _optionalChain([before, 'optionalAccess', _17 => _17.candidate]);
-    const right = _optionalChain([after, 'optionalAccess', _18 => _18.candidate]);
-    const winner = left === void 0 ? _nullishCoalesce(right, () => ( merging.candidate)) : right === void 0 || scoreOver(left) >= scoreOver(right) ? left : right;
-    for (let i = merging.from; i < merging.toExclusive; i += 1) {
-      chosen[i] = winner;
-    }
-  }
-}
-function withRelations(regions) {
-  for (let i = 1; i < regions.length; i += 1) {
-    const previous = regions[i - 1];
-    const current = regions[i];
-    if (previous === void 0 || current === void 0) {
-      continue;
-    }
-    const relation = _chunkUADYAYATcjs.keyRelationBetween.call(void 0, _chunkUADYAYATcjs.spelledKeyOf.call(void 0, previous.key), _chunkUADYAYATcjs.spelledKeyOf.call(void 0, current.key));
-    if (relation !== null && relation !== "same") {
-      current.modulation = relation;
-    }
-  }
-  return regions;
-}
-function keyTimelineFromNotes(notes, opts = {}) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "key timeline meters");
-  const bar = _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, 0, meters);
-  const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
-  const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
-  const budget = opts.budget;
-  _chunkQ2WGKJNNcjs.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));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
-  const slotBeats = Math.min(minKeyBeats, expectedKeyBeats);
-  const firstOnset = sounding.reduce((first, n) => Math.min(first, n.startBeat), 0);
-  const { origin, startBeat: musicStart } = gridOriginOf(firstOnset, slotBeats);
-  const slotCount = Math.max(0, Math.ceil((totalBeats - origin) / slotBeats - EPS3));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, slotCount, "key timeline slots", budget);
-  if (slotCount === 0 || sounding.length === 0) {
-    return [];
-  }
-  const profile = _chunkOE6WK2Y2cjs.resolveKeyProfile.call(void 0, opts.profile);
-  const slotNotes = bucketNotesBySlot(sounding, { origin, slotBeats }, slotCount, {
-    name: "key timeline note-to-slot memberships",
-    budget
-  });
-  const slotWeights = [];
-  for (let i = 0; i < slotCount; i += 1) {
-    const startBeat = origin + i * slotBeats;
-    slotWeights.push(
-      windowWeights(
-        _nullishCoalesce(slotNotes[i], () => ( [])),
-        startBeat,
-        Math.min(startBeat + slotBeats, totalBeats),
-        meters
-      )
-    );
-  }
-  const slots = [];
-  let weightSum = 0;
-  let soundingSlots = 0;
-  for (let i = 0; i < slotCount; i += 1) {
-    const startBeat = origin + i * slotBeats;
-    const endBeat = Math.min(startBeat + slotBeats, totalBeats);
-    const own = _nullishCoalesce(slotWeights[i], () => ( EMPTY_WEIGHTS));
-    const before = _nullishCoalesce(slotWeights[i - 1], () => ( EMPTY_WEIGHTS));
-    const after = _nullishCoalesce(slotWeights[i + 1], () => ( EMPTY_WEIGHTS));
-    const weights = own.weights.map(
-      (weight, pc) => weight + PAST_CONTEXT_SHARE * (_nullishCoalesce(before.weights[pc], () => ( 0))) + FUTURE_CONTEXT_SHARE * (_nullishCoalesce(after.weights[pc], () => ( 0)))
-    );
-    const totalWeight = own.totalWeight;
-    const scores = KEY_CANDIDATES.map(
-      (candidate) => _chunkOE6WK2Y2cjs.profileScore.call(void 0, weights, candidate.minor ? profile.minor : profile.major, candidate.rootPc) * totalWeight
-    );
-    slots.push({ startBeat, endBeat, scores, weight: totalWeight });
-    if (totalWeight > EPS3) {
-      weightSum += totalWeight;
-      soundingSlots += 1;
-    }
-  }
-  if (soundingSlots === 0) {
-    return [];
-  }
-  const meanSlotWeight = weightSum / soundingSlots;
-  const changeCost = MODULATION_COST * meanSlotWeight * (expectedKeyBeats / slotBeats);
-  const path = chooseKeys(slots, changeCost, meters);
-  const grouped = regionsFromPath(slots, path);
-  const regions = grouped.map((region) => {
-    const candidate = KEY_CANDIDATES[region.candidate];
-    const key = _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _19 => _19.key]), () => ( _chunkUADYAYATcjs.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) {
-      const slot = slotWeights[i];
-      if (slot === void 0) {
-        continue;
-      }
-      for (let pc = 0; pc < PITCH_CLASSES; pc += 1) {
-        weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + (_nullishCoalesce(slot.weights[pc], () => ( 0)));
-      }
-    }
-    const correlation = _chunkOE6WK2Y2cjs.profileScore.call(void 0, 
-      weights,
-      _optionalChain([candidate, 'optionalAccess', _20 => _20.minor]) ? profile.minor : profile.major,
-      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _21 => _21.rootPc]), () => ( 0))
-    );
-    return {
-      startBeat,
-      endBeat: region.endBeat,
-      key,
-      confidence: Math.max(0, correlation)
-    };
-  });
-  return withRelations(regions);
-}
-var CHORD_TONE_CREDIT = 1;
-var DOMINANT_CREDIT = 0.7;
-var TONIC_CREDIT = 0.4;
-var CADENCE_CREDIT = 0.6;
-var CHORD_MODULATION_COST = 0.6;
-function chordFitsKey(chord, candidate) {
-  const tones = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord);
-  if (tones.length === 0) {
-    return 0;
-  }
-  let inKey = 0;
-  for (const pc of tones) {
-    if (_chunkUADYAYATcjs.isScaleTone.call(void 0, pc, candidate.key)) {
-      inKey += 1;
-    }
-  }
-  let score = CHORD_TONE_CREDIT * ((inKey - (tones.length - inKey)) / tones.length);
-  const rootDegree = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - candidate.rootPc);
-  if (rootDegree === 7 && (chord.quality === "dom7" || chord.quality === "maj")) {
-    score += DOMINANT_CREDIT * (chord.quality === "dom7" ? 1 : 0.5);
-  }
-  if (rootDegree === 0) {
-    score += TONIC_CREDIT;
-  }
-  return score;
-}
-function detectModulations(chords, opts = {}) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "modulation meters");
-  const bar = _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, 0, meters);
-  const expectedKeyBeats = _nullishCoalesce(opts.expectedKeyBeats, () => ( bar * 4));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
-  const minKeyBeats = _nullishCoalesce(opts.minKeyBeats, () => ( bar));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, chords.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 totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastChordEnd));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "modulation totalBeats");
-  const ordered = sorted.map((segment) => ({ ...segment, endBeat: Math.min(segment.endBeat, totalBeats) })).filter((segment) => segment.endBeat > segment.startBeat);
-  if (ordered.length === 0) {
-    return [];
-  }
-  const slots = ordered.map((segment) => {
-    const length = segment.endBeat - segment.startBeat;
-    return {
-      startBeat: segment.startBeat,
-      endBeat: segment.endBeat,
-      // A chord that holds for two bars argues twice as hard as one that
-      // passes in half a bar, exactly as a heavier slot does in the note path.
-      scores: KEY_CANDIDATES.map((candidate) => chordFitsKey(segment.chord, candidate) * length),
-      weight: length
-    };
-  });
-  for (let i = 1; i < slots.length; i += 1) {
-    const arriving = _optionalChain([ordered, 'access', _22 => _22[i], 'optionalAccess', _23 => _23.chord]);
-    const approaching = _optionalChain([ordered, 'access', _24 => _24[i - 1], 'optionalAccess', _25 => _25.chord]);
-    const slot = slots[i];
-    if (arriving === void 0 || approaching === void 0 || slot === void 0) {
-      continue;
-    }
-    const isDominantMotion = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, approaching.rootPc - arriving.rootPc) === 7 && approaching.quality === "dom7";
-    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 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, arriving.rootPc - candidate.rootPc) === 0) {
-        slot.scores[c] = (_nullishCoalesce(slot.scores[c], () => ( 0))) + CADENCE_CREDIT * length;
-      }
-    }
-  }
-  const changeCost = CHORD_MODULATION_COST * expectedKeyBeats;
-  const path = chooseKeys(slots, changeCost, meters);
-  const grouped = regionsFromPath(
-    slots,
-    enforceMinimumRegion(slots, path, Math.min(minKeyBeats, expectedKeyBeats))
-  );
-  const profile = _chunkOE6WK2Y2cjs.resolveKeyProfile.call(void 0, opts.profile);
-  const regions = grouped.map((region) => {
-    const candidate = KEY_CANDIDATES[region.candidate];
-    const key = _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _26 => _26.key]), () => ( _chunkUADYAYATcjs.majorKey.call(void 0, 0)));
-    const weights = new Array(PITCH_CLASSES).fill(0);
-    for (const segment of ordered) {
-      const overlap = Math.min(segment.endBeat, region.endBeat) - Math.max(segment.startBeat, region.startBeat);
-      if (overlap <= EPS3) {
-        continue;
-      }
-      for (const pc of _chunkUADYAYATcjs.chordPitchClasses.call(void 0, segment.chord)) {
-        weights[pc] = (_nullishCoalesce(weights[pc], () => ( 0))) + overlap;
-      }
-    }
-    const correlation = _chunkOE6WK2Y2cjs.profileScore.call(void 0, 
-      weights,
-      _optionalChain([candidate, 'optionalAccess', _27 => _27.minor]) ? profile.minor : profile.major,
-      _nullishCoalesce(_optionalChain([candidate, 'optionalAccess', _28 => _28.rootPc]), () => ( 0))
-    );
-    return {
-      startBeat: region.startBeat,
-      endBeat: region.endBeat,
-      key,
-      confidence: Math.max(0, correlation)
-    };
-  });
-  const last = regions[regions.length - 1];
-  if (last !== void 0 && totalBeats > last.endBeat) {
-    last.endBeat = totalBeats;
-  }
-  return attachPivots(withRelations(regions), ordered);
-}
-var THIRD_SEMITONES = [3, 4];
-var FIFTH_SEMITONES = [6, 7, 8];
-function triadCore(chord) {
-  const root = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc);
-  let third;
-  let fifth;
-  for (const interval of chord.intervals) {
-    if (interval < 0 || interval >= 12) {
-      continue;
-    }
-    if (third === void 0 && THIRD_SEMITONES.includes(interval)) {
-      third = interval;
-    } else if (fifth === void 0 && FIFTH_SEMITONES.includes(interval)) {
-      fifth = interval;
-    }
-  }
-  if (third === void 0 || fifth === void 0) {
-    return null;
-  }
-  return [root, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, root + third), _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, root + fifth)].sort((a, b) => a - b);
-}
-function sameTones(a, b) {
-  return a.length === b.length && a.every((pc, index) => pc === b[index]);
-}
-function attachPivots(regions, chords) {
-  for (let i = 1; i < regions.length; i += 1) {
-    const previous = regions[i - 1];
-    const current = regions[i];
-    if (previous === void 0 || current === void 0) {
-      continue;
-    }
-    let last;
-    for (const segment of chords) {
-      if (segment.endBeat <= current.startBeat + EPS3) {
-        last = segment;
-      }
-    }
-    if (last === void 0) {
-      continue;
-    }
-    const core = triadCore(last.chord);
-    if (core === null) {
-      continue;
-    }
-    const root = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, last.chord.rootPc);
-    const pivot = _chunkOE6WK2Y2cjs.pivotChords.call(void 0, previous.key, current.key).find(
-      (entry) => entry.chord.rootPc === root && sameTones(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, entry.chord), core)
-    );
-    if (pivot !== void 0) {
-      current.pivot = pivot;
-    }
-  }
-  return regions;
-}
-function keyLookup(regions, fallback) {
-  return (beat) => {
-    let low = 0;
-    let high = regions.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if ((_nullishCoalesce(_optionalChain([regions, 'access', _29 => _29[middle], 'optionalAccess', _30 => _30.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
-        low = middle + 1;
-      } else {
-        high = middle;
-      }
-    }
-    const candidate = regions[low - 1];
-    return candidate !== void 0 && beat < candidate.endBeat ? candidate.key : fallback;
-  };
-}
-function prevailingKeyOf(regions) {
-  const totals = /* @__PURE__ */ new Map();
-  for (const region of regions) {
-    const id = `${_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, region.key.rootPc)}:${region.key.modeMask12}`;
-    const entry = totals.get(id);
-    const length = Math.max(0, region.endBeat - region.startBeat);
-    if (entry === void 0) {
-      totals.set(id, { key: region.key, length });
-    } else {
-      entry.length += length;
-    }
-  }
-  let best = null;
-  let bestLength = -1;
-  for (const entry of totals.values()) {
-    if (entry.length > bestLength) {
-      bestLength = entry.length;
-      best = entry.key;
-    }
-  }
-  return best;
-}
-
-// src/analyze/timeline/index.ts
-function chordTimelineFromChords(chords, totalBeats) {
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
-  for (let index = 0; index < chords.length; index += 1) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, 
-      _nullishCoalesce(_optionalChain([chords, 'access', _31 => _31[index], 'optionalAccess', _32 => _32.startBeat]), () => ( Number.NaN)),
-      -Number.MAX_SAFE_INTEGER,
-      Number.MAX_SAFE_INTEGER,
-      `chords[${index}].startBeat`
-    );
-  }
-  const sorted = [...chords].filter((chord) => chord.startBeat < totalBeats).sort((a, b) => a.startBeat - b.startBeat);
-  const segments = sorted.map((gc, i) => {
-    const next = sorted[i + 1];
-    const nextBeat = next ? next.startBeat : totalBeats;
-    const endBeat = Math.min(totalBeats, Math.max(gc.startBeat, nextBeat));
-    return {
-      startBeat: gc.startBeat,
-      endBeat,
-      chord: _chunkUADYAYATcjs.chordFromSpan.call(void 0, gc)
-    };
-  }).filter((seg) => seg.endBeat > seg.startBeat);
-  return { at: segmentLookup(segments), segments };
-}
-function segmentLookup(segments) {
-  return (beat) => {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
-    let low = 0;
-    let high = segments.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if ((_nullishCoalesce(_optionalChain([segments, 'access', _33 => _33[middle], 'optionalAccess', _34 => _34.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
-        low = middle + 1;
-      } else {
-        high = middle;
-      }
-    }
-    const candidate = segments[low - 1];
-    return candidate !== void 0 && beat >= candidate.startBeat && beat < candidate.endBeat ? candidate.chord : null;
-  };
-}
-var EPS4 = 1e-9;
-var NOISE_THRESHOLD_RATIO = 0.2;
-var MAX_DETECTION_PCS = 6;
-var INEXACT_CONFIDENCE_FACTOR = 0.85;
-var DIATONIC_BONUS = 0.5;
-var EXACT_BONUS = 0.5;
-var EXTRA_TONE_PENALTY = 0.6;
-var OMITTED_TONE_PENALTY = 0.15;
-var BASS_ROOT_STANDING = 0.95;
-function scoreMatch(match, weights, maxWeight, key) {
-  const rootWeight = maxWeight > 0 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
-  const rootStanding = match.inversion === 0 ? Math.max(rootWeight, BASS_ROOT_STANDING) : rootWeight;
-  const tones = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, match.rootPc, match.quality));
-  let score = rootStanding;
-  if (tones.every((pc) => _chunkUADYAYATcjs.isScaleTone.call(void 0, pc, key))) {
-    score += DIATONIC_BONUS;
-  }
-  if (match.exact) {
-    score += EXACT_BONUS;
-  }
-  score -= EXTRA_TONE_PENALTY * match.extraPcs.length;
-  score -= OMITTED_TONE_PENALTY * match.missingPcs.length;
-  return score;
-}
-function chordConfidence(chord, weights, totalWeight, exact) {
-  const tones = new Set(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord));
-  let chordWeight = 0;
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (tones.has(pc)) {
-      chordWeight += _nullishCoalesce(weights[pc], () => ( 0));
-    }
-  }
-  const raw = totalWeight > 0 ? chordWeight / totalWeight : 0;
-  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 <= EPS4) {
-    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 = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, lowestPitch);
-  const hasBass = selected.includes(bassPc);
-  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
-  const matches = _chunkOE6WK2Y2cjs.detectChord.call(void 0, detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
-  let bestMatch = null;
-  let bestScore = Number.NEGATIVE_INFINITY;
-  for (const match of matches) {
-    const score = scoreMatch(match, weights, maxWeight, key);
-    if (score > bestScore) {
-      bestScore = score;
-      bestMatch = match;
-    }
-  }
-  if (bestMatch) {
-    const augmented = hasBass ? _chunkOE6WK2Y2cjs.augmentedSixthFromPitchClasses.call(void 0, selected, bassPc, key) : null;
-    if (augmented !== null) {
-      return {
-        chord: augmented,
-        confidence: chordConfidence(augmented, weights, totalWeight, true)
-      };
-    }
-    const chord = _chunkUADYAYATcjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
-    return { chord, confidence: chordConfidence(chord, weights, totalWeight, bestMatch.exact) };
-  }
-  return null;
-}
-function sameChord(a, b) {
-  return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;
-}
-var SEGMENTATION_QUALITIES = [
-  "maj",
-  "min",
-  "dim",
-  "aug",
-  "dom7",
-  "maj7",
-  "min7",
-  "m7b5",
-  "dim7",
-  "sus4",
-  "6",
-  "min6"
-];
-var LEXICON_SIZE = 12 * SEGMENTATION_QUALITIES.length;
-var LEXICON_ROOTS = new Int32Array(LEXICON_SIZE);
-var LEXICON_TONE_START = new Int32Array(LEXICON_SIZE + 1);
-var LEXICON_TONES = (() => {
-  const tones = [];
-  let candidate = 0;
-  for (let rootPc = 0; rootPc < 12; rootPc += 1) {
-    for (const quality of SEGMENTATION_QUALITIES) {
-      LEXICON_ROOTS[candidate] = rootPc;
-      LEXICON_TONE_START[candidate] = tones.length;
-      tones.push(..._chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, quality)));
-      candidate += 1;
-    }
-  }
-  LEXICON_TONE_START[candidate] = tones.length;
-  return Int32Array.from(tones);
-})();
-var OUTSIDE_TONE_PENALTY = 1;
-var MISSING_TONE_PENALTY = 0.5;
-var ROOT_PRESENCE_BONUS = 0.3;
-var CHANGE_COST = 0.35;
-var STRONG_BEAT_DISCOUNT2 = 0.5;
-var MAX_METRIC_WEIGHT2 = 3;
-function candidateScore(candidate, weights, totalWeight) {
-  const first = _nullishCoalesce(LEXICON_TONE_START[candidate], () => ( 0));
-  const last = _nullishCoalesce(LEXICON_TONE_START[candidate + 1], () => ( first));
-  let covered = 0;
-  let missing = 0;
-  for (let index = first; index < last; index += 1) {
-    const weight = _nullishCoalesce(weights[_nullishCoalesce(LEXICON_TONES[index], () => ( 0))], () => ( 0));
-    covered += weight;
-    if (weight <= EPS4) {
-      missing += 1;
-    }
-  }
-  const outside = totalWeight - covered;
-  const averageToneWeight = totalWeight / (last - first);
-  return covered - OUTSIDE_TONE_PENALTY * outside - MISSING_TONE_PENALTY * missing * averageToneWeight + ROOT_PRESENCE_BONUS * (_nullishCoalesce(weights[_nullishCoalesce(LEXICON_ROOTS[candidate], () => ( 0))], () => ( 0)));
-}
-function beatOfSlot(grid, index) {
-  return grid.origin + index * grid.slotBeats;
-}
-function slotOfBeat(grid, beat) {
-  return (beat - grid.origin) / grid.slotBeats;
-}
-function createBoundaryTables(slotCount) {
-  return {
-    scores: new Float64Array(slotCount * LEXICON_SIZE),
-    back: new Int32Array(slotCount * LEXICON_SIZE),
-    costs: new Float64Array(LEXICON_SIZE),
-    spare: new Float64Array(LEXICON_SIZE),
-    path: new Int32Array(slotCount)
-  };
-}
-function scoreSlot(tables, slot, index) {
-  const base = index * LEXICON_SIZE;
-  if (slot.totalWeight <= EPS4) {
-    tables.scores.fill(0, base, base + LEXICON_SIZE);
-    return;
-  }
-  for (let c = 0; c < LEXICON_SIZE; c += 1) {
-    tables.scores[base + c] = candidateScore(c, slot.weights, slot.totalWeight);
-  }
-}
-function chooseBoundaries(tables, from, to, grid, meters, changeCost) {
-  const width = to - from;
-  if (width <= 0) {
-    return [];
-  }
-  const { scores, back, path } = tables;
-  let costs = tables.costs;
-  let next = tables.spare;
-  for (let c = 0; c < LEXICON_SIZE; c += 1) {
-    costs[c] = -(_nullishCoalesce(scores[from * LEXICON_SIZE + c], () => ( 0)));
-  }
-  for (let i = 1; i < width; i += 1) {
-    let cheapest = Number.POSITIVE_INFINITY;
-    let cheapestIndex = 0;
-    for (let c = 0; c < LEXICON_SIZE; c += 1) {
-      const cost = _nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY));
-      if (cost < cheapest) {
-        cheapest = cost;
-        cheapestIndex = c;
-      }
-    }
-    const slotStart = beatOfSlot(grid, from + i);
-    const accent = _chunkK4ZJUGF4cjs.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;
-    for (let c = 0; c < LEXICON_SIZE; c += 1) {
-      const stay = _nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY));
-      const carried = stay <= change ? stay : change;
-      back[rowBase + c] = stay <= change ? c : cheapestIndex;
-      next[c] = carried - (_nullishCoalesce(scores[rowBase + c], () => ( 0)));
-    }
-    const previous = costs;
-    costs = next;
-    next = previous;
-  }
-  let best = 0;
-  for (let c = 1; c < LEXICON_SIZE; c += 1) {
-    if ((_nullishCoalesce(costs[c], () => ( Number.POSITIVE_INFINITY))) < (_nullishCoalesce(costs[best], () => ( Number.POSITIVE_INFINITY)))) {
-      best = c;
-    }
-  }
-  let current = best;
-  for (let i = width - 1; i >= 0; i -= 1) {
-    path[from + i] = current;
-    if (i > 0) {
-      current = _nullishCoalesce(back[(from + i) * LEXICON_SIZE + current], () => ( current));
-    }
-  }
-  const spans = [];
-  let runStart = 0;
-  for (let i = 1; i <= width; i += 1) {
-    if (i === width || path[from + i] !== path[from + runStart]) {
-      spans.push({
-        startBeat: beatOfSlot(grid, from + runStart),
-        endBeat: beatOfSlot(grid, from + i)
-      });
-      runStart = i;
-    }
-  }
-  return spans;
-}
-var DEFAULT_MIN_CHORD_BEATS = 1;
-function slotBeatsWithin(harmonicRhythm, minChordBeats) {
-  const divisions = Math.max(1, Math.ceil(harmonicRhythm / minChordBeats - EPS4));
-  return harmonicRhythm / divisions;
-}
-function gridSpans(slotCount, grid) {
-  return Array.from({ length: slotCount }, (_, i) => ({
-    startBeat: beatOfSlot(grid, i),
-    endBeat: beatOfSlot(grid, i + 1)
-  }));
-}
-function dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters) {
-  const slotBeats = grid.slotBeats;
-  const slotCount = slotWeights.length;
-  let soundingSlots = 0;
-  let weightSum = 0;
-  for (let i = 0; i < slotCount; i += 1) {
-    const weight = _nullishCoalesce(_optionalChain([slotWeights, 'access', _35 => _35[i], 'optionalAccess', _36 => _36.totalWeight]), () => ( 0));
-    if (weight > EPS4) {
-      soundingSlots += 1;
-      weightSum += weight;
-    }
-  }
-  if (soundingSlots === 0) {
-    return [];
-  }
-  const meanSlotWeight = weightSum / soundingSlots;
-  const changeCost = CHANGE_COST * meanSlotWeight * (harmonicRhythm / slotBeats);
-  const silent = slotWeights.map((slot) => slot.totalWeight <= EPS4);
-  const breaks = new Array(slotCount).fill(false);
-  for (let i = 0; i < slotCount; ) {
-    if (!silent[i]) {
-      i += 1;
-      continue;
-    }
-    let end = i;
-    while (end < slotCount && silent[end]) {
-      end += 1;
-    }
-    if ((end - i) * slotBeats >= harmonicRhythm - EPS4) {
-      for (let k = i; k < end; k += 1) {
-        breaks[k] = true;
-      }
-    }
-    i = end;
-  }
-  const spans = [];
-  for (let i = 0; i < slotCount; ) {
-    if (breaks[i]) {
-      i += 1;
-      continue;
-    }
-    let end = i;
-    while (end < slotCount && !breaks[end]) {
-      end += 1;
-    }
-    spans.push(...chooseBoundaries(tables, i, end, grid, meters, changeCost));
-    i = end;
-  }
-  return spans;
-}
-function notesOfSpan(slotNotes, span, grid) {
-  const first = Math.round(slotOfBeat(grid, span.startBeat));
-  const lastExclusive = Math.round(slotOfBeat(grid, span.endBeat));
-  if (lastExclusive - first === 1) {
-    return [..._nullishCoalesce(slotNotes[first], () => ( []))];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = first; i < lastExclusive; i += 1) {
-    for (const note of _nullishCoalesce(slotNotes[i], () => ( []))) {
-      seen.add(note);
-    }
-  }
-  return [...seen];
-}
-function chordTimelineFromNotes(notes, opts = {}) {
-  return analyzeTimeline(notes, opts).result;
-}
-var DIRTY_SLOT_MARGIN = 1;
-function dirtySlotsFor(evidence, startBeat, endBeat) {
-  const first = Math.floor(slotOfBeat(evidence.grid, startBeat)) - DIRTY_SLOT_MARGIN;
-  const lastExclusive = Math.ceil(slotOfBeat(evidence.grid, endBeat)) + DIRTY_SLOT_MARGIN;
-  return {
-    from: Math.max(0, Math.min(evidence.slotCount, first)),
-    to: Math.max(0, Math.min(evidence.slotCount, lastExclusive))
-  };
-}
-function spanIsClean(grid, span, dirtyFrom, dirtyTo) {
-  const first = Math.round(slotOfBeat(grid, span.startBeat));
-  const lastExclusive = Math.round(slotOfBeat(grid, span.endBeat));
-  return lastExclusive <= dirtyFrom || first >= dirtyTo;
-}
-function keyId(key) {
-  return `${key.rootPc}:${key.modeMask12}`;
-}
-function windowId(startBeat, endBeat, key) {
-  return `${startBeat}|${endBeat}|${keyId(key)}`;
-}
-function evidenceFits(previous, grid, slotCount, totalBeats, segmentation, harmonicRhythm, keyGiven) {
-  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 = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "timeline meters");
-  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, 0, meters)));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
-  const segmentation = _nullishCoalesce(opts.segmentation, () => ( "dynamic"));
-  const minChordBeats = _nullishCoalesce(opts.minChordBeats, () => ( DEFAULT_MIN_CHORD_BEATS));
-  _chunkQ2WGKJNNcjs.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) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
-    noteOptions.minStartBeat = -opts.pickupBeats;
-  }
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "timeline notes", noteOptions);
-  const soundingIndex = _chunkK4ZJUGF4cjs.createNoteEventIndex.call(void 0, 
-    notes.filter((note) => note.durationBeat > 0),
-    { name: "timeline notes", budget }
-  );
-  const sounding = soundingIndex.notes.map(({ note }) => note);
-  const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const totalBeats = _nullishCoalesce(opts.totalBeats, () => ( lastNoteEnd));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  const slotBeats = segmentation === "grid" ? harmonicRhythm : slotBeatsWithin(harmonicRhythm, minChordBeats);
-  const firstOnset = sounding.reduce((first, n) => Math.min(first, n.startBeat), 0);
-  const { origin, startBeat: musicStart } = gridOriginOf(firstOnset, slotBeats);
-  const grid = { origin, slotBeats };
-  const keys = opts.key !== void 0 ? [{ startBeat: musicStart, endBeat: totalBeats, key: opts.key, confidence: 1 }] : keyTimelineFromNotes(sounding, { meters, totalBeats, budget });
-  const prevailingKey = _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunkUADYAYATcjs.majorKey.call(void 0, 0)));
-  const keyAt = keyLookup(keys, prevailingKey);
-  const segments = [];
-  const segmentConfidence = [];
-  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - EPS4));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, slotCount, "timeline windows", budget);
-  const slotNotes = bucketNotesBySlot(sounding, grid, slotCount, {
-    name: "timeline note-to-window memberships",
-    budget
-  });
-  const carried = previous !== void 0 && dirty !== void 0 && evidenceFits(
-    previous,
-    grid,
-    slotCount,
-    totalBeats,
-    segmentation,
-    harmonicRhythm,
-    opts.key !== void 0
-  ) ? previous : void 0;
-  const dirtyFrom = carried === void 0 ? 0 : Math.max(0, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _37 => _37.from]), () => ( 0)));
-  const dirtyTo = carried === void 0 ? slotCount : Math.min(slotCount, _nullishCoalesce(_optionalChain([dirty, 'optionalAccess', _38 => _38.to]), () => ( slotCount)));
-  const tables = createBoundaryTables(slotCount);
-  const slotWeights = new Array(slotCount);
-  if (carried !== void 0) {
-    tables.scores.set(carried.tables.scores);
-  }
-  for (let i = 0; i < slotCount; i += 1) {
-    const reusable = i < dirtyFrom || i >= dirtyTo ? _optionalChain([carried, 'optionalAccess', _39 => _39.slotWeights, 'access', _40 => _40[i]]) : void 0;
-    if (reusable !== void 0) {
-      slotWeights[i] = reusable;
-      continue;
-    }
-    const start = beatOfSlot(grid, i);
-    const weights = windowWeights(
-      _nullishCoalesce(slotNotes[i], () => ( [])),
-      start,
-      Math.min(start + slotBeats, totalBeats),
-      meters
-    );
-    slotWeights[i] = weights;
-    scoreSlot(tables, weights, i);
-  }
-  const spans = segmentation === "grid" ? gridSpans(slotCount, grid) : dynamicSpans(slotWeights, tables, grid, harmonicRhythm, meters);
-  const windows = /* @__PURE__ */ new Map();
-  for (const span of spans) {
-    const start = Math.max(span.startBeat, musicStart);
-    const end = Math.min(span.endBeat, totalBeats);
-    const spanKey = 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, spanKey);
-    windows.set(id, inferred);
-    if (!inferred) {
-      continue;
-    }
-    const last = segments[segments.length - 1];
-    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < EPS4) {
-      const lastLength = last.endBeat - last.startBeat;
-      const length = end - start;
-      const lastConfidence = _nullishCoalesce(segmentConfidence[segmentConfidence.length - 1], () => ( 0));
-      segmentConfidence[segmentConfidence.length - 1] = (lastConfidence * lastLength + inferred.confidence * length) / (lastLength + length);
-      last.endBeat = end;
-    } else {
-      segments.push({ startBeat: start, endBeat: end, chord: inferred.chord });
-      segmentConfidence.push(inferred.confidence);
-    }
-  }
-  return {
-    result: {
-      timeline: { at: segmentLookup(segments), segments },
-      keys: attachPivots(keys, segments),
-      prevailingKey,
-      segmentConfidence
-    },
-    evidence: {
-      grid,
-      slotCount,
-      totalBeats,
-      segmentation,
-      harmonicRhythm,
-      keyGiven: opts.key !== void 0,
-      slotWeights,
-      tables,
-      windows
-    }
-  };
-}
-function detectCadences(timeline, key) {
-  const keyAt = typeof key === "function" ? key : () => key;
-  const hits = [];
-  for (let i = 1; i < timeline.segments.length; i += 1) {
-    const prev = timeline.segments[i - 1];
-    const cur = timeline.segments[i];
-    if (!prev || !cur) {
-      continue;
-    }
-    if (Math.abs(cur.startBeat - prev.endBeat) > EPS4) {
-      continue;
-    }
-    const before = timeline.segments[i - 2];
-    const approach = before !== void 0 && Math.abs(prev.startBeat - before.endBeat) <= EPS4 ? before.chord : void 0;
-    const cadence = _chunkOE6WK2Y2cjs.detectCadence.call(void 0, prev.chord, cur.chord, keyAt(cur.startBeat), {
-      ...approach === void 0 ? {} : { approach }
-    });
-    if (cadence.type !== null) {
-      hits.push({ atBeat: cur.startBeat, cadence, from: prev.chord, to: cur.chord });
-    }
-  }
-  return hits;
-}
-
-// src/analyze/voice/index.ts
-function toVoiceNotes(events) {
-  return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
-}
-var HUMANIZE_ADJACENCY = 0.05;
-function intervalAboveBass(pitch, others, chord) {
-  let bass = Number.POSITIVE_INFINITY;
-  for (const ov of others) {
-    bass = Math.min(bass, ov.pitch);
-  }
-  if (Number.isFinite(bass) && bass < pitch) {
-    return ((pitch - bass) % 12 + 12) % 12;
-  }
-  const ref = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
-  return ((_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch) - _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
-}
-var TENSION_DEGREE_BY_INTERVAL = {
-  1: 9,
-  2: 9,
-  3: 9,
-  5: 11,
-  6: 11,
-  8: 13,
-  9: 13
-};
-function tensionDegree(ic) {
-  return TENSION_DEGREE_BY_INTERVAL[ic];
-}
-function isStep(a, b) {
-  const d = Math.abs(a - b);
-  return d === 1 || d === 2;
-}
-var LEAP_SEMITONES = 3;
-function suspensionType(ic, delta) {
-  if (delta > 0) {
-    return ic === 1 || ic === 2 ? "sus2-3" : null;
-  }
-  if (ic === 2) {
-    return "sus9-8";
-  }
-  if (ic === 10 || ic === 11) {
-    return "sus7-6";
-  }
-  if (ic === 5 || ic === 6) {
-    return "sus4-3";
-  }
-  if (ic === 8 || ic === 9) {
-    return "sus6-5";
-  }
-  return null;
-}
-var STEP_RESOLUTION = 2;
-var NEAREST_CHORD_TONE_REACH = 12;
-function nearestChordTone(pitch, chord, maxDistance) {
-  for (let delta = 1; delta <= maxDistance; delta += 1) {
-    if (_chunkUADYAYATcjs.isChordMember.call(void 0, pitch - delta, chord)) {
-      return pitch - delta;
-    }
-    if (_chunkUADYAYATcjs.isChordMember.call(void 0, pitch + delta, chord)) {
-      return pitch + delta;
-    }
-  }
-  return void 0;
-}
-function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
-  const keyAt = typeof key === "function" ? key : () => key;
-  const result = [];
-  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 && Math.abs(prevEnd - note.startBeat) <= HUMANIZE_ADJACENCY ? prevNote : void 0;
-    const next = nextNote !== void 0 && Math.abs(noteEnd - nextNote.startBeat) <= HUMANIZE_ADJACENCY ? nextNote : void 0;
-    const chord = chordAtBeat(note.startBeat);
-    const labels = [];
-    const member = _chunkUADYAYATcjs.isChordMember.call(void 0, note.pitch, chord);
-    let handled = false;
-    if (chord && member) {
-      const role = _chunkUADYAYATcjs.chordToneRole.call(void 0, note.pitch, chord);
-      const degree = role === null ? tensionDegree(_chunkUADYAYATcjs.intervalAboveRoot.call(void 0, note.pitch, chord)) : void 0;
-      if (role) {
-        labels.push({ kind: "chordTone", role });
-        handled = true;
-      } else if (degree !== void 0) {
-        labels.push({ kind: "tension", degree });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next) {
-      const prevChord = chordAtBeat(prev.startBeat);
-      const prepared = prev.pitch === note.pitch && _chunkUADYAYATcjs.isChordMember.call(void 0, prev.pitch, prevChord);
-      const resolves = isStep(next.pitch, note.pitch);
-      const others = otherVoicesAtBeat(note.startBeat);
-      const verticallyDissonant = others.some(
-        (ov) => _chunkUADYAYATcjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
-      );
-      if (prepared && verticallyDissonant && resolves) {
-        const ic = intervalAboveBass(note.pitch, others, chord);
-        const type = suspensionType(ic, next.pitch - note.pitch);
-        if (type !== null) {
-          labels.push({ kind: "suspension", type, resolveTo: next.pitch });
-          handled = true;
-        }
-      }
-    }
-    if (!handled && chord && prev && next) {
-      const prevMember = _chunkUADYAYATcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = _chunkUADYAYATcjs.isChordMember.call(void 0, next.pitch, chordAtBeat(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;
-      if (prevMember && nextMember && !member && isStep(note.pitch, prev.pitch) && isStep(next.pitch, note.pitch) && sameDir) {
-        labels.push({ kind: "passing" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunkUADYAYATcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
-      labels.push({ kind: "neighbor" });
-      handled = true;
-    }
-    if (!handled && chord && next && !member && note.pitch === next.pitch) {
-      const nextChord = chordAtBeat(next.startBeat);
-      if (_chunkUADYAYATcjs.isChordMember.call(void 0, next.pitch, nextChord)) {
-        labels.push({ kind: "anticipation" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member) {
-      const prevMember = _chunkUADYAYATcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = _chunkUADYAYATcjs.isChordMember.call(void 0, next.pitch, chordAtBeat(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;
-      if (prevMember && nextMember && leapFromPrev && stepToNext && opposite) {
-        labels.push({ kind: "appoggiatura", resolveTo: next.pitch });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member) {
-      const prevMember = _chunkUADYAYATcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = _chunkUADYAYATcjs.isChordMember.call(void 0, next.pitch, chordAtBeat(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;
-      if (prevMember && nextMember && stepFromPrev && leapToNext && opposite) {
-        labels.push({ kind: "escape" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && !member) {
-      const ic = _chunkUADYAYATcjs.intervalAboveRoot.call(void 0, note.pitch, chord);
-      const degree = tensionDegree(ic);
-      const isTension = ic === 2 || ic === 5 || ic === 9;
-      const avoid = ic === 5 && chord.intervals.includes(4) && !chord.intervals.includes(5) || ic === 11 && chord.intervals.includes(4) && chord.intervals.includes(10);
-      if (avoid) {
-        labels.push({ kind: "avoid" });
-        const resolveTo = nearestChordTone(note.pitch, chord, STEP_RESOLUTION);
-        if (resolveTo !== void 0) {
-          labels.push({ kind: "needsResolution", resolveTo });
-        }
-      } else if (isTension && degree !== void 0) {
-        labels.push({ kind: "tension", degree });
-      } else {
-        const resolveTo = nearestChordTone(note.pitch, chord, NEAREST_CHORD_TONE_REACH);
-        labels.push(
-          resolveTo === void 0 ? { kind: "avoid" } : { kind: "needsResolution", resolveTo }
-        );
-      }
-    }
-    if (next && _chunkUADYAYATcjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, keyAt(next.startBeat))) {
-      labels.push({ kind: "leadingTone", resolveTo: next.pitch });
-    }
-    const analyzed = {
-      noteId: _nullishCoalesce(note.id, () => ( i)),
-      pitch: note.pitch,
-      startBeat: note.startBeat,
-      durationBeat: note.durationBeat,
-      labels,
-      rationale: describe(labels)
-    };
-    if (note.originalIndex !== void 0) {
-      analyzed.originalIndex = note.originalIndex;
-    }
-    result.push(analyzed);
-  }
-  return result;
-}
-function describe(labels) {
-  const primary = labels[0];
-  if (!primary) {
-    return "Unclassified note";
-  }
-  switch (primary.kind) {
-    case "chordTone":
-      return `Chord ${primary.role}`;
-    case "tension":
-      return `${primary.degree}th tension`;
-    case "avoid":
-      return "Avoid note";
-    case "passing":
-      return "Passing tone between chord tones";
-    case "neighbor":
-      return "Neighbor tone";
-    case "suspension":
-      return `Suspension (${primary.type})`;
-    case "appoggiatura":
-      return "Appoggiatura leaning on the harmony, resolving by step";
-    case "anticipation":
-      return "Anticipation of the next chord";
-    case "escape":
-      return "Escape tone";
-    case "needsResolution":
-      return "Unresolved dissonance";
-    case "leadingTone":
-      return "Leading tone resolving to the tonic";
-  }
-}
-
-// src/analyze/arrange/internal.ts
-var EPS5 = 1e-9;
-var MAX_LANE_LEAP = 24;
-function covers(note, beat) {
-  return beat >= note.startBeat - EPS5 && beat < note.endBeat - EPS5;
-}
-function isPercussion(role) {
-  return role === "drums";
-}
-var DEFAULT_PROFILE = "pop";
-var SAFETY_PROFILES = Object.keys(_chunkUADYAYATcjs.PROFILE_WEIGHTS);
-function arrangementProfile(profile) {
-  return _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(profile, () => ( DEFAULT_PROFILE)), SAFETY_PROFILES, "arrangement profile");
-}
-function assertTrackNotes(tracks, options) {
-  let noteCount = 0;
-  for (let index = 0; index < tracks.length; index += 1) {
-    const notes = _optionalChain([tracks, 'access', _41 => _41[index], 'optionalAccess', _42 => _42.notes]);
-    if (!Array.isArray(notes)) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `tracks[${index}].notes must be an array; received ${typeof notes}`
-      );
-    }
-    _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, `tracks[${index}].notes`, options);
-    noteCount += notes.length;
-  }
-  return noteCount;
-}
-function harmonyTrackSet(harmonyTracks, trackCount, name = "harmonyTracks") {
-  if (harmonyTracks === void 0) {
-    return void 0;
-  }
-  const only = /* @__PURE__ */ new Set();
-  for (let index = 0; index < harmonyTracks.length; index += 1) {
-    const value = harmonyTracks[index];
-    if (value === void 0 || !Number.isFinite(value)) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`${name}[${index}] must be a track index; received ${value}`);
-    }
-    const track = Math.trunc(value);
-    if (track < 0 || track >= trackCount) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `${name}[${index}] ${track} is outside the arrangement's ${trackCount} tracks`
-      );
-    }
-    only.add(track);
-  }
-  return only;
-}
-function poolNotes(tracks, only) {
-  const notes = [];
-  for (let index = 0; index < tracks.length; index += 1) {
-    const track = tracks[index];
-    if (track === void 0 || isPercussion(track.role)) {
-      continue;
-    }
-    if (only !== void 0 && !only.has(index)) {
-      continue;
-    }
-    for (const note of track.notes) {
-      if (note.durationBeat > 0) {
-        notes.push(note);
-      }
-    }
-  }
-  return notes;
-}
-function splitIntoSubVoices(ordered) {
-  const lanes = [];
-  const attachNearest = (note, excluded = /* @__PURE__ */ new Set()) => {
-    let best = -1;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    let bestEnd = Number.NEGATIVE_INFINITY;
-    for (let lane = 0; lane < lanes.length; lane += 1) {
-      if (excluded.has(lane)) {
-        continue;
-      }
-      const last = _optionalChain([lanes, 'access', _43 => _43[lane], 'optionalAccess', _44 => _44[(_nullishCoalesce(_optionalChain([lanes, 'access', _45 => _45[lane], 'optionalAccess', _46 => _46.length]), () => ( 0))) - 1]]);
-      if (last === void 0) {
-        continue;
-      }
-      const end = last.startBeat + last.durationBeat;
-      if (end > note.startBeat + EPS5) {
-        continue;
-      }
-      const distance = Math.abs(last.pitch - note.pitch);
-      if (distance > MAX_LANE_LEAP) {
-        continue;
-      }
-      if (distance < bestDistance || distance === bestDistance && end > bestEnd) {
-        best = lane;
-        bestDistance = distance;
-        bestEnd = end;
-      }
-    }
-    if (best >= 0) {
-      _optionalChain([lanes, 'access', _47 => _47[best], 'optionalAccess', _48 => _48.push, 'call', _49 => _49(note)]);
-      return true;
-    }
-    return false;
-  };
-  for (let start = 0; start < ordered.length; ) {
-    const onset = _nullishCoalesce(_optionalChain([ordered, 'access', _50 => _50[start], 'optionalAccess', _51 => _51.startBeat]), () => ( 0));
-    let end = start + 1;
-    while (end < ordered.length && Math.abs((_nullishCoalesce(_optionalChain([ordered, 'access', _52 => _52[end], 'optionalAccess', _53 => _53.startBeat]), () => ( 0))) - onset) <= EPS5) {
-      end += 1;
-    }
-    const block = ordered.slice(start, end);
-    if (block.length > 1) {
-      const freeLanes = lanes.map((lane, index) => ({ index, last: lane[lane.length - 1] })).filter(
-        (entry) => entry.last !== void 0 && entry.last.startBeat + entry.last.durationBeat <= onset + EPS5
-      ).sort((a, b) => a.last.pitch - b.last.pitch);
-      const paired = /* @__PURE__ */ new Set();
-      for (let index = 0; index < block.length; index += 1) {
-        const note = block[index];
-        const lane = freeLanes[index];
-        if (note !== void 0 && lane !== void 0 && Math.abs(lane.last.pitch - note.pitch) <= MAX_LANE_LEAP) {
-          _optionalChain([lanes, 'access', _54 => _54[lane.index], 'optionalAccess', _55 => _55.push, 'call', _56 => _56(note)]);
-          paired.add(lane.index);
-        } else if (note !== void 0 && !attachNearest(note, paired)) {
-          lanes.push([note]);
-        }
-      }
-    } else {
-      const note = block[0];
-      if (note !== void 0 && !attachNearest(note)) {
-        lanes.push([note]);
-      }
-    }
-    start = end;
-  }
-  return lanes;
-}
-function lastStartingAtOrBefore(sounding, beat) {
-  let low = 0;
-  let high = sounding.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((_nullishCoalesce(_optionalChain([sounding, 'access', _57 => _57[middle], 'optionalAccess', _58 => _58.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat + EPS5) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low - 1;
-}
-function prepareTracks(tracks) {
-  let nextId = 0;
-  return tracks.map((track, index) => {
-    const ordered = track.notes.map((note, originalIndex) => ({ note, originalIndex })).filter(({ note }) => note.durationBeat > 0).sort((a, b) => a.note.startBeat - b.note.startBeat || a.note.pitch - b.note.pitch).map(({ note, originalIndex }) => ({ ...note, id: nextId++, originalIndex }));
-    const voices = splitIntoSubVoices(ordered).map((voice) => {
-      const sounding = voice.map((note, i) => {
-        const prev = i > 0 ? voice[i - 1] : void 0;
-        const prevEnd = prev === void 0 ? void 0 : prev.startBeat + prev.durationBeat;
-        const contiguous = prevEnd !== void 0 && Math.abs(prevEnd - note.startBeat) <= EPS5;
-        return {
-          pitch: note.pitch,
-          prevPitch: contiguous ? _optionalChain([prev, 'optionalAccess', _59 => _59.pitch]) : void 0,
-          startBeat: note.startBeat,
-          endBeat: note.startBeat + note.durationBeat
-        };
-      });
-      return {
-        voice,
-        sounding,
-        at: (beat) => {
-          const candidate = sounding[lastStartingAtOrBefore(sounding, beat)];
-          return candidate !== void 0 && covers(candidate, beat) ? candidate : void 0;
-        }
-      };
-    });
-    return {
-      name: _nullishCoalesce(track.name, () => ( `track ${index + 1}`)),
-      role: _nullishCoalesce(track.role, () => ( "other")),
-      trackIndex: index,
-      voices
-    };
-  });
-}
-
-// src/analyze/arrange/tracks.ts
-function withGivenKeys(result, given) {
-  if (given === void 0) {
-    return result;
-  }
-  return { ...result, keys: given, prevailingKey: _nullishCoalesce(prevailingKeyOf(given), () => ( result.prevailingKey)) };
-}
-function callerTimeline(timeline, key, given, pooled, meters, budget) {
-  const totalBeats = timeline.segments.reduce((end, segment) => Math.max(end, segment.endBeat), 0);
-  const keys = _nullishCoalesce(given, () => ( attachPivots(
-    key !== void 0 ? [{ startBeat: 0, endBeat: totalBeats, key, confidence: 1 }] : keyTimelineFromNotes(pooled, { meters, totalBeats, budget }),
-    timeline.segments
-  )));
-  return {
-    timeline,
-    keys,
-    prevailingKey: _nullishCoalesce(prevailingKeyOf(keys), () => ( _chunkUADYAYATcjs.majorKey.call(void 0, 0))),
-    segmentConfidence: timeline.segments.map(() => 0)
-  };
-}
-function soundingVoicesAt(prepared, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track || isPercussion(track.role)) {
-      continue;
-    }
-    for (let v = 0; v < track.voices.length; v += 1) {
-      const note = _optionalChain([track, 'access', _60 => _60.voices, 'access', _61 => _61[v], 'optionalAccess', _62 => _62.at, 'call', _63 => _63(beat)]);
-      if (note === void 0) {
-        continue;
-      }
-      const snap = { pitch: note.pitch };
-      const previous = Math.abs(note.startBeat - beat) <= EPS5 ? note.prevPitch : note.pitch;
-      if (previous !== void 0) {
-        snap.prevPitch = previous;
-      }
-      out.push({ track: t, voice: v, snapshot: snap });
-    }
-  }
-  return out;
-}
-function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat, cache) {
-  const sounding = _nullishCoalesce(cache.get(beat), () => ( soundingVoicesAt(prepared, beat)));
-  cache.set(beat, sounding);
-  return sounding.filter(({ track, voice }) => track !== excludeTrack || voice !== excludeVoice).map(({ snapshot }) => snapshot);
-}
-function firstSegmentAfter(timeline, beat) {
-  let low = 0;
-  let high = timeline.segments.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((_nullishCoalesce(_optionalChain([timeline, 'access', _64 => _64.segments, 'access', _65 => _65[middle], 'optionalAccess', _66 => _66.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat + EPS5) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low;
-}
-function evaluationBeats(note, timeline) {
-  const noteEnd = note.startBeat + note.durationBeat;
-  const beats = [note.startBeat];
-  for (let i = firstSegmentAfter(timeline, note.startBeat); i < timeline.segments.length; i += 1) {
-    const start = _optionalChain([timeline, 'access', _67 => _67.segments, 'access', _68 => _68[i], 'optionalAccess', _69 => _69.startBeat]);
-    if (start === void 0 || start >= noteEnd - EPS5) {
-      break;
-    }
-    beats.push(start);
-  }
-  return beats;
-}
-function analyzeArrangement(tracks, opts = {}) {
-  return analyzeArrangementWith(tracks, opts).analysis;
-}
-function analyzeArrangementWith(tracks, opts = {}, previous, dirty) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "arrangement meters");
-  const budget = opts.budget;
-  const noteOptions = { allowNonPositiveDuration: true, budget };
-  if (opts.pickupBeats !== void 0) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "arrangement pickupBeats");
-    noteOptions.minStartBeat = -opts.pickupBeats;
-  }
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
-  const noteCount = assertTrackNotes(tracks, noteOptions);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, noteCount, "arrangement notes", budget);
-  const profile = arrangementProfile(opts.profile);
-  const minSeverity = _nullishCoalesce(opts.minSeverity, () => ( 1)) /* Warning */;
-  const harmonyTracks = harmonyTrackSet(opts.harmonyTracks, tracks.length);
-  const prepared = prepareTracks(tracks);
-  const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, noteCount * voiceCount, "arrangement note-voice comparisons", budget);
-  const pooled = poolNotes(tracks, harmonyTracks);
-  let evidence;
-  let inferred;
-  if (opts.timeline === void 0) {
-    const run = analyzeTimeline(
-      pooled,
-      {
-        key: opts.key,
-        meters,
-        pickupBeats: opts.pickupBeats,
-        harmonicRhythm: opts.harmonicRhythm,
-        budget
-      },
-      previous,
-      dirty
-    );
-    evidence = run.evidence;
-    inferred = withGivenKeys(run.result, opts.keys);
-  } else {
-    inferred = callerTimeline(opts.timeline, opts.key, opts.keys, pooled, meters, budget);
-  }
-  const { timeline, keys, prevailingKey, segmentConfidence } = inferred;
-  const keyAt = keyLookup(keys, prevailingKey);
-  const cadences = detectCadences(timeline, keyAt);
-  const soundingCache = /* @__PURE__ */ new Map();
-  const trackAnalyses = [];
-  const conflicts = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track) {
-      continue;
-    }
-    if (isPercussion(track.role)) {
-      trackAnalyses.push({ name: track.name, role: track.role, notes: [] });
-      continue;
-    }
-    const notes = [];
-    for (let v = 0; v < track.voices.length; v += 1) {
-      const subVoice = track.voices[v];
-      if (!subVoice) {
-        continue;
-      }
-      const analyzed = analyzeVoice(
-        subVoice.voice,
-        timeline.at,
-        keyAt,
-        (beat) => otherVoicesSounding(prepared, t, v, beat, soundingCache)
-      );
-      for (const note of analyzed) {
-        notes.push({ ...note, trackIndex: track.trackIndex });
-      }
-      const labelsById = new Map(analyzed.map((note) => [note.noteId, note.labels]));
-      for (let noteIndex = 0; noteIndex < subVoice.voice.length; noteIndex += 1) {
-        const note = subVoice.voice[noteIndex];
-        const preparedNote = subVoice.sounding[noteIndex];
-        if (note === void 0 || preparedNote === void 0) {
-          continue;
-        }
-        for (const beat of evaluationBeats(note, timeline)) {
-          const atOnset = Math.abs(beat - note.startBeat) <= EPS5;
-          const safetyQuery = {
-            profile,
-            candidatePitch: note.pitch,
-            prevPitch: atOnset ? preparedNote.prevPitch : note.pitch,
-            chord: timeline.at(beat),
-            key: keyAt(beat),
-            otherVoices: otherVoicesSounding(prepared, t, v, beat, soundingCache),
-            strongBeat: _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, beat, meters)
-          };
-          let result = _chunkUADYAYATcjs.evaluateSafety.call(void 0, safetyQuery, { suggestions: false });
-          if (result.safety !== 0 /* Safe */ && result.safety >= minSeverity) {
-            result = _chunkUADYAYATcjs.evaluateSafety.call(void 0, safetyQuery);
-            const conflict = {
-              beat,
-              trackName: track.name,
-              trackIndex: track.trackIndex,
-              noteId: note.id,
-              pitch: note.pitch,
-              labels: _nullishCoalesce(labelsById.get(note.id), () => ( [])),
-              safety: result.safety,
-              reasons: result.reasons
-            };
-            if (note.originalIndex !== void 0) {
-              conflict.originalIndex = note.originalIndex;
-            }
-            if (result.rationale !== void 0) {
-              conflict.rationale = result.rationale;
-            }
-            if (result.resolveTo !== void 0) {
-              conflict.resolveTo = result.resolveTo;
-            }
-            if (result.suggestions !== void 0) {
-              conflict.suggestions = [...result.suggestions];
-            }
-            conflicts.push(conflict);
-          }
-        }
-      }
-    }
-    notes.sort((a, b) => a.noteId - b.noteId);
-    trackAnalyses.push({ name: track.name, role: track.role, notes });
-  }
-  conflicts.sort((a, b) => b.safety - a.safety || a.beat - b.beat);
-  const analysis = {
-    keys,
-    prevailingKey,
-    timeline,
-    segmentConfidence,
-    cadences,
-    tracks: trackAnalyses,
-    conflicts
-  };
-  return evidence === void 0 ? { analysis } : { analysis, evidence };
-}
-
-// src/analyze/arrange/session.ts
-function noteId(note) {
-  return `${note.pitch}|${note.startBeat}|${note.durationBeat}|${_nullishCoalesce(note.velocity, () => ( ""))}`;
-}
-function sameOrder(before, after) {
-  if (before.length !== after.length) {
-    return false;
-  }
-  for (let index = 0; index < before.length; index += 1) {
-    const previous = before[index];
-    const current = after[index];
-    if (previous === void 0 || current === void 0 || noteId(previous) !== noteId(current)) {
-      return false;
-    }
-  }
-  return true;
-}
-function editedSpan(before, after) {
-  const counts = /* @__PURE__ */ new Map();
-  const tally = (notes, sign) => {
-    for (const note of notes) {
-      const id = noteId(note);
-      const entry = counts.get(id);
-      if (entry === void 0) {
-        counts.set(id, {
-          count: sign,
-          startBeat: note.startBeat,
-          endBeat: note.startBeat + note.durationBeat
-        });
-      } else {
-        entry.count += sign;
-      }
-    }
-  };
-  tally(before, 1);
-  tally(after, -1);
-  let startBeat = Number.POSITIVE_INFINITY;
-  let endBeat = Number.NEGATIVE_INFINITY;
-  for (const entry of counts.values()) {
-    if (entry.count === 0) {
-      continue;
-    }
-    startBeat = Math.min(startBeat, entry.startBeat);
-    endBeat = Math.max(endBeat, entry.endBeat, entry.startBeat);
-  }
-  return startBeat <= endBeat ? { startBeat, endBeat } : null;
-}
-function unionSpan(a, b) {
-  if (a === null) {
-    return b;
-  }
-  if (b === null) {
-    return a;
-  }
-  return {
-    startBeat: Math.min(a.startBeat, b.startBeat),
-    endBeat: Math.max(a.endBeat, b.endBeat)
-  };
-}
-function sessionOf(tracks, opts, analysis, evidence) {
-  return {
-    tracks,
-    analysis,
-    update(edits) {
-      _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, edits.length, "arrangement edits", opts.budget);
-      const next = [...tracks];
-      let edited = null;
-      let reordered = false;
-      for (let index = 0; index < edits.length; index += 1) {
-        const edit = edits[index];
-        if (edit === void 0) {
-          continue;
-        }
-        const target = next[edit.trackIndex];
-        if (target === void 0) {
-          throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-            `edits[${index}].trackIndex ${edit.trackIndex} is outside the session's ${tracks.length} tracks`
-          );
-        }
-        if (!Array.isArray(edit.notes)) {
-          throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-            `edits[${index}].notes must be an array; received ${typeof edit.notes}`
-          );
-        }
-        _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, edit.notes, `edits[${index}].notes`, {
-          allowNonPositiveDuration: true,
-          budget: opts.budget
-        });
-        edited = unionSpan(edited, editedSpan(target.notes, edit.notes));
-        reordered = reordered || !sameOrder(target.notes, edit.notes);
-        next[edit.trackIndex] = { ...target, notes: edit.notes };
-      }
-      if (edited === null && !reordered) {
-        return sessionOf(next, opts, analysis, evidence);
-      }
-      const dirty = evidence === void 0 ? void 0 : edited === null ? { from: 0, to: 0 } : dirtySlotsFor(evidence, edited.startBeat, edited.endBeat);
-      const run = analyzeArrangementWith(next, opts, evidence, dirty);
-      return sessionOf(next, opts, run.analysis, run.evidence);
-    }
-  };
-}
-function createArrangementSession(tracks, opts = {}) {
-  const run = analyzeArrangementWith(tracks, opts);
-  return sessionOf([...tracks], opts, run.analysis, run.evidence);
-}
-
-// src/analyze/arrange/tension.ts
-var FUNCTION_TENSION = {
-  tonic: 0,
-  subdominant: 0.5,
-  dominant: 1
-};
-var FUNCTION_WEIGHT = 0.5;
-var DISSONANCE_WEIGHT = 0.35;
-var SPAN_WEIGHT = 0.15;
-var SPAN_SATURATION = 24;
-function clamp01(value) {
-  return Math.min(1, Math.max(0, value));
-}
-function tensionCurve(tracks, opts = {}) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "arrangement meters");
-  const budget = opts.budget;
-  const noteOptions = { allowNonPositiveDuration: true, budget };
-  if (opts.pickupBeats !== void 0) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "arrangement pickupBeats");
-    noteOptions.minStartBeat = -opts.pickupBeats;
-  }
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
-  const noteCount = assertTrackNotes(tracks, noteOptions);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, noteCount, "arrangement notes", budget);
-  const profile = arrangementProfile(opts.profile);
-  const step = _nullishCoalesce(opts.step, () => ( 1));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, step, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "tension sampling step");
-  const harmonyTracks = harmonyTrackSet(opts.harmonyTracks, tracks.length);
-  const pooled = poolNotes(tracks, harmonyTracks);
-  const all = poolNotes(tracks);
-  const totalBeats = all.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const firstOnset = all.reduce((first, n) => Math.min(first, n.startBeat), 0);
-  const sampleStart = Math.min(0, Math.floor(firstOnset / step + EPS5) * step);
-  const suppliedKeys = opts.timeline === void 0 ? void 0 : _nullishCoalesce(opts.keys, () => ( (opts.key !== void 0 ? [{ startBeat: 0, endBeat: totalBeats, key: opts.key, confidence: 1 }] : keyTimelineFromNotes(pooled, { meters, totalBeats, budget }))));
-  const { timeline, keys, prevailingKey } = opts.timeline === void 0 || suppliedKeys === void 0 ? chordTimelineFromNotes(pooled, {
-    key: opts.key,
-    meters,
-    pickupBeats: opts.pickupBeats,
-    harmonicRhythm: opts.harmonicRhythm,
-    budget
-  }) : {
-    timeline: opts.timeline,
-    keys: suppliedKeys,
-    prevailingKey: _nullishCoalesce(prevailingKeyOf(suppliedKeys), () => ( _chunkUADYAYATcjs.majorKey.call(void 0, 0)))
-  };
-  const regions = _nullishCoalesce(opts.keys, () => ( keys));
-  const keyAt = keyLookup(regions, _nullishCoalesce(prevailingKeyOf(regions), () => ( prevailingKey)));
-  const prepared = prepareTracks(tracks);
-  const points = [];
-  const sampleCount = Math.max(0, Math.ceil((totalBeats - sampleStart) / step - EPS5));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, sampleCount, "tension samples", budget);
-  const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 
-    sampleCount * Math.min(128, voiceCount) * voiceCount,
-    "tension sample-voice comparisons",
-    budget
-  );
-  for (let i = 0; i < sampleCount; i += 1) {
-    const beat = sampleStart + i * step;
-    points.push({
-      beat,
-      tension: sampleTension(prepared, timeline, keyAt(beat), meters, profile, beat)
-    });
-  }
-  return points;
-}
-function tensionCurveFrom(tracks, analysis, opts = {}) {
-  return tensionCurve(tracks, {
-    ...opts,
-    timeline: analysis.timeline,
-    keys: analysis.keys
-  });
-}
-function allSounding(prepared, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track || isPercussion(track.role)) {
-      continue;
-    }
-    for (const subVoice of track.voices) {
-      const note = subVoice.at(beat);
-      if (note !== void 0) {
-        out.push({ pitch: note.pitch, track: t });
-      }
-    }
-  }
-  return out;
-}
-function sampleTension(prepared, timeline, key, meters, profile, beat) {
-  const sounding = allSounding(prepared, beat);
-  if (sounding.length === 0) {
-    return 0;
-  }
-  const chord = timeline.at(beat);
-  const functionScore = chord ? FUNCTION_TENSION[_chunkOE6WK2Y2cjs.functionOf.call(void 0, chord, key)] : 0;
-  const chordPcs = chord ? new Set(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord)) : null;
-  const strongBeat = _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, beat, meters);
-  let nonChord = 0;
-  let dissonant = 0;
-  const pitches = /* @__PURE__ */ new Map();
-  for (const voice of sounding) {
-    pitches.set(voice.pitch, (_nullishCoalesce(pitches.get(voice.pitch), () => ( 0))) + 1);
-  }
-  for (const [pitch, count] of pitches) {
-    if (chordPcs && !chordPcs.has(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch))) {
-      nonChord += count;
-    }
-    const others = [...pitches].flatMap(
-      ([otherPitch, otherCount]) => Array.from({ length: otherCount - (otherPitch === pitch ? 1 : 0) }, () => ({
-        pitch: otherPitch
-      }))
-    );
-    const result = _chunkUADYAYATcjs.evaluateSafety.call(void 0, 
-      {
-        profile,
-        candidatePitch: pitch,
-        chord,
-        key,
-        otherVoices: others,
-        strongBeat
-      },
-      { suggestions: false }
-    );
-    if (result.safety === 2 /* Dissonant */) {
-      dissonant += count;
-    }
-  }
-  const dissonanceScore = Math.max(nonChord, dissonant) / sounding.length;
-  let low = Number.POSITIVE_INFINITY;
-  let high = Number.NEGATIVE_INFINITY;
-  for (const voice of sounding) {
-    low = Math.min(low, voice.pitch);
-    high = Math.max(high, voice.pitch);
-  }
-  const spanScore = Math.min(1, (high - low) / SPAN_SATURATION);
-  return clamp01(
-    FUNCTION_WEIGHT * functionScore + DISSONANCE_WEIGHT * dissonanceScore + SPAN_WEIGHT * spanScore
-  );
-}
-
-// src/analyze/form/internal.ts
-var EPS6 = 1e-9;
-function clamp012(value) {
-  return Math.min(1, Math.max(0, value));
-}
-function floorMod(value, modulus) {
-  return (value % modulus + modulus) % modulus;
-}
-function firstSoundingBeat(notes, fallback = 0) {
-  let first = Number.POSITIVE_INFINITY;
-  for (const note of notes) {
-    first = Math.min(first, note.startBeat);
-  }
-  return Number.isFinite(first) ? first : fallback;
-}
-function lastBarOf(meter, spanStart, spanEnd) {
-  const firstBar = _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, spanStart, meter);
-  const bar = _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, Math.max(spanStart, spanEnd), meter);
-  if (bar > firstBar && _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter) >= spanEnd - EPS6) {
-    return bar - 1;
-  }
-  return bar;
-}
-function sliceBars(notes, meter, spanStart, spanEnd, budget) {
-  const firstBar = _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, spanStart, meter);
-  const lastBar = lastBarOf(meter, spanStart, spanEnd);
-  const barCount = lastBar - firstBar + 1;
-  _chunkQ2WGKJNNcjs.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, _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, note.startBeat, meter));
-    const to = Math.min(lastBar, _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, Math.max(note.startBeat, noteEnd - EPS6), meter));
-    memberships += Math.max(0, to - from + 1);
-    _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, memberships, "form note-to-bar memberships", budget);
-    for (let bar = from; bar <= to; bar += 1) {
-      _optionalChain([buckets, 'access', _70 => _70[bar - firstBar], 'optionalAccess', _71 => _71.push, 'call', _72 => _72(note)]);
-    }
-  }
-  const slices = [];
-  for (let bar = firstBar; bar <= lastBar; bar += 1) {
-    const startBeat = _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar, beat: 0 }, meter);
-    const endBeat = _chunkK4ZJUGF4cjs.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 });
-  }
-  return slices;
-}
-function weightSimilarity(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i += 1) {
-    const x = _nullishCoalesce(a[i], () => ( 0));
-    const y = _nullishCoalesce(b[i], () => ( 0));
-    dot += x * y;
-    normA += x * x;
-    normB += y * y;
-  }
-  if (normA <= EPS6 && normB <= EPS6) {
-    return 1;
-  }
-  if (normA <= EPS6 || normB <= EPS6) {
-    return 0;
-  }
-  return clamp012(dot / Math.sqrt(normA * normB));
-}
-function harmonicNovelty(slices, index) {
-  const current = slices[index];
-  if (current === void 0) {
-    return 0;
-  }
-  const previous = slices[index - 1];
-  if (previous === void 0) {
-    return current.index === 0 ? 1 : 0;
-  }
-  return 1 - weightSimilarity(previous.weights, current.weights);
-}
-function combineEvidence(strengths) {
-  let remaining = 1;
-  for (const strength of strengths) {
-    remaining *= 1 - clamp012(strength);
-  }
-  return clamp012(1 - remaining);
-}
-
-// src/analyze/form/hypermeter.ts
-var GROUP_CANDIDATES = [2, 3, 4, 6, 8];
-var GROUP_PRIOR = /* @__PURE__ */ new Map([
-  [2, 0.9],
-  [3, 0.75],
-  [4, 1],
-  [6, 0.7],
-  [8, 0.85]
-]);
-var CONTRAST_SHARE = 0.65;
-var CADENCE_SHARE = 0.35;
-var GROUP_FINAL_FIT = 1;
-var ELIDED_FIT = 0.5;
-var MIN_GROUPS = 2;
-var MARGIN_FLOOR = 0.7;
-function accentContrast(novelty, slices, groupBars, phase) {
-  let headSum = 0;
-  let headCount = 0;
-  let otherSum = 0;
-  let otherCount = 0;
-  for (let i = 0; i < slices.length; i += 1) {
-    const slice = slices[i];
-    if (slice === void 0) {
-      continue;
-    }
-    const value = _nullishCoalesce(novelty[i], () => ( 0));
-    if (floorMod(slice.index - phase, groupBars) === 0) {
-      headSum += value;
-      headCount += 1;
-    } else {
-      otherSum += value;
-      otherCount += 1;
-    }
-  }
-  if (headCount === 0 || otherCount === 0) {
-    return 0;
-  }
-  return headSum / headCount - otherSum / otherCount;
-}
-function cadenceFitOf(cadenceBars, groupBars, phase) {
-  if (cadenceBars.length === 0) {
-    return 0;
-  }
-  let fit = 0;
-  for (const bar of cadenceBars) {
-    const position = floorMod(bar - phase, groupBars);
-    if (position === groupBars - 1) {
-      fit += GROUP_FINAL_FIT;
-    } else if (position === 0) {
-      fit += ELIDED_FIT;
-    }
-  }
-  return clamp012(fit / cadenceBars.length);
-}
-function undecidedReading(slices) {
-  const groupBars = Math.max(1, slices.length);
-  const first = slices[0];
-  return {
-    groupBars,
-    downbeats: first === void 0 ? [] : [first.startBeat],
-    confidence: 0,
-    rationale: `Span of ${slices.length} bar(s) is too short to establish a grouping; read as one group`
-  };
-}
-function hypermeter(notes, meter, opts = {}) {
-  const meters = _nullishCoalesce(meter, () => ( _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, {})));
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "hypermeter notes", {
-    allowNonPositiveDuration: true,
-    budget: opts.budget
-  });
-  const sounding = notes.filter((note) => note.durationBeat > 0);
-  const firstOnset = firstSoundingBeat(sounding);
-  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const spanEnd = _nullishCoalesce(opts.totalBeats, () => ( lastEnd));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, spanEnd, 0, Number.MAX_SAFE_INTEGER, "hypermeter totalBeats");
-  const spanStart = firstOnset < 0 ? gridOriginOf(firstOnset, _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, firstOnset, meters)).startBeat : firstOnset;
-  const slices = sliceBars(sounding, meters, spanStart, spanEnd, opts.budget);
-  const candidates = GROUP_CANDIDATES.filter(
-    (groupBars) => slices.length >= groupBars * MIN_GROUPS
-  );
-  if (candidates.length === 0) {
-    return undecidedReading(slices);
-  }
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 
-    candidates.reduce((sum, groupBars) => sum + groupBars * slices.length, 0),
-    "hypermeter readings",
-    opts.budget
-  );
-  const novelty = slices.map((_, index) => harmonicNovelty(slices, index));
-  const cadenceBars = (_nullishCoalesce(opts.cadenceBeats, () => ( []))).map((beat) => _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, beat, meters));
-  const readings = [];
-  for (const groupBars of candidates) {
-    for (let phase = 0; phase < groupBars; phase += 1) {
-      const contrast = accentContrast(novelty, slices, groupBars, phase);
-      const cadenceFit = cadenceFitOf(cadenceBars, groupBars, phase);
-      const evidence = clamp012(
-        cadenceBars.length === 0 ? contrast : CONTRAST_SHARE * contrast + CADENCE_SHARE * cadenceFit
-      );
-      readings.push({
-        groupBars,
-        phase,
-        contrast,
-        cadenceFit,
-        evidence,
-        score: evidence * (_nullishCoalesce(GROUP_PRIOR.get(groupBars), () => ( 0)))
-      });
-    }
-  }
-  readings.sort(
-    (a, b) => b.score - a.score || (_nullishCoalesce(GROUP_PRIOR.get(b.groupBars), () => ( 0))) - (_nullishCoalesce(GROUP_PRIOR.get(a.groupBars), () => ( 0))) || a.groupBars - b.groupBars || a.phase - b.phase
-  );
-  const best = readings[0];
-  if (best === void 0) {
-    return undecidedReading(slices);
-  }
-  const runnerUp = readings.find((reading) => reading.groupBars !== best.groupBars);
-  const margin = runnerUp === void 0 || best.score <= EPS6 ? 1 : clamp012((best.score - runnerUp.score) / best.score);
-  const downbeats = slices.filter((slice) => slice.index >= 0 && floorMod(slice.index - best.phase, best.groupBars) === 0).map((slice) => slice.startBeat);
-  const cadencePart = cadenceBars.length === 0 ? "no cadences given" : `${Math.round(best.cadenceFit * 100)}% of cadences arriving at a group end`;
-  return {
-    groupBars: best.groupBars,
-    downbeats,
-    // Mostly the evidence, discounted when a rival grouping explains the
-    // accents nearly as well. The discount is the smaller term because the
-    // runner-up is nearly always a multiple or a divisor of the winner — four
-    // bars nest inside eight — and a reading of the same accents at another
-    // level is weaker counter-evidence than an unrelated rival would be.
-    confidence: clamp012(best.evidence * (MARGIN_FLOOR + (1 - MARGIN_FLOOR) * margin)),
-    rationale: `${best.groupBars}-bar groups from bar ${best.phase}: harmonic change ${Math.round(best.contrast * 100)}% stronger on group heads, ${cadencePart}`
-  };
-}
-
-// src/analyze/melody/index.ts
-var EPS7 = 1e-9;
-var RHYTHM_GRID = 64;
-var MIN_CELL_NOTES = 3;
-var MAX_CELL_NOTES = 8;
-var MIN_OCCURRENCES = 2;
-var SEQUENCE_GAP = 0.05;
-var INTERVAL_TOLERANCE = 6;
-var PITCH_WEIGHT = 0.75;
-var RHYTHM_WEIGHT = 0.25;
-var DIRECTIONAL_SHARE = 0.75;
-function phraseNotes(phrase) {
-  return "notes" in phrase ? phrase.notes : phrase;
-}
-function orderedNotes(notes, name, budget) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, name, { allowNonPositiveDuration: true, budget });
-  return notes.filter((note) => note.durationBeat > 0).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-}
-function intervalsOf(notes) {
-  const out = [];
-  for (let i = 1; i < notes.length; i += 1) {
-    out.push((_nullishCoalesce(_optionalChain([notes, 'access', _73 => _73[i], 'optionalAccess', _74 => _74.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _75 => _75[i - 1], 'optionalAccess', _76 => _76.pitch]), () => ( 0))));
-  }
-  return out;
-}
-function onsetGaps(notes) {
-  const out = [];
-  for (let i = 1; i < notes.length; i += 1) {
-    out.push((_nullishCoalesce(_optionalChain([notes, 'access', _77 => _77[i], 'optionalAccess', _78 => _78.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _79 => _79[i - 1], 'optionalAccess', _80 => _80.startBeat]), () => ( 0))));
-  }
-  return out;
-}
-function rhythmProfile(gaps) {
-  const unit = _nullishCoalesce(gaps[0], () => ( 0));
-  if (!(unit > EPS7)) {
-    return gaps.length === 0 ? [] : null;
-  }
-  return gaps.map((gap) => Math.round(gap / unit * RHYTHM_GRID) / RHYTHM_GRID);
-}
-function sameNumbers(a, b) {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i += 1) {
-    if (Math.abs((_nullishCoalesce(a[i], () => ( 0))) - (_nullishCoalesce(b[i], () => ( 0)))) > EPS7) {
-      return false;
-    }
-  }
-  return true;
-}
-function roundTo(value, digits) {
-  const scale = 10 ** digits;
-  return Math.round(value * scale) / scale;
-}
-function endBeatOf(notes) {
-  let end = 0;
-  for (const note of notes) {
-    end = Math.max(end, note.startBeat + note.durationBeat);
-  }
-  return end;
-}
-function onsetSpan(notes) {
-  if (notes.length < 2) {
-    return 0;
-  }
-  return (_nullishCoalesce(_optionalChain([notes, 'access', _81 => _81[notes.length - 1], 'optionalAccess', _82 => _82.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([notes, 'access', _83 => _83[0], 'optionalAccess', _84 => _84.startBeat]), () => ( 0)));
-}
-function spellingOf(key) {
-  if (key === void 0) {
-    return "sharp";
-  }
-  const spelled = _chunkUADYAYATcjs.spelledKeyOf.call(void 0, key);
-  return _chunkUADYAYATcjs.keySignatureFifths.call(void 0, spelled.tonic, spelled.key) < 0 ? "flat" : "sharp";
-}
-function intervalBetween(from, to, key) {
-  const spelling = spellingOf(key);
-  return _chunkQ2WGKJNNcjs.spelledInterval.call(void 0, _chunkQ2WGKJNNcjs.midiToNote.call(void 0, from, spelling), _chunkQ2WGKJNNcjs.midiToNote.call(void 0, to, spelling));
-}
-function intervalName(interval) {
-  return `${interval.descending && interval.semitones !== 0 ? "-" : ""}${interval.quality}${interval.number}`;
-}
-function ladderIndices(notes, key) {
-  const root = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
-  const offsets = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key).map((pc) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pc - root));
-  if (offsets.length === 0) {
-    return null;
-  }
-  const out = [];
-  for (const note of notes) {
-    const semitones = note.pitch - root;
-    const octave = Math.floor(semitones / 12);
-    const degree = offsets.indexOf(semitones - octave * 12);
-    if (degree < 0) {
-      return null;
-    }
-    out.push(octave * offsets.length + degree);
-  }
-  return out;
-}
-function ladderSteps(indices) {
-  const out = [];
-  for (let i = 1; i < indices.length; i += 1) {
-    out.push((_nullishCoalesce(indices[i], () => ( 0))) - (_nullishCoalesce(indices[i - 1], () => ( 0))));
-  }
-  return out;
-}
-function windowSignature(notes) {
-  const profile = rhythmProfile(onsetGaps(notes));
-  if (profile === null) {
-    return null;
-  }
-  return `${notes.length}|${intervalsOf(notes).join(",")}|${profile.join(",")}`;
-}
-function nonOverlapping(starts, length) {
-  const picked = [];
-  let lastEnd = Number.NEGATIVE_INFINITY;
-  for (const start of starts) {
-    if (start > lastEnd) {
-      picked.push(start);
-      lastEnd = start + length - 1;
-    }
-  }
-  return picked;
-}
-function subsumes(outer, inner) {
-  return inner.starts.every(
-    (start) => outer.starts.some((from) => start >= from && start + inner.length <= from + outer.length)
-  );
-}
-function listBeats(occurrences) {
-  const shown = occurrences.slice(0, 5).map((occurrence) => roundTo(occurrence.startBeat, 3));
-  return occurrences.length > shown.length ? `${shown.join(", ")}, and ${occurrences.length - shown.length} more` : shown.join(", ");
-}
-function motifFromGroup(group, notes) {
-  const first = _nullishCoalesce(group.starts[0], () => ( 0));
-  const prime = notes.slice(first, first + group.length).map((note) => ({ ...note }));
-  const primePitch = _nullishCoalesce(_optionalChain([prime, 'access', _85 => _85[0], 'optionalAccess', _86 => _86.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', _87 => _87[0], 'optionalAccess', _88 => _88.startBeat]), () => ( 0)),
-      endBeat: endBeatOf(statement),
-      transpose: (_nullishCoalesce(_optionalChain([statement, 'access', _89 => _89[0], 'optionalAccess', _90 => _90.pitch]), () => ( 0))) - primePitch,
-      timeRatio: primeSpan > EPS7 ? 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) > EPS7);
-  const detail = [
-    transposed ? "at more than one pitch level" : "at the same pitch level",
-    stretched ? "and in more than one set of note values" : ""
-  ].filter((part) => part !== "").join(" ");
-  return {
-    notes: prime,
-    intervals: intervalsOf(prime),
-    rhythm: _nullishCoalesce(rhythmProfile(onsetGaps(prime)), () => ( [])),
-    occurrences,
-    rationale: `${group.length}-note ${shape} cell stated ${occurrences.length} ${occurrences.length === 1 ? "time" : "times"} (beats ${listBeats(occurrences)}), ${detail}`
-  };
-}
-function extractMotifs(notes, opts = {}) {
-  const minNotes = _chunkQ2WGKJNNcjs.assertInteger.call(void 0, _nullishCoalesce(opts.minNotes, () => ( MIN_CELL_NOTES)), "motif minNotes", 2, 64);
-  const maxNotes = _chunkQ2WGKJNNcjs.assertInteger.call(void 0, _nullishCoalesce(opts.maxNotes, () => ( MAX_CELL_NOTES)), "motif maxNotes", 2, 64);
-  if (maxNotes < minNotes) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-      `motif maxNotes must be at least minNotes ${minNotes}; received ${maxNotes}`
-    );
-  }
-  const minOccurrences = _chunkQ2WGKJNNcjs.assertInteger.call(void 0, 
-    _nullishCoalesce(opts.minOccurrences, () => ( MIN_OCCURRENCES)),
-    "motif minOccurrences",
-    2
-  );
-  const sounding = orderedNotes(notes, "melody notes", opts.budget);
-  if (sounding.length < minNotes) {
-    return [];
-  }
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, sounding.length * (maxNotes - minNotes + 1), "motif windows", opts.budget);
-  const groups = /* @__PURE__ */ new Map();
-  for (let length = minNotes; length <= maxNotes; length += 1) {
-    for (let start = 0; start + length <= sounding.length; start += 1) {
-      const signature = windowSignature(sounding.slice(start, start + length));
-      if (signature === null) {
-        continue;
-      }
-      const group = groups.get(signature);
-      if (group === void 0) {
-        groups.set(signature, { signature, length, starts: [start] });
-      } else {
-        group.starts.push(start);
-      }
-    }
-  }
-  const candidates = [...groups.values()].map((group) => ({ ...group, starts: nonOverlapping(group.starts, group.length) })).filter((group) => group.starts.length >= minOccurrences).sort(
-    (a, b) => b.length - a.length || b.starts.length - a.starts.length || (_nullishCoalesce(a.starts[0], () => ( 0))) - (_nullishCoalesce(b.starts[0], () => ( 0))) || (a.signature < b.signature ? -1 : a.signature > b.signature ? 1 : 0)
-  );
-  const kept = [];
-  for (const candidate of candidates) {
-    const covered = kept.some(
-      (outer) => outer.length > candidate.length && outer.starts.length >= candidate.starts.length && subsumes(outer, candidate)
-    );
-    if (!covered) {
-      kept.push(candidate);
-    }
-  }
-  return kept.map((group) => motifFromGroup(group, sounding));
-}
-function motifFromNotes(notes) {
-  const sounding = orderedNotes(notes, "motif notes").map((note) => ({ ...note }));
-  return motifFromGroup(
-    { signature: _nullishCoalesce(windowSignature(sounding), () => ( "")), length: sounding.length, starts: [0] },
-    sounding
-  );
-}
-function pitchRelation(a, b) {
-  if (sameNumbers(a, b)) {
-    return "exact";
-  }
-  if (sameNumbers(
-    b,
-    a.map((step) => -step)
-  )) {
-    return "inversion";
-  }
-  const reversed = [...a].reverse();
-  if (sameNumbers(
-    b,
-    reversed.map((step) => -step)
-  )) {
-    return "retrograde";
-  }
-  if (sameNumbers(b, reversed)) {
-    return "retrogradeInversion";
-  }
-  return null;
-}
-function stretchPhrase(ratio) {
-  return `note values ${roundTo(ratio, 3)}x the model's`;
-}
-function relateMotifs(a, b, key) {
-  const model = a.notes;
-  const answer = b.notes;
-  if (model.length === 0 || model.length !== answer.length) {
-    return null;
-  }
-  const modelGaps = onsetGaps(model);
-  const answerGaps = onsetGaps(answer);
-  const modelProfile = rhythmProfile(modelGaps);
-  const answerProfile = rhythmProfile(answerGaps);
-  const retroProfile = rhythmProfile([...answerGaps].reverse());
-  if (modelProfile === null || answerProfile === null) {
-    return null;
-  }
-  const forward = sameNumbers(modelProfile, answerProfile);
-  const backward = retroProfile !== null && sameNumbers(modelProfile, retroProfile);
-  const modelSpan = onsetSpan(model);
-  const timeRatio = modelSpan > EPS7 ? onsetSpan(answer) / modelSpan : 1;
-  const semitones = (_nullishCoalesce(_optionalChain([answer, 'access', _91 => _91[0], 'optionalAccess', _92 => _92.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([model, 'access', _93 => _93[0], 'optionalAccess', _94 => _94.pitch]), () => ( 0)));
-  const interval = intervalBetween(_nullishCoalesce(_optionalChain([model, 'access', _95 => _95[0], 'optionalAccess', _96 => _96.pitch]), () => ( 0)), _nullishCoalesce(_optionalChain([answer, 'access', _97 => _97[0], 'optionalAccess', _98 => _98.pitch]), () => ( 0)), key);
-  const gap = (_nullishCoalesce(_optionalChain([answer, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.startBeat]), () => ( 0))) - endBeatOf(model);
-  const sequence = gap >= -SEQUENCE_GAP && gap <= SEQUENCE_GAP;
-  const stretched = Math.abs(timeRatio - 1) > EPS7;
-  const relation = pitchRelation(intervalsOf(model), intervalsOf(answer));
-  const base = { sequence, semitones, interval, timeRatio };
-  if (forward && relation === "exact") {
-    if (semitones === 0) {
-      if (!stretched) {
-        return {
-          ...base,
-          kind: "repetition",
-          rationale: "Exact repetition: the same pitches in the same rhythm"
-        };
-      }
-      const augmented = timeRatio > 1;
-      return {
-        ...base,
-        kind: augmented ? "augmentation" : "diminution",
-        rationale: `${augmented ? "Augmentation" : "Diminution"}: the same pitches in ${stretchPhrase(timeRatio)}`
-      };
-    }
-    const name = intervalName(interval);
-    return {
-      ...base,
-      kind: "transposition",
-      rationale: sequence ? `Real sequence: the cell restated ${name} away with every interval kept literally` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "") : `Transposition by ${name}: every interval kept literally` + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
-    };
-  }
-  if (forward && key !== void 0) {
-    const modelLadder = ladderIndices(model, key);
-    const answerLadder = ladderIndices(answer, key);
-    if (modelLadder !== null && answerLadder !== null) {
-      const degrees = (_nullishCoalesce(answerLadder[0], () => ( 0))) - (_nullishCoalesce(modelLadder[0], () => ( 0)));
-      if (degrees !== 0 && sameNumbers(ladderSteps(modelLadder), ladderSteps(answerLadder))) {
-        const direction = degrees > 0 ? "higher" : "lower";
-        const count = Math.abs(degrees);
-        return {
-          ...base,
-          kind: "tonalTransposition",
-          degrees,
-          rationale: `${sequence ? "Tonal sequence" : "Tonal transposition"}: the cell restated ${count} scale ${count === 1 ? "degree" : "degrees"} ${direction} inside the key, so the key resizes its intervals \u2014 a real one would have kept them literal`
-        };
-      }
-    }
-  }
-  if (forward && relation === "inversion") {
-    return {
-      ...base,
-      kind: "inversion",
-      rationale: "Inversion: every interval turned upside down about the first note" + (stretched ? `, in ${stretchPhrase(timeRatio)}` : "")
-    };
-  }
-  if (backward && relation === "retrograde") {
-    return {
-      ...base,
-      kind: "retrograde",
-      rationale: "Retrograde: the cell read back to front, rhythm included"
-    };
-  }
-  if (backward && relation === "retrogradeInversion") {
-    return {
-      ...base,
-      kind: "retrogradeInversion",
-      rationale: "Retrograde inversion: the cell read back to front and turned upside down"
-    };
-  }
-  return null;
-}
-function gradedEditDistance(a, b, cost) {
-  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i += 1) {
-    const row = new Array(b.length + 1);
-    row[0] = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const substitution = (_nullishCoalesce(previous[j - 1], () => ( 0))) + cost(_nullishCoalesce(a[i - 1], () => ( 0)), _nullishCoalesce(b[j - 1], () => ( 0)));
-      const deletion = (_nullishCoalesce(previous[j], () => ( 0))) + 1;
-      const insertion = (_nullishCoalesce(row[j - 1], () => ( 0))) + 1;
-      row[j] = Math.min(substitution, deletion, insertion);
-    }
-    previous = row;
-  }
-  return _nullishCoalesce(previous[b.length], () => ( 0));
-}
-function distanceToSimilarity(distance, a, b) {
-  const longest = Math.max(a, b);
-  if (longest === 0) {
-    return 1;
-  }
-  return Math.min(1, Math.max(0, 1 - distance / longest));
-}
-function intervalCost(x, y) {
-  return Math.min(1, Math.abs(x - y) / INTERVAL_TOLERANCE);
-}
-function gapCost(x, y) {
-  if (!(x > EPS7) || !(y > EPS7)) {
-    return Math.abs(x - y) > EPS7 ? 1 : 0;
-  }
-  return Math.min(1, Math.abs(Math.log2(x / y)));
-}
-function compareMelodies(a, b) {
-  const left = orderedNotes(phraseNotes(a), "melody a");
-  const right = orderedNotes(phraseNotes(b), "melody b");
-  const leftIntervals = intervalsOf(left);
-  const rightIntervals = intervalsOf(right);
-  const pitchSimilarity = distanceToSimilarity(
-    gradedEditDistance(leftIntervals, rightIntervals, intervalCost),
-    leftIntervals.length,
-    rightIntervals.length
-  );
-  const leftGaps = _nullishCoalesce(rhythmProfile(onsetGaps(left)), () => ( onsetGaps(left)));
-  const rightGaps = _nullishCoalesce(rhythmProfile(onsetGaps(right)), () => ( onsetGaps(right)));
-  const rhythmSimilarity = distanceToSimilarity(
-    gradedEditDistance(leftGaps, rightGaps, gapCost),
-    leftGaps.length,
-    rightGaps.length
-  );
-  const similarity = PITCH_WEIGHT * pitchSimilarity + RHYTHM_WEIGHT * rhythmSimilarity;
-  return {
-    similarity,
-    pitchSimilarity,
-    rhythmSimilarity,
-    rationale: `Interval shapes ${Math.round(pitchSimilarity * 100)}% alike, rhythms ${Math.round(rhythmSimilarity * 100)}% alike, weighted ${PITCH_WEIGHT}/${RHYTHM_WEIGHT} into ${roundTo(similarity, 3)}`
-  };
-}
-function melodicSimilarity(a, b) {
-  return compareMelodies(a, b).similarity;
-}
-function extremes(notes) {
-  let peak = 0;
-  let trough = 0;
-  for (let i = 1; i < notes.length; i += 1) {
-    if ((_nullishCoalesce(_optionalChain([notes, 'access', _101 => _101[i], 'optionalAccess', _102 => _102.pitch]), () => ( 0))) > (_nullishCoalesce(_optionalChain([notes, 'access', _103 => _103[peak], 'optionalAccess', _104 => _104.pitch]), () => ( 0)))) {
-      peak = i;
-    }
-    if ((_nullishCoalesce(_optionalChain([notes, 'access', _105 => _105[i], 'optionalAccess', _106 => _106.pitch]), () => ( 0))) < (_nullishCoalesce(_optionalChain([notes, 'access', _107 => _107[trough], 'optionalAccess', _108 => _108.pitch]), () => ( 0)))) {
-      trough = i;
-    }
-  }
-  return { peak, trough };
-}
-function melodicContour(notes) {
-  const line = orderedNotes(phraseNotes(notes), "contour notes");
-  const intervals = intervalsOf(line);
-  const directions = intervals.map(
-    (step) => step > 0 ? "up" : step < 0 ? "down" : "same"
-  );
-  const { peak, trough } = extremes(line);
-  const range = (_nullishCoalesce(_optionalChain([line, 'access', _109 => _109[peak], 'optionalAccess', _110 => _110.pitch]), () => ( 0))) - (_nullishCoalesce(_optionalChain([line, 'access', _111 => _111[trough], 'optionalAccess', _112 => _112.pitch]), () => ( 0)));
-  const motion = intervals.reduce((sum, step) => sum + Math.abs(step), 0);
-  if (motion === 0) {
-    return {
-      directions,
-      shape: "static",
-      peakIndex: peak,
-      troughIndex: trough,
-      range: 0,
-      rationale: line.length < 2 ? "Too short to have a direction, so the line is static" : "Every note at the same pitch, so the line is static"
-    };
-  }
-  const first = _nullishCoalesce(_optionalChain([line, 'access', _113 => _113[0], 'optionalAccess', _114 => _114.pitch]), () => ( 0));
-  const last = _nullishCoalesce(_optionalChain([line, 'access', _115 => _115[line.length - 1], 'optionalAccess', _116 => _116.pitch]), () => ( 0));
-  const net = last - first;
-  const directness = Math.abs(net) / motion;
-  const share = Math.round(directness * 100);
-  if (directness >= DIRECTIONAL_SHARE) {
-    const shape = net > 0 ? "ascending" : "descending";
-    return {
-      directions,
-      shape,
-      peakIndex: peak,
-      troughIndex: trough,
-      range,
-      rationale: `${share}% of the motion runs ${net > 0 ? "up" : "down"}, so the line is ${shape}`
-    };
-  }
-  const peakPitch = _nullishCoalesce(_optionalChain([line, 'access', _117 => _117[peak], 'optionalAccess', _118 => _118.pitch]), () => ( 0));
-  const archMotion = peakPitch - first + (peakPitch - last);
-  if (peak > 0 && peak < line.length - 1 && archMotion >= DIRECTIONAL_SHARE * motion) {
-    return {
-      directions,
-      shape: "arch",
-      peakIndex: peak,
-      troughIndex: trough,
-      range,
-      rationale: `Rises to its peak at note ${peak + 1} of ${line.length} and falls back, so the line is an arch`
-    };
-  }
-  return {
-    directions,
-    shape: "wave",
-    peakIndex: peak,
-    troughIndex: trough,
-    range,
-    rationale: `Changes direction without settling either way (${share}% of the motion nets out), so the line is a wave`
-  };
-}
-
-// src/analyze/form/phrase.ts
-var CADENCE_BOUNDARY_STRENGTH = {
-  authentic: 0.9,
-  modal: 0.75,
-  plagal: 0.7,
-  phrygian: 0.65,
-  half: 0.6,
-  deceptive: 0.45
-};
-var CADENCE_CLOSURE = {
-  authentic: 0.85,
-  modal: 0.6,
-  plagal: 0.55,
-  phrygian: 0.4,
-  half: 0.35,
-  deceptive: 0.3
-};
-var REST_STRENGTH = 0.6;
-var LONG_NOTE_STRENGTH = 0.4;
-var REPETITION_STRENGTH = 0.5;
-var REPETITION_THRESHOLD = 0.75;
-var HYPERMETER_STRENGTH = 0.25;
-var PIECE_END_STRENGTH = 0.5;
-var PHRASE_CUT_COST = 1.3;
-var CLOSING_SHARE = 0.65;
-var FINAL_PHRASE_BONUS = 0.15;
-var HYPERMETRIC_CLOSE_BONUS = 0.1;
-var EVADED_FACTOR = 0.6;
-var SIGNAL_ORDER = [
-  "cadence",
-  "rest",
-  "repetition",
-  "longNote",
-  "pieceEnd",
-  "hypermeter"
-];
-function addSignal(boundaries, beat, signal, strength, cadence = null) {
-  const key = Math.round(beat / EPS6);
-  const existing = boundaries.get(key);
-  const boundary = _nullishCoalesce(existing, () => ( { beat, strengths: /* @__PURE__ */ new Map(), cadence: null }));
-  boundary.strengths.set(signal, Math.max(_nullishCoalesce(boundary.strengths.get(signal), () => ( 0)), strength));
-  if (cadence !== null && boundary.cadence === null) {
-    boundary.cadence = cadence;
-  }
-  boundaries.set(key, boundary);
-}
-function readBoundary(boundary) {
-  const signals = [...boundary.strengths.entries()].sort(
-    (a, b) => b[1] - a[1] || SIGNAL_ORDER.indexOf(a[0]) - SIGNAL_ORDER.indexOf(b[0])
-  );
-  return {
-    strength: combineEvidence(signals.map(([, strength]) => strength)),
-    signals: signals.map(([signal]) => signal)
-  };
-}
-function lengthFit(length, expected) {
-  if (!(expected > 0)) {
-    return 0;
-  }
-  return Math.max(-1, 1 - Math.abs(length - expected) / expected);
-}
-function choosePhrasePath(beats, strengths, minPhraseBeats, expected) {
-  const value = new Array(beats.length).fill(Number.NEGATIVE_INFINITY);
-  const cameFrom = new Array(beats.length).fill(-1);
-  value[0] = 0;
-  for (let j = 1; j < beats.length; j += 1) {
-    const endBeat = _nullishCoalesce(beats[j], () => ( 0));
-    for (let i = 0; i < j; i += 1) {
-      if (!Number.isFinite(_nullishCoalesce(value[i], () => ( Number.NEGATIVE_INFINITY)))) {
-        continue;
-      }
-      const length = endBeat - (_nullishCoalesce(beats[i], () => ( 0)));
-      if (length < minPhraseBeats - EPS6) {
-        continue;
-      }
-      const gain = (_nullishCoalesce(value[i], () => ( 0))) + (_nullishCoalesce(strengths[j], () => ( 0))) + lengthFit(length, expected) - PHRASE_CUT_COST;
-      if (gain > (_nullishCoalesce(value[j], () => ( Number.NEGATIVE_INFINITY)))) {
-        value[j] = gain;
-        cameFrom[j] = i;
-      }
-    }
-  }
-  const last = beats.length - 1;
-  const path = [];
-  if (last > 0 && Number.isFinite(_nullishCoalesce(value[last], () => ( Number.NEGATIVE_INFINITY)))) {
-    for (let i = last; i > 0; i = _nullishCoalesce(cameFrom[i], () => ( 0))) {
-      path.push(i);
-    }
-    path.reverse();
-  } else if (last > 0) {
-    path.push(last);
-  }
-  return path;
-}
-function arrivalEnd(timeline, atBeat) {
-  for (const segment of timeline.segments) {
-    if (Math.abs(segment.startBeat - atBeat) < EPS6) {
-      return segment.endBeat;
-    }
-  }
-  return atBeat;
-}
-function resolveKey(opts, notes, meters, totalBeats) {
-  if (opts.key !== void 0) {
-    return opts.key;
-  }
-  const regions = keyTimelineFromNotes(notes, {
-    meters,
-    totalBeats,
-    budget: opts.budget
-  });
-  return keyLookup(regions, _nullishCoalesce(prevailingKeyOf(regions), () => ( _chunkUADYAYATcjs.majorKey.call(void 0, 0))));
-}
-function restBoundaries(boundaries, notes, meters, restBeats) {
-  const ordered = [...notes].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-  let covered = Number.NEGATIVE_INFINITY;
-  for (const note of ordered) {
-    const gap = note.startBeat - covered;
-    if (Number.isFinite(covered) && gap >= restBeats - EPS6) {
-      const bar = _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, note.startBeat, meters);
-      addSignal(
-        boundaries,
-        note.startBeat,
-        "rest",
-        REST_STRENGTH * clamp012(bar > 0 ? gap / bar : 1)
-      );
-    }
-    covered = Math.max(covered, note.startBeat + note.durationBeat);
-  }
-}
-function repetitionBoundaries(boundaries, notes, meters, spanStart, spanEnd, windowBeats, budget) {
-  if (!(windowBeats > 0)) {
-    return;
-  }
-  const slices = sliceBars(notes, meters, spanStart, spanEnd, budget);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, slices.length * notes.length, "form repetition comparisons", budget);
-  const onsetsIn = (from, to) => notes.filter((note) => note.startBeat >= from - EPS6 && note.startBeat < to - EPS6);
-  for (const slice of slices) {
-    const beat = slice.startBeat;
-    if (beat - windowBeats < spanStart - EPS6 || beat + windowBeats > spanEnd + EPS6) {
-      continue;
-    }
-    const before = onsetsIn(beat - windowBeats, beat);
-    const after = onsetsIn(beat, beat + windowBeats);
-    if (before.length < 2 || after.length < 2) {
-      continue;
-    }
-    const similarity = melodicSimilarity(before, after);
-    if (similarity >= REPETITION_THRESHOLD) {
-      addSignal(boundaries, beat, "repetition", REPETITION_STRENGTH * similarity);
-    }
-  }
-}
-function structuralWeightOf(cadence, confidence, aligned, isLast) {
-  if (cadence === null || cadence.cadence.type === null) {
-    return 0;
-  }
-  const result = cadence.cadence;
-  let base = CADENCE_CLOSURE[result.type];
-  if (result.type === "authentic") {
-    if (result.strength === "perfect") {
-      base = 1;
-    } else if (result.strength === "imperfect") {
-      base *= 0.8;
-    }
-  }
-  if (result.evaded) {
-    base *= EVADED_FACTOR;
-  }
-  let weight = base * confidence;
-  if (isLast) {
-    weight += FINAL_PHRASE_BONUS;
-  }
-  if (aligned || isLast) {
-    weight += HYPERMETRIC_CLOSE_BONUS;
-  }
-  return clamp012(weight);
-}
-function describeCadence(cadence) {
-  if (cadence === null || cadence.cadence.type === null) {
-    return "no cadence";
-  }
-  const { type, strength } = cadence.cadence;
-  const graded = strength === null ? type : `${strength} ${type}`;
-  return `a ${graded} cadence at beat ${cadence.atBeat}`;
-}
-function phrasesFromTimeline(timeline, notes, opts = {}) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "phrase meters");
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "phrase notes", {
-    allowNonPositiveDuration: true,
-    budget: opts.budget
-  });
-  const sounding = notes.filter((note) => note.durationBeat > 0);
-  const segments = timeline.segments;
-  const firstSegment = segments[0];
-  const lastSegment = segments[segments.length - 1];
-  const spanStart = sounding.reduce(
-    (first, n) => Math.min(first, n.startBeat),
-    _nullishCoalesce(_optionalChain([firstSegment, 'optionalAccess', _119 => _119.startBeat]), () => ( 0))
-  );
-  const notesEnd = sounding.reduce(
-    (end, n) => Math.max(end, n.startBeat + n.durationBeat),
-    _nullishCoalesce(_optionalChain([lastSegment, 'optionalAccess', _120 => _120.endBeat]), () => ( 0))
-  );
-  const spanEnd = Math.max(spanStart, _nullishCoalesce(opts.totalBeats, () => ( notesEnd)));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, spanEnd, 0, Number.MAX_SAFE_INTEGER, "phrase totalBeats");
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBarAt.call(void 0, Math.max(0, spanStart), meters);
-  const restBeats = _nullishCoalesce(opts.restBeats, () => ( barBeats / 2));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, restBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase restBeats");
-  const longNoteBeats = _nullishCoalesce(opts.longNoteBeats, () => ( barBeats));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, longNoteBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase longNoteBeats");
-  const minPhraseBeats = _nullishCoalesce(opts.minPhraseBeats, () => ( barBeats));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, minPhraseBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase minPhraseBeats");
-  const key = resolveKey(opts, sounding, meters, spanEnd);
-  const cadences = detectCadences(timeline, key);
-  const grouping = _nullishCoalesce(opts.hypermeter, () => ( hypermeter(sounding, meters, {
-    totalBeats: spanEnd,
-    cadenceBeats: cadences.map((hit) => hit.atBeat),
-    budget: opts.budget
-  })));
-  const hyperBeats = Math.max(
-    barBeats,
-    _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar: grouping.groupBars, beat: 0 }, meters) - _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar: 0, beat: 0 }, meters)
-  );
-  const expected = _nullishCoalesce(opts.expectedPhraseBeats, () => ( hyperBeats));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, expected, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase expectedPhraseBeats");
-  const boundaries = /* @__PURE__ */ new Map();
-  for (const hit of cadences) {
-    const type = hit.cadence.type;
-    if (type === null) {
-      continue;
-    }
-    addSignal(
-      boundaries,
-      arrivalEnd(timeline, hit.atBeat),
-      "cadence",
-      CADENCE_BOUNDARY_STRENGTH[type],
-      hit
-    );
-  }
-  restBoundaries(boundaries, sounding, meters, restBeats);
-  for (const note of sounding) {
-    if (note.durationBeat >= longNoteBeats - EPS6) {
-      addSignal(boundaries, note.startBeat + note.durationBeat, "longNote", LONG_NOTE_STRENGTH);
-    }
-  }
-  repetitionBoundaries(boundaries, sounding, meters, spanStart, spanEnd, hyperBeats, opts.budget);
-  for (const downbeat of grouping.downbeats) {
-    addSignal(boundaries, downbeat, "hypermeter", HYPERMETER_STRENGTH * grouping.confidence);
-  }
-  addSignal(boundaries, spanEnd, "pieceEnd", PIECE_END_STRENGTH);
-  const candidates = [...boundaries.values()].filter((boundary) => boundary.beat > spanStart + EPS6 && boundary.beat < spanEnd - EPS6).sort((a, b) => a.beat - b.beat);
-  const endBoundary = _nullishCoalesce(boundaries.get(Math.round(spanEnd / EPS6)), () => ( {
-    beat: spanEnd,
-    strengths: /* @__PURE__ */ new Map(),
-    cadence: null
-  }));
-  const stops = [
-    { beat: spanStart, strengths: /* @__PURE__ */ new Map(), cadence: null },
-    ...candidates,
-    endBoundary
-  ];
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, stops.length * stops.length, "form phrase boundary pairs", opts.budget);
-  const readings = stops.map(readBoundary);
-  const path = choosePhrasePath(
-    stops.map((stop) => stop.beat),
-    readings.map((reading) => reading.strength),
-    minPhraseBeats,
-    expected
-  );
-  const downbeatKeys = new Set(grouping.downbeats.map((downbeat) => Math.round(downbeat / EPS6)));
-  const phrases = [];
-  let from = 0;
-  for (let n = 0; n < path.length; n += 1) {
-    const to = _nullishCoalesce(path[n], () => ( stops.length - 1));
-    const startBeat = _nullishCoalesce(_optionalChain([stops, 'access', _121 => _121[from], 'optionalAccess', _122 => _122.beat]), () => ( spanStart));
-    const stop = stops[to];
-    const endBeat = _nullishCoalesce(_optionalChain([stop, 'optionalAccess', _123 => _123.beat]), () => ( spanEnd));
-    const reading = _nullishCoalesce(readings[to], () => ( { strength: 0, signals: [] }));
-    const length = endBeat - startBeat;
-    const confidence = clamp012(
-      CLOSING_SHARE * reading.strength + (1 - CLOSING_SHARE) * Math.max(0, lengthFit(length, expected))
-    );
-    const isLast = n === path.length - 1;
-    const cadence = _nullishCoalesce(_optionalChain([stop, 'optionalAccess', _124 => _124.cadence]), () => ( null));
-    const structuralWeight = structuralWeightOf(
-      cadence,
-      confidence,
-      downbeatKeys.has(Math.round(endBeat / EPS6)),
-      isLast
-    );
-    const bars = barBeats > 0 ? Math.round(length / barBeats * 100) / 100 : 0;
-    phrases.push({
-      startBeat,
-      endBeat,
-      cadence,
-      signals: reading.signals,
-      confidence,
-      structuralWeight,
-      rationale: `Phrase of ${bars} bar(s) closing on ${describeCadence(cadence)}; boundary from ${reading.signals.length === 0 ? "the end of the span" : reading.signals.join(", ")}`
-    });
-    from = to;
-  }
-  return phrases;
-}
-function structuralCadences(phrases) {
-  const ranked = [];
-  for (let index = 0; index < phrases.length; index += 1) {
-    const phrase = phrases[index];
-    if (phrase === void 0 || phrase.cadence === null || phrase.cadence.cadence.type === null) {
-      continue;
-    }
-    const hit = phrase.cadence;
-    ranked.push({
-      phraseIndex: index,
-      atBeat: hit.atBeat,
-      endBeat: phrase.endBeat,
-      cadence: hit.cadence,
-      weight: phrase.structuralWeight,
-      rationale: `Closes ${describeCadence(hit)} on a phrase of confidence ${Math.round(phrase.confidence * 100) / 100}`
-    });
-  }
-  return ranked.sort((a, b) => b.weight - a.weight || a.atBeat - b.atBeat);
-}
-
-// src/analyze/form/section.ts
-var MELODY_SHARE = 0.6;
-var HARMONY_SHARE = 0.4;
-var DEFAULT_THRESHOLD = 0.8;
-function labelAt(index) {
-  let n = index;
-  let label = "";
-  do {
-    label = String.fromCharCode(65 + n % 26) + label;
-    n = Math.floor(n / 26) - 1;
-  } while (n >= 0);
-  return label;
-}
-function unitSimilarity(a, b) {
-  const harmony = weightSimilarity(a.weights, b.weights);
-  if (a.notes.length < 2 || b.notes.length < 2) {
-    return a.notes.length === b.notes.length ? harmony : 0;
-  }
-  const melody = melodicSimilarity(a.notes, b.notes);
-  return clamp012(MELODY_SHARE * melody + HARMONY_SHARE * harmony);
-}
-function sectionsFromNotes(notes, opts = {}) {
-  const meters = _chunkK4ZJUGF4cjs.resolveMeters.call(void 0, opts, "section meters");
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "section notes", {
-    allowNonPositiveDuration: true,
-    budget: opts.budget
-  });
-  const sounding = notes.filter((note) => note.durationBeat > 0);
-  if (sounding.length === 0) {
-    return [];
-  }
-  const firstOnset = firstSoundingBeat(sounding);
-  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const spanEnd = Math.max(firstOnset, _nullishCoalesce(opts.totalBeats, () => ( lastEnd)));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, spanEnd, 0, Number.MAX_SAFE_INTEGER, "section totalBeats");
-  const threshold = _nullishCoalesce(opts.threshold, () => ( DEFAULT_THRESHOLD));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, threshold, 0, 1, "section threshold");
-  const unitBars = _nullishCoalesce(opts.unitBars, () => ( hypermeter(sounding, meters, { totalBeats: spanEnd, budget: opts.budget }).groupBars));
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, unitBars, "section unitBars");
-  const firstBar = _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, firstOnset, meters);
-  const lastBar = lastBarOf(meters, firstOnset, spanEnd);
-  const startBar = Math.max(0, firstBar);
-  const unitCount = Math.max(1, Math.ceil((lastBar - startBar + 1) / unitBars));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, unitCount * unitCount, "form section comparisons", opts.budget);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, unitCount * sounding.length, "form section unit notes", opts.budget);
-  const units = [];
-  for (let index = 0; index < unitCount; index += 1) {
-    const barStart = startBar + index * unitBars;
-    const startBeat = index === 0 ? firstOnset : _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar: barStart, beat: 0 }, meters);
-    const endBeat = index === unitCount - 1 ? spanEnd : _chunkK4ZJUGF4cjs.barPositionToBeat.call(void 0, { bar: barStart + unitBars, beat: 0 }, meters);
-    const unitNotes = sounding.filter((note) => note.startBeat >= startBeat - EPS6 && note.startBeat < endBeat - EPS6).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-    units.push({
-      startBeat,
-      endBeat,
-      notes: unitNotes,
-      weights: windowWeights(unitNotes, startBeat, endBeat, meters).weights
-    });
-  }
-  const labels = [];
-  const scores = [];
-  let distinct = 0;
-  for (let index = 0; index < units.length; index += 1) {
-    const unit = units[index];
-    if (unit === void 0) {
-      continue;
-    }
-    let bestScore = -1;
-    let bestIndex = -1;
-    for (let earlier = 0; earlier < index; earlier += 1) {
-      const other = units[earlier];
-      if (other === void 0) {
-        continue;
-      }
-      const score = unitSimilarity(unit, other);
-      if (score > bestScore) {
-        bestScore = score;
-        bestIndex = earlier;
-      }
-    }
-    if (bestIndex >= 0 && bestScore >= threshold) {
-      labels.push(_nullishCoalesce(labels[bestIndex], () => ( labelAt(distinct))));
-      scores.push(bestScore);
-    } else {
-      labels.push(labelAt(distinct));
-      scores.push(1);
-      distinct += 1;
-    }
-  }
-  const sections = [];
-  const firstByLabel = /* @__PURE__ */ new Map();
-  for (let index = 0; index < units.length; ) {
-    const label = _nullishCoalesce(labels[index], () => ( labelAt(0)));
-    let end = index;
-    let scoreSum = 0;
-    while (end < units.length && labels[end] === label) {
-      scoreSum += _nullishCoalesce(scores[end], () => ( 1));
-      end += 1;
-    }
-    const startBeat = _nullishCoalesce(_optionalChain([units, 'access', _125 => _125[index], 'optionalAccess', _126 => _126.startBeat]), () => ( 0));
-    const endBeat = _nullishCoalesce(_optionalChain([units, 'access', _127 => _127[end - 1], 'optionalAccess', _128 => _128.endBeat]), () => ( spanEnd));
-    const sectionIndex = sections.length;
-    const first = firstByLabel.get(label);
-    if (first === void 0) {
-      firstByLabel.set(label, sectionIndex);
-    }
-    const similarity = first === void 0 ? 1 : clamp012(scoreSum / (end - index));
-    sections.push({
-      label,
-      startBeat,
-      endBeat,
-      bars: lastBarOf(meters, startBeat, endBeat) - _chunkK4ZJUGF4cjs.barIndexAt.call(void 0, startBeat, meters) + 1,
-      firstOccurrence: _nullishCoalesce(first, () => ( sectionIndex)),
-      similarity,
-      rationale: first === void 0 ? `Section ${label}: material first heard at beat ${startBeat}` : `Section ${label}: ${Math.round(similarity * 100)}% alike the ${label} at beat ${_nullishCoalesce(_optionalChain([sections, 'access', _129 => _129[first], 'optionalAccess', _130 => _130.startBeat]), () => ( 0))}`
-    });
-    index = end;
-  }
-  return sections;
-}
-
-// src/analyze/reduction/index.ts
-var ADJACENCY_EPS = 1e-9;
-var TONIC_ARRIVING = /* @__PURE__ */ new Set(["authentic", "plagal", "modal", "deceptive"]);
-function signedStep(fromPc, toPc) {
-  return (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, toPc) - _chunkQ2WGKJNNcjs.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) <= ADJACENCY_EPS;
-}
-function median(values) {
-  if (values.length === 0) {
-    return 0;
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = sorted.length >> 1;
-  if (sorted.length % 2 === 1) {
-    return _nullishCoalesce(sorted[middle], () => ( 0));
-  }
-  return ((_nullishCoalesce(sorted[middle - 1], () => ( 0))) + (_nullishCoalesce(sorted[middle], () => ( 0)))) / 2;
-}
-function isTonicChord(chord, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 0;
-}
-function isDominantChord(chord, key) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc - key.rootPc) === 7 && chord.intervals.some((iv) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, iv) === 4);
-}
-function functionalReason(segment, before, after, keyAt) {
-  const key = keyAt(segment.startBeat);
-  if (after !== void 0 && _chunkOE6WK2Y2cjs.isCadentialSixFour.call(void 0, segment.chord, after.chord, key)) {
-    return { kind: "cadentialSixFour" };
-  }
-  if (isTonicChord(segment.chord, key)) {
-    return { kind: "tonic" };
-  }
-  if (isDominantChord(segment.chord, key)) {
-    return { kind: "dominant" };
-  }
-  if (before !== void 0) {
-    const arrival = _chunkOE6WK2Y2cjs.detectCadence.call(void 0, before.chord, segment.chord, key).type;
-    if (arrival !== null) {
-      return { kind: "cadenceArrival", cadence: arrival };
-    }
-  }
-  if (after !== void 0) {
-    const agent = _chunkOE6WK2Y2cjs.detectCadence.call(void 0, segment.chord, after.chord, keyAt(after.startBeat)).type;
-    if (agent !== null && TONIC_ARRIVING.has(agent)) {
-      return { kind: "cadenceAgent", cadence: agent };
-    }
-  }
-  return null;
-}
-function figureReason(segment, before, after) {
-  if (before === void 0 || after === void 0) {
-    return null;
-  }
-  const incoming = signedStep(before.chord.rootPc, segment.chord.rootPc);
-  const outgoing = signedStep(segment.chord.rootPc, after.chord.rootPc);
-  if (!isStep2(incoming) || !isStep2(outgoing)) {
-    return null;
-  }
-  if (incoming > 0 === outgoing > 0) {
-    return { kind: "passing" };
-  }
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, before.chord.rootPc) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, after.chord.rootPc) ? { kind: "neighbor" } : null;
-}
-function describe2(reason) {
-  switch (reason.kind) {
-    case "tonic":
-      return "Structural: the tonic of the key, which the progression is heard against";
-    case "dominant":
-      return "Structural: the dominant of the key, the chord its tonic is approached from";
-    case "cadentialSixFour":
-      return "Structural: a tonic six-four on the bass of the dominant that follows, which prolongs that dominant rather than framing the tonic";
-    case "cadenceArrival":
-      return `Structural: the arrival of a ${reason.cadence} cadence`;
-    case "cadenceAgent":
-      return `Structural: the chord that drives a ${reason.cadence} cadence`;
-    case "salient":
-      return "Structural: it holds the harmony at least as long as the median chord";
-    case "first":
-      return "Structural: the first chord of the progression frames it";
-    case "last":
-      return "Structural: the last chord of the progression frames it";
-    case "unfigured":
-      return "Structural: its root neither steps through to the next chord nor returns to the last, so it embellishes nothing";
-    case "passing":
-      return "Passing: its root steps in from the previous chord and on to the next in the same direction";
-    case "neighbor":
-      return "Neighbor: its root steps away from the surrounding harmony and returns to it";
-  }
-}
-var BASIS_READINGS = {
-  function: ({ segment, before, after, keyAt }) => functionalReason(segment, before, after, keyAt),
-  duration: ({ segment, salienceFloor }) => segment.endBeat - segment.startBeat >= salienceFloor ? { kind: "salient" } : null
-};
-var REDUCTION_BASES = Object.keys(BASIS_READINGS);
-function levelOf(reason) {
-  if (reason.kind === "passing") {
-    return "passing";
-  }
-  return reason.kind === "neighbor" ? "neighbor" : "structural";
-}
-function reduceProgression(timeline, key, opts = {}) {
-  const keyAt = typeof key === "function" ? key : () => key;
-  const basis = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.basis, () => ( "function")), REDUCTION_BASES, "reduction basis");
-  const reading = BASIS_READINGS[basis];
-  const segments = timeline.segments;
-  const salienceFloor = basis === "duration" ? median(segments.map((segment) => segment.endBeat - segment.startBeat)) : 0;
-  const result = [];
-  for (let index = 0; index < segments.length; index += 1) {
-    const segment = segments[index];
-    if (segment === void 0) {
-      continue;
-    }
-    const previous = segments[index - 1];
-    const following = segments[index + 1];
-    const before = previous !== void 0 && touches(previous, segment) ? previous : void 0;
-    const after = following !== void 0 && touches(segment, following) ? following : void 0;
-    let reason = reading({ segment, before, after, keyAt, salienceFloor });
-    if (reason === null && index === 0) {
-      reason = { kind: "first" };
-    }
-    if (reason === null && index === segments.length - 1) {
-      reason = { kind: "last" };
-    }
-    reason ??= _nullishCoalesce(figureReason(segment, before, after), () => ( { kind: "unfigured" }));
-    result.push({
-      chord: segment.chord,
-      startBeat: segment.startBeat,
-      endBeat: segment.endBeat,
-      level: levelOf(reason),
-      rationale: describe2(reason)
-    });
-  }
-  return result;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.keyTimelineFromNotes = keyTimelineFromNotes; exports.detectModulations = detectModulations; exports.keyLookup = keyLookup; exports.prevailingKeyOf = prevailingKeyOf; exports.chordTimelineFromChords = chordTimelineFromChords; exports.chordTimelineFromNotes = chordTimelineFromNotes; exports.detectCadences = detectCadences; exports.toVoiceNotes = toVoiceNotes; exports.analyzeVoice = analyzeVoice; exports.analyzeArrangement = analyzeArrangement; exports.createArrangementSession = createArrangementSession; exports.tensionCurve = tensionCurve; exports.tensionCurveFrom = tensionCurveFrom; exports.hypermeter = hypermeter; exports.extractMotifs = extractMotifs; exports.motifFromNotes = motifFromNotes; exports.relateMotifs = relateMotifs; exports.compareMelodies = compareMelodies; exports.melodicSimilarity = melodicSimilarity; exports.melodicContour = melodicContour; exports.phrasesFromTimeline = phrasesFromTimeline; exports.structuralCadences = structuralCadences; exports.sectionsFromNotes = sectionsFromNotes; exports.reduceProgression = reduceProgression;
-//# sourceMappingURL=chunk-B6XNKWZV.cjs.map