@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-GOZG57ER.js

@@ -0,0 +1,3220 @@
+import {
+  augmentedSixthFromPitchClasses,
+  detectCadence,
+  detectChord,
+  functionOf,
+  isCadentialSixFour,
+  pivotChords,
+  profileScore,
+  resolveKeyProfile
+} from "./chunk-H42UHPYW.js";
+import {
+  barIndexAt,
+  barPositionToBeat,
+  beatsPerBarAt,
+  createNoteEventIndex,
+  isStrongBeat,
+  metricWeight,
+  resolveMeters
+} from "./chunk-ELCTZUJJ.js";
+import {
+  PROFILE_WEIGHTS,
+  chordFromSpan,
+  chordPitchClasses,
+  chordToneRole,
+  createsVerticalDissonance,
+  evaluateSafety,
+  intervalAboveRoot,
+  isChordMember,
+  isLeadingToneResolution,
+  isScaleTone,
+  keyRelationBetween,
+  keySignatureFifths,
+  majorKey,
+  makeChord,
+  minorKey,
+  scaleTonesInDegreeOrder,
+  spelledKeyOf
+} from "./chunk-INHVXP6Z.js";
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertInteger,
+  assertNoteEvents,
+  assertOneOf,
+  assertPositiveInt,
+  assertRange,
+  midiToNote,
+  pitchClassOf,
+  spelledInterval
+} from "./chunk-VTI6FOLB.js";
+
+// 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);
+    assertGenerationBudget(memberships, opts.name, opts.budget);
+    for (let slot = first; slot < lastExclusive; slot += 1) {
+      buckets[slot]?.push(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 + metricWeight(note.startBeat, meter) / 3 : 1;
+    const pc = pitchClassOf(note.pitch);
+    weights[pc] = (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: majorKey(rootPc), rootPc, minor: false });
+    candidates.push({ key: minorKey(rootPc), rootPc, minor: true });
+  }
+  return candidates;
+})();
+function fifthsOf(rootPc, minor) {
+  const majorRoot = pitchClassOf(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 = (slots[0]?.scores ?? []).map((score) => -score);
+  const cameFrom = [];
+  for (let i = 1; i < slots.length; i += 1) {
+    const slot = slots[i];
+    const previous = costs;
+    const accent = metricWeight(slot?.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 = previous[to] ?? Number.POSITIVE_INFINITY;
+      let bestFrom = to;
+      for (let from = 0; from < count; from += 1) {
+        if (from === to) {
+          continue;
+        }
+        const distance = CANDIDATE_DISTANCE[from]?.[to] ?? 0;
+        const penalty = changeCost * metricFactor * (1 + FIFTHS_DISTANCE_COST * distance);
+        const cost = (previous[from] ?? Number.POSITIVE_INFINITY) + penalty;
+        if (cost < best2) {
+          best2 = cost;
+          bestFrom = from;
+        }
+      }
+      back[to] = bestFrom;
+      next[to] = best2 - (slot?.scores[to] ?? 0);
+    }
+    costs = next;
+    cameFrom.push(back);
+  }
+  let best = 0;
+  for (let c = 1; c < count; c += 1) {
+    if ((costs[c] ?? Number.POSITIVE_INFINITY) < (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 = cameFrom[i - 1]?.[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: 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 += slots[i]?.scores[candidate] ?? 0;
+      }
+      return total;
+    };
+    const left = before?.candidate;
+    const right = after?.candidate;
+    const winner = left === void 0 ? 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 = keyRelationBetween(spelledKeyOf(previous.key), spelledKeyOf(current.key));
+    if (relation !== null && relation !== "same") {
+      current.modulation = relation;
+    }
+  }
+  return regions;
+}
+function keyTimelineFromNotes(notes, opts = {}) {
+  const meters = resolveMeters(opts, "key timeline meters");
+  const bar = beatsPerBarAt(0, meters);
+  const expectedKeyBeats = opts.expectedKeyBeats ?? bar * 4;
+  assertRange(expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  const minKeyBeats = opts.minKeyBeats ?? bar;
+  assertRange(minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  const budget = opts.budget;
+  assertNoteEvents(notes, "key timeline notes", { allowNonPositiveDuration: true, budget });
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  const lastEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
+  const totalBeats = opts.totalBeats ?? lastEnd;
+  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "key timeline totalBeats");
+  const 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));
+  assertGenerationBudget(slotCount, "key timeline slots", budget);
+  if (slotCount === 0 || sounding.length === 0) {
+    return [];
+  }
+  const profile = resolveKeyProfile(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(
+        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 = slotWeights[i] ?? EMPTY_WEIGHTS;
+    const before = slotWeights[i - 1] ?? EMPTY_WEIGHTS;
+    const after = slotWeights[i + 1] ?? EMPTY_WEIGHTS;
+    const weights = own.weights.map(
+      (weight, pc) => weight + PAST_CONTEXT_SHARE * (before.weights[pc] ?? 0) + FUTURE_CONTEXT_SHARE * (after.weights[pc] ?? 0)
+    );
+    const totalWeight = own.totalWeight;
+    const scores = KEY_CANDIDATES.map(
+      (candidate) => profileScore(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 = candidate?.key ?? majorKey(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] = (weights[pc] ?? 0) + (slot.weights[pc] ?? 0);
+      }
+    }
+    const correlation = profileScore(
+      weights,
+      candidate?.minor ? profile.minor : profile.major,
+      candidate?.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 = chordPitchClasses(chord);
+  if (tones.length === 0) {
+    return 0;
+  }
+  let inKey = 0;
+  for (const pc of tones) {
+    if (isScaleTone(pc, candidate.key)) {
+      inKey += 1;
+    }
+  }
+  let score = CHORD_TONE_CREDIT * ((inKey - (tones.length - inKey)) / tones.length);
+  const rootDegree = pitchClassOf(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 = resolveMeters(opts, "modulation meters");
+  const bar = beatsPerBarAt(0, meters);
+  const expectedKeyBeats = opts.expectedKeyBeats ?? bar * 4;
+  assertRange(expectedKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "expectedKeyBeats");
+  const minKeyBeats = opts.minKeyBeats ?? bar;
+  assertRange(minKeyBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minKeyBeats");
+  assertGenerationBudget(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 = opts.totalBeats ?? lastChordEnd;
+  assertRange(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 = ordered[i]?.chord;
+    const approaching = ordered[i - 1]?.chord;
+    const slot = slots[i];
+    if (arriving === void 0 || approaching === void 0 || slot === void 0) {
+      continue;
+    }
+    const isDominantMotion = pitchClassOf(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 && pitchClassOf(arriving.rootPc - candidate.rootPc) === 0) {
+        slot.scores[c] = (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 = resolveKeyProfile(opts.profile);
+  const regions = grouped.map((region) => {
+    const candidate = KEY_CANDIDATES[region.candidate];
+    const key = candidate?.key ?? majorKey(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 chordPitchClasses(segment.chord)) {
+        weights[pc] = (weights[pc] ?? 0) + overlap;
+      }
+    }
+    const correlation = profileScore(
+      weights,
+      candidate?.minor ? profile.minor : profile.major,
+      candidate?.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 = pitchClassOf(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, pitchClassOf(root + third), pitchClassOf(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 = pitchClassOf(last.chord.rootPc);
+    const pivot = pivotChords(previous.key, current.key).find(
+      (entry) => entry.chord.rootPc === root && sameTones(chordPitchClasses(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 ((regions[middle]?.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 = `${pitchClassOf(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) {
+  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  assertGenerationBudget(chords.length, "timeline chords");
+  for (let index = 0; index < chords.length; index += 1) {
+    assertRange(
+      chords[index]?.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: chordFromSpan(gc)
+    };
+  }).filter((seg) => seg.endBeat > seg.startBeat);
+  return { at: segmentLookup(segments), segments };
+}
+function segmentLookup(segments) {
+  return (beat) => {
+    assertFiniteNumber(beat, "timeline query beat");
+    let low = 0;
+    let high = segments.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if ((segments[middle]?.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 MISMATCH_PENALTY = 0.3;
+function scoreMatch(match, weights, maxWeight, key) {
+  const rootWeight = maxWeight > 0 ? (weights[match.rootPc] ?? 0) / maxWeight : 0;
+  const tones = chordPitchClasses(makeChord(match.rootPc, match.quality));
+  let score = rootWeight;
+  if (tones.every((pc) => isScaleTone(pc, key))) {
+    score += DIATONIC_BONUS;
+  }
+  if (match.exact) {
+    score += EXACT_BONUS;
+  }
+  score -= MISMATCH_PENALTY * (match.extraPcs.length + match.missingPcs.length);
+  return score;
+}
+function chordConfidence(chord, weights, totalWeight, exact) {
+  const tones = new Set(chordPitchClasses(chord));
+  let chordWeight = 0;
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (tones.has(pc)) {
+      chordWeight += 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 = pitchClassOf(lowestPitch);
+  const hasBass = selected.includes(bassPc);
+  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
+  const matches = detectChord(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 ? augmentedSixthFromPitchClasses(selected, bassPc, key) : null;
+    if (augmented !== null) {
+      return {
+        chord: augmented,
+        confidence: chordConfidence(augmented, weights, totalWeight, true)
+      };
+    }
+    const chord = makeChord(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(...chordPitchClasses(makeChord(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 = LEXICON_TONE_START[candidate] ?? 0;
+  const last = LEXICON_TONE_START[candidate + 1] ?? first;
+  let covered = 0;
+  let missing = 0;
+  for (let index = first; index < last; index += 1) {
+    const weight = weights[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 * (weights[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] = -(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 = costs[c] ?? Number.POSITIVE_INFINITY;
+      if (cost < cheapest) {
+        cheapest = cost;
+        cheapestIndex = c;
+      }
+    }
+    const slotStart = beatOfSlot(grid, from + i);
+    const accent = metricWeight(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 = costs[c] ?? Number.POSITIVE_INFINITY;
+      const carried = stay <= change ? stay : change;
+      back[rowBase + c] = stay <= change ? c : cheapestIndex;
+      next[c] = carried - (scores[rowBase + c] ?? 0);
+    }
+    const previous = costs;
+    costs = next;
+    next = previous;
+  }
+  let best = 0;
+  for (let c = 1; c < LEXICON_SIZE; c += 1) {
+    if ((costs[c] ?? Number.POSITIVE_INFINITY) < (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 = 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 = slotWeights[i]?.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 [...slotNotes[first] ?? []];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = first; i < lastExclusive; i += 1) {
+    for (const note of 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 = resolveMeters(opts, "timeline meters");
+  const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBarAt(0, meters);
+  assertRange(harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  const segmentation = opts.segmentation ?? "dynamic";
+  const minChordBeats = opts.minChordBeats ?? DEFAULT_MIN_CHORD_BEATS;
+  assertRange(minChordBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "minChordBeats");
+  const budget = opts.budget;
+  const noteOptions = { allowNonPositiveDuration: true, budget };
+  if (opts.pickupBeats !== void 0) {
+    assertRange(opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "timeline pickupBeats");
+    noteOptions.minStartBeat = -opts.pickupBeats;
+  }
+  assertNoteEvents(notes, "timeline notes", noteOptions);
+  const soundingIndex = createNoteEventIndex(
+    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 = opts.totalBeats ?? lastNoteEnd;
+  assertRange(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 = prevailingKeyOf(keys) ?? majorKey(0);
+  const keyAt = keyLookup(keys, prevailingKey);
+  const segments = [];
+  const segmentConfidence = [];
+  const slotCount = Math.max(0, Math.ceil((totalBeats - grid.origin) / slotBeats - EPS4));
+  assertGenerationBudget(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, dirty?.from ?? 0);
+  const dirtyTo = carried === void 0 ? slotCount : Math.min(slotCount, dirty?.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 ? carried?.slotWeights[i] : void 0;
+    if (reusable !== void 0) {
+      slotWeights[i] = reusable;
+      continue;
+    }
+    const start = beatOfSlot(grid, i);
+    const weights = windowWeights(
+      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 = 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 = detectCadence(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 = chord.bassPc ?? chord.rootPc;
+  return ((pitchClassOf(pitch) - pitchClassOf(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 (isChordMember(pitch - delta, chord)) {
+      return pitch - delta;
+    }
+    if (isChordMember(pitch + delta, chord)) {
+      return pitch + delta;
+    }
+  }
+  return void 0;
+}
+function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
+  assertNoteEvents(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 = isChordMember(note.pitch, chord);
+    let handled = false;
+    if (chord && member) {
+      const role = chordToneRole(note.pitch, chord);
+      const degree = role === null ? tensionDegree(intervalAboveRoot(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 && isChordMember(prev.pitch, prevChord);
+      const resolves = isStep(next.pitch, note.pitch);
+      const others = otherVoicesAtBeat(note.startBeat);
+      const verticallyDissonant = others.some(
+        (ov) => createsVerticalDissonance(note.pitch, ov.pitch, true)
+      );
+      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 = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));
+      const nextMember = isChordMember(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 && isChordMember(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 (isChordMember(next.pitch, nextChord)) {
+        labels.push({ kind: "anticipation" });
+        handled = true;
+      }
+    }
+    if (!handled && chord && prev && next && !member) {
+      const prevMember = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));
+      const nextMember = isChordMember(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 = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));
+      const nextMember = isChordMember(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 = intervalAboveRoot(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 && isLeadingToneResolution(note.pitch, next.pitch, keyAt(next.startBeat))) {
+      labels.push({ kind: "leadingTone", resolveTo: next.pitch });
+    }
+    const analyzed = {
+      noteId: 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(PROFILE_WEIGHTS);
+function arrangementProfile(profile) {
+  return assertOneOf(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 = tracks[index]?.notes;
+    if (!Array.isArray(notes)) {
+      throw new InvalidInputError(
+        `tracks[${index}].notes must be an array; received ${typeof notes}`
+      );
+    }
+    assertNoteEvents(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 InvalidInputError(`${name}[${index}] must be a track index; received ${value}`);
+    }
+    const track = Math.trunc(value);
+    if (track < 0 || track >= trackCount) {
+      throw new 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 = lanes[lane]?.[(lanes[lane]?.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) {
+      lanes[best]?.push(note);
+      return true;
+    }
+    return false;
+  };
+  for (let start = 0; start < ordered.length; ) {
+    const onset = ordered[start]?.startBeat ?? 0;
+    let end = start + 1;
+    while (end < ordered.length && Math.abs((ordered[end]?.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) {
+          lanes[lane.index]?.push(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 ((sounding[middle]?.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 ? prev?.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: track.name ?? `track ${index + 1}`,
+      role: 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: 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 = given ?? attachPivots(
+    key !== void 0 ? [{ startBeat: 0, endBeat: totalBeats, key, confidence: 1 }] : keyTimelineFromNotes(pooled, { meters, totalBeats, budget }),
+    timeline.segments
+  );
+  return {
+    timeline,
+    keys,
+    prevailingKey: prevailingKeyOf(keys) ?? majorKey(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 = track.voices[v]?.at(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 = 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 ((timeline.segments[middle]?.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 = timeline.segments[i]?.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 = resolveMeters(opts, "arrangement meters");
+  const budget = opts.budget;
+  const noteOptions = { allowNonPositiveDuration: true, budget };
+  if (opts.pickupBeats !== void 0) {
+    assertRange(opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "arrangement pickupBeats");
+    noteOptions.minStartBeat = -opts.pickupBeats;
+  }
+  assertGenerationBudget(tracks.length, "arrangement tracks", budget);
+  const noteCount = assertTrackNotes(tracks, noteOptions);
+  assertGenerationBudget(noteCount, "arrangement notes", budget);
+  const profile = arrangementProfile(opts.profile);
+  const minSeverity = 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);
+  assertGenerationBudget(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: isStrongBeat(beat, meters)
+          };
+          let result = evaluateSafety(safetyQuery, { suggestions: false });
+          if (result.safety !== 0 /* Safe */ && result.safety >= minSeverity) {
+            result = evaluateSafety(safetyQuery);
+            const conflict = {
+              beat,
+              trackName: track.name,
+              trackIndex: track.trackIndex,
+              noteId: note.id,
+              pitch: note.pitch,
+              labels: 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}|${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) {
+      assertGenerationBudget(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 InvalidInputError(
+            `edits[${index}].trackIndex ${edit.trackIndex} is outside the session's ${tracks.length} tracks`
+          );
+        }
+        if (!Array.isArray(edit.notes)) {
+          throw new InvalidInputError(
+            `edits[${index}].notes must be an array; received ${typeof edit.notes}`
+          );
+        }
+        assertNoteEvents(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 = resolveMeters(opts, "arrangement meters");
+  const budget = opts.budget;
+  const noteOptions = { allowNonPositiveDuration: true, budget };
+  if (opts.pickupBeats !== void 0) {
+    assertRange(opts.pickupBeats, 0, Number.MAX_SAFE_INTEGER, "arrangement pickupBeats");
+    noteOptions.minStartBeat = -opts.pickupBeats;
+  }
+  assertGenerationBudget(tracks.length, "arrangement tracks", budget);
+  const noteCount = assertTrackNotes(tracks, noteOptions);
+  assertGenerationBudget(noteCount, "arrangement notes", budget);
+  const profile = arrangementProfile(opts.profile);
+  const step = opts.step ?? 1;
+  assertRange(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 : 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: prevailingKeyOf(suppliedKeys) ?? majorKey(0)
+  };
+  const regions = opts.keys ?? keys;
+  const keyAt = keyLookup(regions, prevailingKeyOf(regions) ?? prevailingKey);
+  const prepared = prepareTracks(tracks);
+  const points = [];
+  const sampleCount = Math.max(0, Math.ceil((totalBeats - sampleStart) / step - EPS5));
+  assertGenerationBudget(sampleCount, "tension samples", budget);
+  const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
+  assertGenerationBudget(
+    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[functionOf(chord, key)] : 0;
+  const chordPcs = chord ? new Set(chordPitchClasses(chord)) : null;
+  const strongBeat = isStrongBeat(beat, meters);
+  let nonChord = 0;
+  let dissonant = 0;
+  const pitches = /* @__PURE__ */ new Map();
+  for (const voice of sounding) {
+    pitches.set(voice.pitch, (pitches.get(voice.pitch) ?? 0) + 1);
+  }
+  for (const [pitch, count] of pitches) {
+    if (chordPcs && !chordPcs.has(pitchClassOf(pitch))) {
+      nonChord += count;
+    }
+    const others = [...pitches].flatMap(
+      ([otherPitch, otherCount]) => Array.from({ length: otherCount - (otherPitch === pitch ? 1 : 0) }, () => ({
+        pitch: otherPitch
+      }))
+    );
+    const result = evaluateSafety(
+      {
+        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 = barIndexAt(spanStart, meter);
+  const bar = barIndexAt(Math.max(spanStart, spanEnd), meter);
+  if (bar > firstBar && barPositionToBeat({ bar, beat: 0 }, meter) >= spanEnd - EPS6) {
+    return bar - 1;
+  }
+  return bar;
+}
+function sliceBars(notes, meter, spanStart, spanEnd, budget) {
+  const firstBar = barIndexAt(spanStart, meter);
+  const lastBar = lastBarOf(meter, spanStart, spanEnd);
+  const barCount = lastBar - firstBar + 1;
+  assertGenerationBudget(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, barIndexAt(note.startBeat, meter));
+    const to = Math.min(lastBar, barIndexAt(Math.max(note.startBeat, noteEnd - EPS6), meter));
+    memberships += Math.max(0, to - from + 1);
+    assertGenerationBudget(memberships, "form note-to-bar memberships", budget);
+    for (let bar = from; bar <= to; bar += 1) {
+      buckets[bar - firstBar]?.push(note);
+    }
+  }
+  const slices = [];
+  for (let bar = firstBar; bar <= lastBar; bar += 1) {
+    const startBeat = barPositionToBeat({ bar, beat: 0 }, meter);
+    const endBeat = barPositionToBeat({ bar: bar + 1, beat: 0 }, meter);
+    const barNotes = 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 = a[i] ?? 0;
+    const y = 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 = 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 = meter ?? resolveMeters({});
+  assertNoteEvents(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 = opts.totalBeats ?? lastEnd;
+  assertRange(spanEnd, 0, Number.MAX_SAFE_INTEGER, "hypermeter totalBeats");
+  const spanStart = firstOnset < 0 ? gridOriginOf(firstOnset, beatsPerBarAt(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);
+  }
+  assertGenerationBudget(
+    candidates.reduce((sum, groupBars) => sum + groupBars * slices.length, 0),
+    "hypermeter readings",
+    opts.budget
+  );
+  const novelty = slices.map((_, index) => harmonicNovelty(slices, index));
+  const cadenceBars = (opts.cadenceBeats ?? []).map((beat) => barIndexAt(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 * (GROUP_PRIOR.get(groupBars) ?? 0)
+      });
+    }
+  }
+  readings.sort(
+    (a, b) => b.score - a.score || (GROUP_PRIOR.get(b.groupBars) ?? 0) - (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) {
+  assertNoteEvents(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((notes[i]?.pitch ?? 0) - (notes[i - 1]?.pitch ?? 0));
+  }
+  return out;
+}
+function onsetGaps(notes) {
+  const out = [];
+  for (let i = 1; i < notes.length; i += 1) {
+    out.push((notes[i]?.startBeat ?? 0) - (notes[i - 1]?.startBeat ?? 0));
+  }
+  return out;
+}
+function rhythmProfile(gaps) {
+  const unit = 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((a[i] ?? 0) - (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 (notes[notes.length - 1]?.startBeat ?? 0) - (notes[0]?.startBeat ?? 0);
+}
+function spellingOf(key) {
+  if (key === void 0) {
+    return "sharp";
+  }
+  const spelled = spelledKeyOf(key);
+  return keySignatureFifths(spelled.tonic, spelled.key) < 0 ? "flat" : "sharp";
+}
+function intervalBetween(from, to, key) {
+  const spelling = spellingOf(key);
+  return spelledInterval(midiToNote(from, spelling), midiToNote(to, spelling));
+}
+function intervalName(interval) {
+  return `${interval.descending && interval.semitones !== 0 ? "-" : ""}${interval.quality}${interval.number}`;
+}
+function ladderIndices(notes, key) {
+  const root = pitchClassOf(key.rootPc);
+  const offsets = scaleTonesInDegreeOrder(key).map((pc) => pitchClassOf(pc - root));
+  if (offsets.length === 0) {
+    return null;
+  }
+  const out = [];
+  for (const note of notes) {
+    const semitones = note.pitch - root;
+    const octave = Math.floor(semitones / 12);
+    const degree = offsets.indexOf(semitones - octave * 12);
+    if (degree < 0) {
+      return null;
+    }
+    out.push(octave * offsets.length + degree);
+  }
+  return out;
+}
+function ladderSteps(indices) {
+  const out = [];
+  for (let i = 1; i < indices.length; i += 1) {
+    out.push((indices[i] ?? 0) - (indices[i - 1] ?? 0));
+  }
+  return out;
+}
+function 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 = group.starts[0] ?? 0;
+  const prime = notes.slice(first, first + group.length).map((note) => ({ ...note }));
+  const primePitch = prime[0]?.pitch ?? 0;
+  const primeSpan = onsetSpan(prime);
+  const occurrences = group.starts.map((start) => {
+    const statement = notes.slice(start, start + group.length);
+    const span = onsetSpan(statement);
+    return {
+      noteIndex: start,
+      startBeat: statement[0]?.startBeat ?? 0,
+      endBeat: endBeatOf(statement),
+      transpose: (statement[0]?.pitch ?? 0) - primePitch,
+      timeRatio: primeSpan > 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: 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 = assertInteger(opts.minNotes ?? MIN_CELL_NOTES, "motif minNotes", 2, 64);
+  const maxNotes = assertInteger(opts.maxNotes ?? MAX_CELL_NOTES, "motif maxNotes", 2, 64);
+  if (maxNotes < minNotes) {
+    throw new InvalidInputError(
+      `motif maxNotes must be at least minNotes ${minNotes}; received ${maxNotes}`
+    );
+  }
+  const minOccurrences = assertInteger(
+    opts.minOccurrences ?? MIN_OCCURRENCES,
+    "motif minOccurrences",
+    2
+  );
+  const sounding = orderedNotes(notes, "melody notes", opts.budget);
+  if (sounding.length < minNotes) {
+    return [];
+  }
+  assertGenerationBudget(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 || (a.starts[0] ?? 0) - (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: 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 = (answer[0]?.pitch ?? 0) - (model[0]?.pitch ?? 0);
+  const interval = intervalBetween(model[0]?.pitch ?? 0, answer[0]?.pitch ?? 0, key);
+  const gap = (answer[0]?.startBeat ?? 0) - endBeatOf(model);
+  const sequence = gap >= -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 = (answerLadder[0] ?? 0) - (modelLadder[0] ?? 0);
+      if (degrees !== 0 && sameNumbers(ladderSteps(modelLadder), ladderSteps(answerLadder))) {
+        const direction = degrees > 0 ? "higher" : "lower";
+        const count = Math.abs(degrees);
+        return {
+          ...base,
+          kind: "tonalTransposition",
+          degrees,
+          rationale: `${sequence ? "Tonal sequence" : "Tonal transposition"}: the cell restated ${count} scale ${count === 1 ? "degree" : "degrees"} ${direction} inside the key, so the key resizes its intervals \u2014 a real one would have kept them literal`
+        };
+      }
+    }
+  }
+  if (forward && 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 = (previous[j - 1] ?? 0) + cost(a[i - 1] ?? 0, b[j - 1] ?? 0);
+      const deletion = (previous[j] ?? 0) + 1;
+      const insertion = (row[j - 1] ?? 0) + 1;
+      row[j] = Math.min(substitution, deletion, insertion);
+    }
+    previous = row;
+  }
+  return previous[b.length] ?? 0;
+}
+function distanceToSimilarity(distance, a, b) {
+  const longest = Math.max(a, b);
+  if (longest === 0) {
+    return 1;
+  }
+  return Math.min(1, Math.max(0, 1 - distance / longest));
+}
+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 = rhythmProfile(onsetGaps(left)) ?? onsetGaps(left);
+  const rightGaps = rhythmProfile(onsetGaps(right)) ?? onsetGaps(right);
+  const rhythmSimilarity = distanceToSimilarity(
+    gradedEditDistance(leftGaps, rightGaps, gapCost),
+    leftGaps.length,
+    rightGaps.length
+  );
+  const similarity = PITCH_WEIGHT * pitchSimilarity + RHYTHM_WEIGHT * rhythmSimilarity;
+  return {
+    similarity,
+    pitchSimilarity,
+    rhythmSimilarity,
+    rationale: `Interval shapes ${Math.round(pitchSimilarity * 100)}% alike, rhythms ${Math.round(rhythmSimilarity * 100)}% alike, weighted ${PITCH_WEIGHT}/${RHYTHM_WEIGHT} into ${roundTo(similarity, 3)}`
+  };
+}
+function melodicSimilarity(a, b) {
+  return compareMelodies(a, b).similarity;
+}
+function extremes(notes) {
+  let peak = 0;
+  let trough = 0;
+  for (let i = 1; i < notes.length; i += 1) {
+    if ((notes[i]?.pitch ?? 0) > (notes[peak]?.pitch ?? 0)) {
+      peak = i;
+    }
+    if ((notes[i]?.pitch ?? 0) < (notes[trough]?.pitch ?? 0)) {
+      trough = i;
+    }
+  }
+  return { peak, trough };
+}
+function melodicContour(notes) {
+  const line = orderedNotes(phraseNotes(notes), "contour notes");
+  const intervals = intervalsOf(line);
+  const directions = intervals.map(
+    (step) => step > 0 ? "up" : step < 0 ? "down" : "same"
+  );
+  const { peak, trough } = extremes(line);
+  const range = (line[peak]?.pitch ?? 0) - (line[trough]?.pitch ?? 0);
+  const motion = intervals.reduce((sum, step) => sum + Math.abs(step), 0);
+  if (motion === 0) {
+    return {
+      directions,
+      shape: "static",
+      peakIndex: peak,
+      troughIndex: trough,
+      range: 0,
+      rationale: line.length < 2 ? "Too short to have a direction, so the line is static" : "Every note at the same pitch, so the line is static"
+    };
+  }
+  const first = line[0]?.pitch ?? 0;
+  const last = line[line.length - 1]?.pitch ?? 0;
+  const net = last - first;
+  const directness = Math.abs(net) / motion;
+  const share = Math.round(directness * 100);
+  if (directness >= DIRECTIONAL_SHARE) {
+    const shape = net > 0 ? "ascending" : "descending";
+    return {
+      directions,
+      shape,
+      peakIndex: peak,
+      troughIndex: trough,
+      range,
+      rationale: `${share}% of the motion runs ${net > 0 ? "up" : "down"}, so the line is ${shape}`
+    };
+  }
+  const peakPitch = line[peak]?.pitch ?? 0;
+  const archMotion = peakPitch - first + (peakPitch - last);
+  if (peak > 0 && peak < line.length - 1 && archMotion >= DIRECTIONAL_SHARE * motion) {
+    return {
+      directions,
+      shape: "arch",
+      peakIndex: peak,
+      troughIndex: trough,
+      range,
+      rationale: `Rises to its peak at note ${peak + 1} of ${line.length} and falls back, so the line is an arch`
+    };
+  }
+  return {
+    directions,
+    shape: "wave",
+    peakIndex: peak,
+    troughIndex: trough,
+    range,
+    rationale: `Changes direction without settling either way (${share}% of the motion nets out), so the line is a wave`
+  };
+}
+
+// src/analyze/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 = existing ?? { beat, strengths: /* @__PURE__ */ new Map(), cadence: null };
+  boundary.strengths.set(signal, Math.max(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 = beats[j] ?? 0;
+    for (let i = 0; i < j; i += 1) {
+      if (!Number.isFinite(value[i] ?? Number.NEGATIVE_INFINITY)) {
+        continue;
+      }
+      const length = endBeat - (beats[i] ?? 0);
+      if (length < minPhraseBeats - EPS6) {
+        continue;
+      }
+      const gain = (value[i] ?? 0) + (strengths[j] ?? 0) + lengthFit(length, expected) - PHRASE_CUT_COST;
+      if (gain > (value[j] ?? Number.NEGATIVE_INFINITY)) {
+        value[j] = gain;
+        cameFrom[j] = i;
+      }
+    }
+  }
+  const last = beats.length - 1;
+  const path = [];
+  if (last > 0 && Number.isFinite(value[last] ?? Number.NEGATIVE_INFINITY)) {
+    for (let i = last; i > 0; i = 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, prevailingKeyOf(regions) ?? majorKey(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 = beatsPerBarAt(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);
+  assertGenerationBudget(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 = resolveMeters(opts, "phrase meters");
+  assertNoteEvents(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),
+    firstSegment?.startBeat ?? 0
+  );
+  const notesEnd = sounding.reduce(
+    (end, n) => Math.max(end, n.startBeat + n.durationBeat),
+    lastSegment?.endBeat ?? 0
+  );
+  const spanEnd = Math.max(spanStart, opts.totalBeats ?? notesEnd);
+  assertRange(spanEnd, 0, Number.MAX_SAFE_INTEGER, "phrase totalBeats");
+  const barBeats = beatsPerBarAt(Math.max(0, spanStart), meters);
+  const restBeats = opts.restBeats ?? barBeats / 2;
+  assertRange(restBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase restBeats");
+  const longNoteBeats = opts.longNoteBeats ?? barBeats;
+  assertRange(longNoteBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase longNoteBeats");
+  const minPhraseBeats = opts.minPhraseBeats ?? barBeats;
+  assertRange(minPhraseBeats, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "phrase minPhraseBeats");
+  const key = resolveKey(opts, sounding, meters, spanEnd);
+  const cadences = detectCadences(timeline, key);
+  const grouping = opts.hypermeter ?? hypermeter(sounding, meters, {
+    totalBeats: spanEnd,
+    cadenceBeats: cadences.map((hit) => hit.atBeat),
+    budget: opts.budget
+  });
+  const hyperBeats = Math.max(
+    barBeats,
+    barPositionToBeat({ bar: grouping.groupBars, beat: 0 }, meters) - barPositionToBeat({ bar: 0, beat: 0 }, meters)
+  );
+  const expected = opts.expectedPhraseBeats ?? hyperBeats;
+  assertRange(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 = 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
+  ];
+  assertGenerationBudget(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 = path[n] ?? stops.length - 1;
+    const startBeat = stops[from]?.beat ?? spanStart;
+    const stop = stops[to];
+    const endBeat = stop?.beat ?? spanEnd;
+    const reading = 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 = stop?.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 = resolveMeters(opts, "section meters");
+  assertNoteEvents(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, opts.totalBeats ?? lastEnd);
+  assertRange(spanEnd, 0, Number.MAX_SAFE_INTEGER, "section totalBeats");
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  assertRange(threshold, 0, 1, "section threshold");
+  const unitBars = opts.unitBars ?? hypermeter(sounding, meters, { totalBeats: spanEnd, budget: opts.budget }).groupBars;
+  assertPositiveInt(unitBars, "section unitBars");
+  const firstBar = barIndexAt(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));
+  assertGenerationBudget(unitCount * unitCount, "form section comparisons", opts.budget);
+  assertGenerationBudget(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 : barPositionToBeat({ bar: barStart, beat: 0 }, meters);
+    const endBeat = index === unitCount - 1 ? spanEnd : barPositionToBeat({ 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(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 = labels[index] ?? labelAt(0);
+    let end = index;
+    let scoreSum = 0;
+    while (end < units.length && labels[end] === label) {
+      scoreSum += scores[end] ?? 1;
+      end += 1;
+    }
+    const startBeat = units[index]?.startBeat ?? 0;
+    const endBeat = units[end - 1]?.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) - barIndexAt(startBeat, meters) + 1,
+      firstOccurrence: 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 ${sections[first]?.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 (pitchClassOf(toPc) - pitchClassOf(fromPc) + 18) % 12 - 6;
+}
+function isStep2(distance) {
+  const size = Math.abs(distance);
+  return size === 1 || size === 2;
+}
+function touches(before, after) {
+  return Math.abs(after.startBeat - before.endBeat) <= 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 sorted[middle] ?? 0;
+  }
+  return ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}
+function isTonicChord(chord, key) {
+  return pitchClassOf(chord.rootPc - key.rootPc) === 0;
+}
+function isDominantChord(chord, key) {
+  return pitchClassOf(chord.rootPc - key.rootPc) === 7 && chord.intervals.some((iv) => pitchClassOf(iv) === 4);
+}
+function functionalReason(segment, before, after, keyAt) {
+  const key = keyAt(segment.startBeat);
+  if (after !== void 0 && isCadentialSixFour(segment.chord, after.chord, key)) {
+    return { kind: "cadentialSixFour" };
+  }
+  if (isTonicChord(segment.chord, key)) {
+    return { kind: "tonic" };
+  }
+  if (isDominantChord(segment.chord, key)) {
+    return { kind: "dominant" };
+  }
+  if (before !== void 0) {
+    const arrival = detectCadence(before.chord, segment.chord, key).type;
+    if (arrival !== null) {
+      return { kind: "cadenceArrival", cadence: arrival };
+    }
+  }
+  if (after !== void 0) {
+    const agent = detectCadence(segment.chord, after.chord, keyAt(after.startBeat)).type;
+    if (agent !== null && TONIC_ARRIVING.has(agent)) {
+      return { kind: "cadenceAgent", cadence: agent };
+    }
+  }
+  return null;
+}
+function figureReason(segment, before, after) {
+  if (before === void 0 || after === void 0) {
+    return null;
+  }
+  const incoming = signedStep(before.chord.rootPc, segment.chord.rootPc);
+  const outgoing = signedStep(segment.chord.rootPc, after.chord.rootPc);
+  if (!isStep2(incoming) || !isStep2(outgoing)) {
+    return null;
+  }
+  if (incoming > 0 === outgoing > 0) {
+    return { kind: "passing" };
+  }
+  return pitchClassOf(before.chord.rootPc) === pitchClassOf(after.chord.rootPc) ? { kind: "neighbor" } : null;
+}
+function describe2(reason) {
+  switch (reason.kind) {
+    case "tonic":
+      return "Structural: the tonic of the key, which the progression is heard against";
+    case "dominant":
+      return "Structural: the dominant of the key, the chord its tonic is approached from";
+    case "cadentialSixFour":
+      return "Structural: a tonic six-four on the bass of the dominant that follows, which prolongs that dominant rather than framing the tonic";
+    case "cadenceArrival":
+      return `Structural: the arrival of a ${reason.cadence} cadence`;
+    case "cadenceAgent":
+      return `Structural: the chord that drives a ${reason.cadence} cadence`;
+    case "salient":
+      return "Structural: it holds the harmony 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 = assertOneOf(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 ??= 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;
+}
+
+export {
+  keyTimelineFromNotes,
+  detectModulations,
+  keyLookup,
+  prevailingKeyOf,
+  chordTimelineFromChords,
+  chordTimelineFromNotes,
+  detectCadences,
+  toVoiceNotes,
+  analyzeVoice,
+  analyzeArrangement,
+  createArrangementSession,
+  tensionCurve,
+  tensionCurveFrom,
+  hypermeter,
+  extractMotifs,
+  motifFromNotes,
+  relateMotifs,
+  compareMelodies,
+  melodicSimilarity,
+  melodicContour,
+  phrasesFromTimeline,
+  structuralCadences,
+  sectionsFromNotes,
+  reduceProgression
+};
+//# sourceMappingURL=chunk-GOZG57ER.js.map