@libraz/libcantus 0.9.3 → 0.9.5

package/dist/generate/index.cjs

@@ -1,4123 +1,66 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/generate/index.ts
-var generate_exports = {};
-__export(generate_exports, {
-  applyGrooveTemplate: () => applyGrooveTemplate,
-  developMotif: () => developMotif,
-  extractGrooveTemplate: () => extractGrooveTemplate,
-  generateBassLine: () => generateBassLine,
-  generateCounterMelody: () => generateCounterMelody,
-  generateDrums: () => generateDrums,
-  generateMotif: () => generateMotif,
-  generateProgression: () => generateProgression,
-  generateRhythm: () => generateRhythm,
-  harmonizeMelody: () => harmonizeMelody,
-  humanize: () => humanize,
-  modalInterchangePalette: () => modalInterchangePalette,
-  negativeHarmonyMirror: () => negativeHarmonyMirror,
-  onsetWeightCurve: () => onsetWeightCurve,
-  progressions: () => progressions,
-  progressionsByStyle: () => progressionsByStyle,
-  rhythmDensity: () => rhythmDensity,
-  substituteChord: () => substituteChord,
-  transformMotif: () => transformMotif
-});
-module.exports = __toCommonJS(generate_exports);
 
-// src/core/validation/index.ts
-var DEFAULT_GENERATION_BUDGET = 1e6;
-function assertFiniteNumber(value, name) {
-  if (!Number.isFinite(value)) {
-    throw new RangeError(`${name} must be finite; received ${value}`);
-  }
-  return value;
-}
-function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
-  assertFiniteNumber(value, name);
-  if (!Number.isSafeInteger(value) || value < min || value > max) {
-    throw new RangeError(`${name} must be an integer in [${min}, ${max}]; received ${value}`);
-  }
-  return value;
-}
-function assertPositiveInt(value, name, max = DEFAULT_GENERATION_BUDGET) {
-  return assertInteger(value, name, 1, max);
-}
-function assertRange(value, min, max, name) {
-  assertFiniteNumber(value, name);
-  if (value < min || value > max) {
-    throw new RangeError(`${name} must be in [${min}, ${max}]; received ${value}`);
-  }
-  return value;
-}
-function assertGenerationBudget(estimated, name, limit = DEFAULT_GENERATION_BUDGET) {
-  assertFiniteNumber(estimated, name);
-  assertPositiveInt(limit, `${name} limit`, Number.MAX_SAFE_INTEGER);
-  if (estimated < 0 || estimated > limit) {
-    throw new RangeError(`${name} exceeds the generation budget ${limit}; received ${estimated}`);
-  }
-  return estimated;
-}
-function assertTimeSignature(ts, name = "time signature") {
-  assertPositiveInt(ts.numerator, `${name}.numerator`);
-  assertPositiveInt(ts.denominator, `${name}.denominator`);
-  if (ts.grouping !== void 0) {
-    if (ts.grouping.length === 0) {
-      throw new RangeError(`${name}.grouping must not be empty`);
-    }
-    let sum = 0;
-    for (let index = 0; index < ts.grouping.length; index += 1) {
-      sum += assertPositiveInt(ts.grouping[index] ?? Number.NaN, `${name}.grouping[${index}]`);
-    }
-    const compound = ts.numerator % 3 === 0 && ts.numerator > 3;
-    const pulses = compound ? ts.numerator / 3 : ts.numerator;
-    if (sum !== pulses) {
-      throw new RangeError(`${name}.grouping must sum to ${pulses}; received ${sum}`);
-    }
-  }
-  return ts;
-}
-function assertNoteEvent(event, name = "note event", options = {}) {
-  assertFiniteNumber(event.pitch, `${name}.pitch`);
-  assertRange(event.startBeat, 0, Number.MAX_SAFE_INTEGER, `${name}.startBeat`);
-  assertRange(
-    event.durationBeat,
-    options.allowNonPositiveDuration ? -Number.MAX_SAFE_INTEGER : Number.MIN_VALUE,
-    Number.MAX_SAFE_INTEGER,
-    `${name}.durationBeat`
-  );
-  if (!options.allowNonPositiveDuration && event.durationBeat <= 0) {
-    throw new RangeError(`${name}.durationBeat must be positive; received ${event.durationBeat}`);
-  }
-  if (event.velocity !== void 0) {
-    assertRange(event.velocity, 0, 127, `${name}.velocity`);
-  }
-  return event;
-}
-function assertNoteEvents(events, name = "note events", options = {}) {
-  assertGenerationBudget(events.length, `${name} count`, options.budget);
-  for (let index = 0; index < events.length; index += 1) {
-    const event = events[index];
-    if (event !== void 0) {
-      assertNoteEvent(event, `${name}[${index}]`, options);
-    }
-  }
-  return events;
-}
 
-// src/core/meter/index.ts
-var EPS = 1e-9;
-function isMultiple(value, unit) {
-  if (unit === 0) {
-    return false;
-  }
-  const ratio = value / unit;
-  return Math.abs(ratio - Math.round(ratio)) < EPS;
-}
-function formatTimeSignature(ts) {
-  assertTimeSignature(ts);
-  return `${ts.numerator}/${ts.denominator}`;
-}
-function isCompound(ts) {
-  assertTimeSignature(ts);
-  return ts.numerator % 3 === 0 && ts.numerator > 3;
-}
-function unitBeats(ts) {
-  return 4 / ts.denominator;
-}
-function beatsPerBar(ts) {
-  assertTimeSignature(ts);
-  return ts.numerator * unitBeats(ts);
-}
-function pulseBeats(ts) {
-  return isCompound(ts) ? 3 * unitBeats(ts) : unitBeats(ts);
-}
-function pulsesPerBar(ts) {
-  return beatsPerBar(ts) / pulseBeats(ts);
-}
-function isValidGrouping(grouping, pulses) {
-  if (grouping.length === 0) {
-    return false;
-  }
-  let sum = 0;
-  for (const g of grouping) {
-    if (!Number.isInteger(g) || g <= 0) {
-      return false;
-    }
-    sum += g;
-  }
-  return sum === pulses;
-}
-function isGroupHead(grouping, pulseIndex) {
-  let acc = 0;
-  for (const g of grouping) {
-    if (acc === pulseIndex) {
-      return true;
-    }
-    acc += g;
-  }
-  return false;
-}
-function beatToBarPosition(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  const barLen = beatsPerBar(ts);
-  const bar = Math.floor(beatInQuarters / barLen);
-  return { bar, beat: beatInQuarters - bar * barLen };
-}
-function metricWeight(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  assertTimeSignature(ts);
-  const { beat } = beatToBarPosition(beatInQuarters, ts);
-  const pulse = pulseBeats(ts);
-  if (!isMultiple(beat, pulse)) {
-    return 0;
-  }
-  const pulses = pulsesPerBar(ts);
-  const pulseIndex = Math.round(beat / pulse) % pulses;
-  if (pulseIndex === 0) {
-    return 3;
-  }
-  const grouping = ts.grouping;
-  if (grouping !== void 0) {
-    if (!isValidGrouping(grouping, pulses)) {
-      throw new Error(
-        `Invalid grouping [${grouping.join(", ")}] for ${formatTimeSignature(ts)}: entries must be positive integers summing to ${pulses}`
-      );
-    }
-    return isGroupHead(grouping, pulseIndex) ? 2 : 1;
-  }
-  if (pulses % 2 === 0 && pulseIndex === pulses / 2) {
-    return 2;
-  }
-  return 1;
-}
-function isStrongBeat(beatInQuarters, ts) {
-  return metricWeight(beatInQuarters, ts) >= 2;
-}
 
-// src/core/random/index.ts
-function createRng(seed) {
-  assertFiniteNumber(seed, "seed");
-  let state = seed >>> 0;
-  const next = () => {
-    state = state + 1831565813 >>> 0;
-    let t = state;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-  return {
-    next,
-    prob: (p) => next() < assertRange(p, 0, 1, "probability"),
-    range: (lo, hi) => {
-      assertInteger(lo, "range lower bound");
-      assertInteger(hi, "range upper bound");
-      if (lo > hi) {
-        throw new RangeError(
-          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
-        );
-      }
-      assertInteger(hi - lo, "range span", 0);
-      return lo + Math.floor(next() * (hi - lo + 1));
-    },
-    float: (lo, hi) => {
-      assertFiniteNumber(lo, "float lower bound");
-      assertFiniteNumber(hi, "float upper bound");
-      if (lo > hi) {
-        throw new RangeError(
-          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
-        );
-      }
-      assertFiniteNumber(hi - lo, "float span");
-      return lo + next() * (hi - lo);
-    }
-  };
-}
 
-// src/theory/scale/degrees.ts
-function pitchClass(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function scaleOffset(pitch, key) {
-  return (pitchClass(pitch) - pitchClass(key.rootPc) + 12) % 12;
-}
-function isScaleTone(pitch, key) {
-  return (key.modeMask12 >> scaleOffset(pitch, key) & 1) === 1;
-}
-function nearestScaleTone(pitch, key) {
-  const base = Math.round(pitch);
-  for (let distance = 0; distance < 12; distance += 1) {
-    const lower = base - distance;
-    if (isScaleTone(lower, key)) {
-      return lower;
-    }
-    const higher = base + distance;
-    if (isScaleTone(higher, key)) {
-      return higher;
-    }
-  }
-  return base;
-}
-function scaleTonesInDegreeOrder(key) {
-  const root = pitchClass(key.rootPc);
-  const pcs = [];
-  for (let n = 0; n < 12; n += 1) {
-    if ((key.modeMask12 >> n & 1) === 1) {
-      pcs.push((root + n) % 12);
-    }
-  }
-  return pcs;
-}
 
-// src/theory/scale/masks.ts
-function maskFromOffsets(offsets) {
-  let mask = 1;
-  for (const offset of offsets) {
-    mask |= 1 << (offset % 12 + 12) % 12;
-  }
-  return mask;
-}
-var MAJOR_MASK = 2741;
-var NATURAL_MINOR_MASK = 1453;
-var HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);
-var MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);
-var DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);
-var PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);
-var LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);
-var MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);
-var LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);
-var MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);
-var MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);
-var BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);
-var WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);
-var OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);
-var OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);
 
-// src/theory/scale/key.ts
-function majorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: MAJOR_MASK };
-}
-function minorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: NATURAL_MINOR_MASK };
-}
 
-// src/generate/bass/index.ts
-var DEFAULT_TS = { numerator: 4, denominator: 4 };
-var DEFAULT_STYLE = "root";
-var DEFAULT_OCTAVE = 2;
-var STRONG_VELOCITY = 100;
-var WEAK_VELOCITY = 80;
-var PICKUP_PROB = 0.35;
-var EPS2 = 1e-9;
-function pitchClass2(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function placePc(pc, anchor, low) {
-  const high = low + 12;
-  let midi = pc + 12 * Math.round((anchor - pc) / 12);
-  while (midi < low) {
-    midi += 12;
-  }
-  while (midi > high) {
-    midi -= 12;
-  }
-  return midi;
-}
-function chordTonePcs(chord) {
-  const seen = /* @__PURE__ */ new Set();
-  const pcs = [];
-  for (const interval of chord.intervals) {
-    const pc = pitchClass2(chord.rootPc + interval);
-    if (!seen.has(pc)) {
-      seen.add(pc);
-      pcs.push(pc);
-    }
-  }
-  if (pcs.length === 0) {
-    pcs.push(pitchClass2(chord.rootPc));
-  }
-  return pcs;
-}
-function fifthPcOf(chord) {
-  const fifths = new Set(chord.intervals.map((i) => pitchClass2(i)));
-  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
-  return chosen === void 0 ? pitchClass2(chord.rootPc) : pitchClass2(chord.rootPc + chosen);
-}
-function bassPcOf(chord) {
-  return pitchClass2(chord.bassPc ?? chord.rootPc);
-}
-function beatPositions(start, end) {
-  const positions = [];
-  for (let p = start; p < end - EPS2; p += 1) {
-    positions.push(p);
-  }
-  if (positions.length === 0) {
-    positions.push(start);
-  }
-  return positions;
-}
-function emit(ctx, pos, pc, midiOverride) {
-  const midi = midiOverride ?? placePc(pc, ctx.prevMidi, ctx.low);
-  const velocity = isStrongBeat(pos, ctx.ts) ? STRONG_VELOCITY : WEAK_VELOCITY;
-  ctx.notes.push({ startBeat: pos, pitch: midi, velocity });
-  return midi;
-}
-function buildRoot(ctx, seg) {
-  ctx.prevMidi = emit(ctx, seg.startBeat, bassPcOf(seg.chord));
-}
-function buildRootFifth(ctx, seg) {
-  ctx.prevMidi = emit(ctx, seg.startBeat, bassPcOf(seg.chord));
-  const mid = (seg.startBeat + seg.endBeat) / 2;
-  if (mid > seg.startBeat + EPS2 && mid < seg.endBeat - EPS2) {
-    ctx.prevMidi = emit(ctx, mid, fifthPcOf(seg.chord));
-  }
-}
-function buildPop(ctx, seg) {
-  const positions = beatPositions(seg.startBeat, seg.endBeat);
-  const rootPc = bassPcOf(seg.chord);
-  let emitted = false;
-  for (const pos of positions) {
-    if (isStrongBeat(pos, ctx.ts)) {
-      ctx.prevMidi = emit(ctx, pos, rootPc);
-      emitted = true;
-    } else if (ctx.rng.prob(PICKUP_PROB)) {
-      if (ctx.rng.prob(0.5)) {
-        const base = placePc(rootPc, ctx.prevMidi, ctx.low);
-        emit(ctx, pos, rootPc, Math.max(ctx.low, base - 12));
-      } else {
-        ctx.prevMidi = emit(ctx, pos, fifthPcOf(seg.chord));
-      }
-    }
-  }
-  if (!emitted) {
-    ctx.prevMidi = emit(ctx, seg.startBeat, rootPc);
-  }
-}
-function buildArpeggio(ctx, seg) {
-  const tones = chordTonePcs(seg.chord);
-  const positions = beatPositions(seg.startBeat, seg.endBeat);
-  positions.forEach((pos, i) => {
-    const pc = tones[i % tones.length] ?? bassPcOf(seg.chord);
-    ctx.prevMidi = emit(ctx, pos, pc);
-  });
-}
-function approachNote(ctx, target, from) {
-  const dir = from <= target ? -1 : 1;
-  if (ctx.rng.prob(0.5)) {
-    return target + dir;
-  }
-  const cand = nearestScaleTone(target + dir * 2, ctx.key);
-  const step = Math.abs(cand - target);
-  return step >= 1 && step <= 2 ? cand : target + dir;
-}
-function buildWalking(ctx, seg, next) {
-  const tones = chordTonePcs(seg.chord);
-  const positions = beatPositions(seg.startBeat, seg.endBeat);
-  const count = positions.length;
-  positions.forEach((pos, i) => {
-    if (i === 0) {
-      ctx.prevMidi = emit(ctx, pos, bassPcOf(seg.chord));
-      return;
-    }
-    if (next && count > 1 && i === count - 1) {
-      const nextBass = placePc(bassPcOf(next.chord), ctx.prevMidi, ctx.low);
-      const midi = approachNote(ctx, nextBass, ctx.prevMidi);
-      ctx.prevMidi = emit(ctx, pos, pitchClass2(midi), midi);
-      return;
-    }
-    const pc = tones[i % tones.length] ?? bassPcOf(seg.chord);
-    ctx.prevMidi = emit(ctx, pos, pc);
-  });
-}
-function generateBassLine(opts) {
-  assertGenerationBudget(opts.segments.length, "bass segments");
-  for (let index = 0; index < opts.segments.length; index += 1) {
-    const segment = opts.segments[index];
-    if (!segment) continue;
-    assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
-    assertRange(segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
-    if (segment.endBeat <= segment.startBeat) {
-      throw new RangeError(`segments[${index}] must have a positive duration`);
-    }
-  }
-  const segments = [...opts.segments].sort((a, b) => a.startBeat - b.startBeat);
-  if (segments.length === 0) {
-    return [];
-  }
-  const ts = opts.ts ?? DEFAULT_TS;
-  assertTimeSignature(ts);
-  const style = opts.style ?? DEFAULT_STYLE;
-  const octave = opts.octave ?? DEFAULT_OCTAVE;
-  assertInteger(octave, "bass octave", -1, 9);
-  const estimatedNotes = segments.reduce(
-    (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
-    0
-  );
-  assertGenerationBudget(estimatedNotes, "bass notes");
-  const low = octave * 12 + 12;
-  const ctx = {
-    ts,
-    low,
-    key: opts.key,
-    rng: createRng(opts.seed ?? 0),
-    notes: [],
-    prevMidi: low
-  };
-  for (let s = 0; s < segments.length; s += 1) {
-    const seg = segments[s];
-    if (!seg) {
-      continue;
-    }
-    switch (style) {
-      case "rootFifth":
-        buildRootFifth(ctx, seg);
-        break;
-      case "pop":
-        buildPop(ctx, seg);
-        break;
-      case "walking":
-        buildWalking(ctx, seg, segments[s + 1]);
-        break;
-      case "arpeggio":
-        buildArpeggio(ctx, seg);
-        break;
-      default:
-        buildRoot(ctx, seg);
-        break;
-    }
-  }
-  ctx.notes.sort((a, b) => a.startBeat - b.startBeat);
-  const lastEnd = segments.reduce((m, seg) => Math.max(m, seg.endBeat), Number.NEGATIVE_INFINITY);
-  const out = [];
-  for (let i = 0; i < ctx.notes.length; i += 1) {
-    const note = ctx.notes[i];
-    if (!note) {
-      continue;
-    }
-    const nextStart = ctx.notes[i + 1]?.startBeat ?? lastEnd;
-    const durationBeat = nextStart - note.startBeat;
-    if (durationBeat <= EPS2) {
-      continue;
-    }
-    out.push({
-      pitch: note.pitch,
-      startBeat: note.startBeat,
-      durationBeat,
-      velocity: note.velocity
-    });
-  }
-  return out;
-}
 
-// src/core/event-index/index.ts
-var EPS3 = 1e-9;
-function upperBound(values, beat) {
-  let low = 0;
-  let high = values.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((values[middle]?.note.startBeat ?? Number.POSITIVE_INFINITY) <= beat) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low;
-}
-function createNoteEventIndex(events, options = {}) {
-  assertNoteEvents(events, "note events", options);
-  const notes = events.map((note, originalIndex) => ({
-    note,
-    originalIndex,
-    endBeat: note.startBeat + note.durationBeat
-  })).sort((a, b) => a.note.startBeat - b.note.startBeat || a.originalIndex - b.originalIndex);
-  const prefixMaxEnd = [];
-  let maxEnd = Number.NEGATIVE_INFINITY;
-  for (const indexed of notes) {
-    maxEnd = Math.max(maxEnd, indexed.endBeat);
-    prefixMaxEnd.push(maxEnd);
-  }
-  return {
-    notes,
-    at(beat) {
-      let index = upperBound(notes, beat + EPS3) - 1;
-      while (index >= 0) {
-        if ((prefixMaxEnd[index] ?? Number.NEGATIVE_INFINITY) <= beat + EPS3) {
-          return void 0;
-        }
-        const indexed = notes[index];
-        if (indexed && indexed.note.durationBeat > 0 && indexed.note.startBeat - EPS3 <= beat && beat < indexed.endBeat - EPS3) {
-          return indexed;
-        }
-        index -= 1;
-      }
-      return void 0;
-    },
-    attacksAt(beat) {
-      const firstAfter = upperBound(notes, beat + EPS3);
-      const candidate = notes[firstAfter - 1];
-      return candidate !== void 0 && Math.abs(candidate.note.startBeat - beat) < EPS3;
-    },
-    onsetsBetween(startBeat, endBeat) {
-      const result = [];
-      let index = upperBound(notes, startBeat + EPS3);
-      while (index < notes.length) {
-        const onset = notes[index]?.note.startBeat;
-        if (onset === void 0 || onset >= endBeat - EPS3) {
-          break;
-        }
-        if (result[result.length - 1] !== onset) {
-          result.push(onset);
-        }
-        index += 1;
-      }
-      return result;
-    }
-  };
-}
 
-// src/theory/chord/index.ts
-var QUALITY_INTERVALS = {
-  maj: [0, 4, 7],
-  min: [0, 3, 7],
-  dim: [0, 3, 6],
-  aug: [0, 4, 8],
-  majb5: [0, 4, 6],
-  maj7: [0, 4, 7, 11],
-  min7: [0, 3, 7, 10],
-  dom7: [0, 4, 7, 10],
-  dim7: [0, 3, 6, 9],
-  m7b5: [0, 3, 6, 10],
-  minMaj7: [0, 3, 7, 11],
-  aug7: [0, 4, 8, 10],
-  augMaj7: [0, 4, 8, 11],
-  "6": [0, 4, 7, 9],
-  min6: [0, 3, 7, 9],
-  "6/9": [0, 4, 7, 9, 14],
-  sus2: [0, 2, 7],
-  sus4: [0, 5, 7],
-  add9: [0, 4, 7, 14],
-  add11: [0, 4, 7, 17],
-  maj9: [0, 4, 7, 11, 14],
-  min9: [0, 3, 7, 10, 14],
-  dom9: [0, 4, 7, 10, 14],
-  "7b9": [0, 4, 7, 10, 13],
-  "7#9": [0, 4, 7, 10, 15],
-  "7#11": [0, 4, 7, 10, 18],
-  "7b13": [0, 4, 7, 10, 20],
-  "11": [0, 7, 10, 14, 17],
-  "13": [0, 4, 7, 10, 14, 21],
-  "5": [0, 7]
-};
-function pitchClass3(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function chordQualities() {
-  return Object.keys(QUALITY_INTERVALS);
-}
-function makeChord(rootPc, quality, bassPc) {
-  const chord = {
-    rootPc: pitchClass3(rootPc),
-    quality,
-    intervals: [...QUALITY_INTERVALS[quality]]
-  };
-  if (bassPc !== void 0) {
-    chord.bassPc = pitchClass3(bassPc);
-  }
-  return chord;
-}
-function chordPitchClasses(chord) {
-  const set = /* @__PURE__ */ new Set();
-  for (const interval of chord.intervals) {
-    set.add(pitchClass3(chord.rootPc + interval));
-  }
-  return [...set].sort((a, b) => a - b);
-}
-function chordToneOffsets(chord) {
-  return new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
-}
-function chordToneRole(pitch, chord) {
-  const interval = (pitchClass3(pitch) - pitchClass3(chord.rootPc) + 12) % 12;
-  const tones = chordToneOffsets(chord);
-  if (interval === 0) {
-    return "root";
-  }
-  if (interval === 3 || interval === 4) {
-    return tones.has(interval) ? "third" : null;
-  }
-  if (interval === 7) {
-    return tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 6) {
-    return tones.has(6) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 8) {
-    return tones.has(8) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 9) {
-    const hasHigherSeventh = tones.has(10) || tones.has(11);
-    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;
-    if (isDiminishedSeventh) {
-      return "seventh";
-    }
-    if (tones.has(9) && !hasHigherSeventh) {
-      return "sixth";
-    }
-    return null;
-  }
-  if (interval === 10 || interval === 11) {
-    return tones.has(interval) ? "seventh" : null;
-  }
-  return null;
-}
-function classifyTriad(thirdIc, fifthIc) {
-  if (thirdIc === 4 && fifthIc === 8) {
-    return "aug";
-  }
-  if (thirdIc === 4 && fifthIc === 6) {
-    return "majb5";
-  }
-  if (thirdIc === 3 && fifthIc === 6) {
-    return "dim";
-  }
-  if (thirdIc === 3) {
-    return "min";
-  }
-  return "maj";
-}
-function classifySeventh(thirdIc, fifthIc, seventhIc) {
-  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 9) {
-    return "dim7";
-  }
-  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 10) {
-    return "m7b5";
-  }
-  if (thirdIc === 3 && seventhIc === 11) {
-    return "minMaj7";
-  }
-  if (thirdIc === 3) {
-    return "min7";
-  }
-  if (fifthIc === 8 && seventhIc === 10) {
-    return "aug7";
-  }
-  if (fifthIc === 8 && seventhIc === 11) {
-    return "augMaj7";
-  }
-  if (seventhIc === 11) {
-    return "maj7";
-  }
-  return "dom7";
-}
-function stackThirds(degree, key, size) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const length = tones.length;
-  if (length !== 7) {
-    throw new Error(
-      `diatonic chord stacking requires a heptatonic scale (received ${length} tones)`
-    );
-  }
-  const idx = (step) => ((degree + step) % length + length) % length;
-  const rootPc = tones[idx(0)] ?? pitchClass3(key.rootPc);
-  const offsets = [0, 2, 4, 6].slice(0, size).map((step) => {
-    const pc = tones[idx(step)] ?? rootPc;
-    return ((pc - rootPc) % 12 + 12) % 12;
-  });
-  const thirdIc = offsets[1] ?? 4;
-  const fifthIc = offsets[2] ?? 7;
-  const quality = size === 3 ? classifyTriad(thirdIc, fifthIc) : classifySeventh(thirdIc, fifthIc, offsets[3] ?? 11);
-  return { rootPc, quality, intervals: offsets };
-}
-function diatonicTriad(degree, key) {
-  return stackThirds(degree, key, 3);
-}
 
-// src/core/interval/index.ts
-function simpleInterval(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isConsonantInterval(semitones, twoVoice = true) {
-  const pc = simpleInterval(semitones);
-  if (pc === 5) {
-    return !twoVoice;
-  }
-  return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
-}
 
-// src/theory/counterpoint/index.ts
-function createsVerticalDissonance(a, b, twoVoice) {
-  return !isConsonantInterval(a - b, twoVoice);
-}
-function isForbiddenMelodicLeap(prev, cur) {
-  const semis = Math.abs(cur - prev);
-  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
-}
-function simpleClass(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isPerfectClass(cls) {
-  return cls === 0 || cls === 7;
-}
-function similarMotion(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
-}
-function bothVoicesMove(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0;
-}
-function createsParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  return isPerfectClass(nowClass) && nowClass === prevClass;
-}
-function createsHiddenParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  const aMove = aCur - aPrev;
-  const bMove = bCur - bPrev;
-  if (!similarMotion(aMove, bMove)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
-    return false;
-  }
-  const upperMove = aCur >= bCur ? aMove : bMove;
-  if (Math.abs(upperMove) <= 2) {
-    return false;
-  }
-  return true;
-}
 
-// src/theory/safety/index.ts
-var SUGGESTION_WINDOW = 12;
-var MAX_SUGGESTIONS = 3;
-var REASON_SEVERITY = [
-  [2 /* Tension */, 1 /* Warning */, 1 /* Warning */],
-  [4 /* AvoidNote */, 1 /* Warning */, 2 /* Dissonant */],
-  [8 /* ScaleTone */, 1 /* Warning */, 1 /* Warning */],
-  [16 /* NonScale */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32 /* OutOfRange */, 1 /* Warning */, 1 /* Warning */],
-  [64 /* Tritone */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [128 /* LargeLeap */, 1 /* Warning */, 2 /* Dissonant */],
-  [1024 /* VerticalDissonance */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [2048 /* ParallelPerfect */, 1 /* Warning */, 2 /* Dissonant */],
-  [4096 /* HiddenParallel */, 1 /* Warning */, 2 /* Dissonant */],
-  [8192 /* VoiceCrossing */, 1 /* Warning */, 2 /* Dissonant */],
-  [16384 /* Suspension */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32768 /* NeedsResolution */, 1 /* Warning */, 2 /* Dissonant */]
-];
-function minimumSafetyForReasons(reasons, profile) {
-  let minimum = 0 /* Safe */;
-  const severityIndex = profile === "strict" ? 2 : 1;
-  for (const entry of REASON_SEVERITY) {
-    if (reasons & entry[0]) {
-      minimum = Math.max(minimum, entry[severityIndex]);
-    }
-  }
-  return minimum;
-}
-function pitchClass4(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function intervalAboveRoot(pitch, chord) {
-  return ((pitchClass4(pitch) - pitchClass4(chord.rootPc)) % 12 + 12) % 12;
-}
-function isChordMember(pitch, chord) {
-  return chordPitchClasses(chord).includes(pitchClass4(pitch));
-}
-function avoidsFourth(chord) {
-  return chord.intervals.includes(4) && !chord.intervals.includes(5);
-}
-function avoidsMajorSeventh(chord) {
-  return chord.intervals.includes(4) && chord.intervals.includes(10);
-}
-function stepResolution(pitch, chord) {
-  for (let delta = 1; delta <= 2; delta += 1) {
-    if (isChordMember(pitch - delta, chord)) {
-      return pitch - delta;
-    }
-  }
-  return void 0;
-}
-function evaluateSafety(q) {
-  assertSafetyContext(q);
-  assertFiniteNumber(q.candidatePitch, "candidatePitch");
-  return evaluateInternal(q, true);
-}
-function assertSafetyContext(q) {
-  if (q.prevPitch !== void 0) assertFiniteNumber(q.prevPitch, "prevPitch");
-  if (q.vocalLow !== void 0) assertFiniteNumber(q.vocalLow, "vocalLow");
-  if (q.vocalHigh !== void 0) assertFiniteNumber(q.vocalHigh, "vocalHigh");
-  if (q.vocalLow !== void 0 && q.vocalHigh !== void 0 && q.vocalLow > q.vocalHigh) {
-    throw new RangeError("vocalLow must not exceed vocalHigh");
-  }
-  assertGenerationBudget(q.otherVoices.length, "other voices");
-  for (let index = 0; index < q.otherVoices.length; index += 1) {
-    const voice = q.otherVoices[index];
-    if (!voice) continue;
-    assertFiniteNumber(voice.pitch, `otherVoices[${index}].pitch`);
-    if (voice.prevPitch !== void 0) {
-      assertFiniteNumber(voice.prevPitch, `otherVoices[${index}].prevPitch`);
-    }
-  }
-}
-function evaluateInternal(q, collectSuggestions) {
-  let reasons = 0;
-  let level = 0 /* Safe */;
-  let resolveTo;
-  const raise = (l) => {
-    if (l > level) {
-      level = l;
-    }
-  };
-  const avoidSeverity = q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */;
-  const parallelSeverity = avoidSeverity;
-  const pitch = q.candidatePitch;
-  if (q.vocalLow !== void 0 && pitch < q.vocalLow || q.vocalHigh !== void 0 && pitch > q.vocalHigh) {
-    reasons |= 32 /* OutOfRange */;
-    raise(1 /* Warning */);
-  }
-  const inScale = isScaleTone(pitch, q.key);
-  const chord = q.chord;
-  if (chord && isChordMember(pitch, chord)) {
-    reasons |= 1 /* ChordTone */;
-  } else if (chord) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const isTension = ic === 2 || ic === 5 || ic === 9;
-    const avoid = ic === 5 && avoidsFourth(chord) || ic === 11 && avoidsMajorSeventh(chord);
-    if (avoid) {
-      reasons |= 4 /* AvoidNote */;
-      if (isTension) {
-        reasons |= 2 /* Tension */;
-      }
-      reasons |= 32768 /* NeedsResolution */;
-      resolveTo = stepResolution(pitch, chord);
-      raise(avoidSeverity);
-    } else if (isTension && inScale) {
-      reasons |= 2 /* Tension */;
-      raise(1 /* Warning */);
-    } else if (inScale) {
-      reasons |= 8 /* ScaleTone */;
-      raise(1 /* Warning */);
-    } else {
-      reasons |= 16 /* NonScale */;
-      raise(2 /* Dissonant */);
-    }
-  } else if (inScale) {
-    reasons |= 8 /* ScaleTone */;
-    raise(1 /* Warning */);
-  } else {
-    reasons |= 16 /* NonScale */;
-    raise(2 /* Dissonant */);
-  }
-  if (chord && !(chord.intervals.includes(4) && chord.intervals.includes(10))) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const toneOffsets = chord.intervals.map((i) => (i % 12 + 12) % 12);
-    if (toneOffsets.some((t) => Math.abs(ic - t) === 6)) {
-      reasons |= 64 /* Tritone */;
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const pc = Math.abs(pitch - q.prevPitch) % 12;
-    if (pc === 6) {
-      reasons |= 64 /* Tritone */;
-      raise(2 /* Dissonant */);
-    }
-    if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
-      reasons |= 128 /* LargeLeap */;
-      raise(parallelSeverity);
-    }
-    if (pc === 1) {
-      reasons |= 256 /* MinorSecond */;
-    }
-    if (pc === 11) {
-      reasons |= 512 /* MajorSeventh */;
-    }
-  }
-  if (q.strongBeat) {
-    const twoVoice = q.otherVoices.length === 1;
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
-        continue;
-      }
-      reasons |= 1024 /* VerticalDissonance */;
-      raise(2 /* Dissonant */);
-      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
-        reasons |= 16384 /* Suspension */;
-      }
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (ov.prevPitch === void 0) {
-        continue;
-      }
-      if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 2048 /* ParallelPerfect */;
-        raise(parallelSeverity);
-      }
-      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 4096 /* HiddenParallel */;
-        raise(parallelSeverity);
-      }
-      const crossedNow = pitch - ov.pitch;
-      const crossedPrev = prev - ov.prevPitch;
-      if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
-        reasons |= 8192 /* VoiceCrossing */;
-        raise(parallelSeverity);
-      }
-    }
-  }
-  raise(minimumSafetyForReasons(reasons, q.profile));
-  const result = { safety: level, reasons, rationale: describe(reasons, q) };
-  if (resolveTo !== void 0) {
-    result.resolveTo = resolveTo;
-  }
-  if (collectSuggestions && level !== 0 /* Safe */) {
-    const suggestions = findSafeNearby(q, pitch);
-    if (suggestions.length > 0) {
-      result.suggestions = suggestions;
-    }
-  }
-  return result;
-}
-function findSafeNearby(q, candidate) {
-  const out = [];
-  for (let d = 1; d <= SUGGESTION_WINDOW; d += 1) {
-    for (const p of [candidate - d, candidate + d]) {
-      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
-        out.push(p);
-        if (out.length >= MAX_SUGGESTIONS) {
-          return out;
-        }
-      }
-    }
-  }
-  return out;
-}
-function describe(reasons, q) {
-  if (reasons & 32 /* OutOfRange */) {
-    return "Outside the target vocal range";
-  }
-  if (reasons & 16384 /* Suspension */) {
-    return "Prepared suspension \u2014 a held consonance now dissonant, awaiting resolution";
-  }
-  if (reasons & 1024 /* VerticalDissonance */) {
-    return "Dissonant against a sounding voice on a strong beat";
-  }
-  if (reasons & 4 /* AvoidNote */) {
-    return "Avoid note \u2014 clashes with a chord tone a semitone away";
-  }
-  if (reasons & 2048 /* ParallelPerfect */) {
-    return "Parallel perfect interval with another voice";
-  }
-  if (reasons & 4096 /* HiddenParallel */) {
-    return "Hidden perfect interval by similar motion";
-  }
-  if (reasons & 8192 /* VoiceCrossing */) {
-    return "Crosses another voice";
-  }
-  if (reasons & 1 /* ChordTone */) {
-    return "Chord tone";
-  }
-  if (reasons & 2 /* Tension */) {
-    return "Chord tension";
-  }
-  if (reasons & 16 /* NonScale */) {
-    return "Outside the key";
-  }
-  if (reasons & 8 /* ScaleTone */) {
-    return "Scale tone, not in the chord";
-  }
-  return q.chord ? "Placeable" : "No chord context";
-}
-function enumerateSafePitches(q, pitchLow, pitchHigh) {
-  assertSafetyContext(q);
-  const chordTones = [];
-  const others = [];
-  assertInteger(pitchLow, "pitchLow");
-  assertInteger(pitchHigh, "pitchHigh");
-  if (pitchLow > pitchHigh) {
-    throw new RangeError(`pitchLow must not exceed pitchHigh; received ${pitchLow} > ${pitchHigh}`);
-  }
-  assertGenerationBudget(pitchHigh - pitchLow + 1, "safe pitch candidates");
-  for (let pitch = pitchHigh; pitch >= pitchLow; pitch -= 1) {
-    const result = evaluateInternal({ ...q, candidatePitch: pitch }, false);
-    if (result.safety === 2 /* Dissonant */) {
-      continue;
-    }
-    if (result.reasons & 1 /* ChordTone */) {
-      chordTones.push(pitch);
-    } else {
-      others.push(pitch);
-    }
-  }
-  return [...chordTones, ...others];
-}
 
-// src/generate/countermelody/index.ts
-var DEFAULT_TS2 = { numerator: 4, denominator: 4 };
-var EPS4 = 1e-9;
-var GRID_STEP = 0.5;
-var MIN_ONSET_GAP = 1;
-var REGISTER_OFFSET = 12;
-var DEFAULT_HALF_RANGE = 10;
-var HOLD_ON_BEAT_PROB = 0.55;
-var HOLD_OFF_BEAT_PROB = 0.2;
-var REINFORCE_PROB = 0.35;
-var DEFAULT_MELODY_VELOCITY = 96;
-var VELOCITY_DROP = 16;
-function isWholeBeat(beat) {
-  return Math.abs(beat - Math.round(beat)) < EPS4;
-}
-function melodyNoteAt(melody, beat) {
-  return melody.at(beat)?.note;
-}
-function melodyAttacksAt(melody, beat) {
-  return melody.attacksAt(beat);
-}
-function melodySnapshotAt(melody, beat) {
-  const current = melodyNoteAt(melody, beat);
-  if (current === void 0) {
-    return void 0;
-  }
-  const attacked = Math.abs(current.startBeat - beat) < EPS4;
-  const previous = attacked ? melodyNoteAt(melody, beat - EPS4 * 2) : current;
-  const snapshot = { pitch: current.pitch };
-  if (previous !== void 0) {
-    snapshot.prevPitch = previous.pitch;
-  }
-  return snapshot;
-}
-function followOnsets(melody) {
-  return [...new Set(melody.notes.map(({ note }) => note.startBeat))];
-}
-function complementOnsets(melody, ts, spanStart, spanEnd, rng) {
-  const onsets = [];
-  const gridStart = Math.floor(spanStart / GRID_STEP) * GRID_STEP;
-  let last = Number.NEGATIVE_INFINITY;
-  for (let beat = gridStart; beat < spanEnd - EPS4; beat += GRID_STEP) {
-    const attacked = melodyAttacksAt(melody, beat);
-    const sounding = melodyNoteAt(melody, beat) !== void 0;
-    let place = false;
-    if (!attacked && !sounding) {
-      place = isWholeBeat(beat);
-    } else if (!attacked) {
-      place = rng.prob(isWholeBeat(beat) ? HOLD_ON_BEAT_PROB : HOLD_OFF_BEAT_PROB);
-    } else if (isStrongBeat(beat, ts)) {
-      place = rng.prob(REINFORCE_PROB);
-    }
-    if (place && beat - last >= MIN_ONSET_GAP - EPS4) {
-      onsets.push(beat);
-      last = beat;
-    }
-  }
-  return onsets;
-}
-function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center) {
-  let score = 0;
-  if (melPitch !== void 0) {
-    const ic = Math.abs(pitch - melPitch) % 12;
-    if (ic === 3 || ic === 4 || ic === 8 || ic === 9) {
-      score += 2;
-    } else if (ic === 0 || ic === 7) {
-      score += 0.5;
-    } else if (ic === 1 || ic === 2 || ic === 6 || ic === 10 || ic === 11) {
-      score -= 2;
-    }
-  }
-  if (chord && chordToneRole(pitch, chord) !== null) {
-    score += 1;
-  }
-  if (prevPitch !== void 0) {
-    const move = pitch - prevPitch;
-    const dist = Math.abs(move);
-    score -= dist * 0.3;
-    if (dist > 0 && dist <= 2) {
-      score += 1;
-    }
-    if (isForbiddenMelodicLeap(prevPitch, pitch)) {
-      score -= 6;
-    }
-    if (melPitch !== void 0 && melPrev !== void 0) {
-      const melMove = melPitch - melPrev;
-      if (move > 0 && melMove < 0 || move < 0 && melMove > 0) {
-        score += 2;
-      } else if (move === 0 || melMove === 0) {
-        score += 1;
-      } else {
-        score -= 1;
-      }
-    }
-  }
-  score -= Math.abs(pitch - center) * 0.02;
-  return score;
-}
-function heldNoteBoundaries(melody, startBeat, endBeat, chordChangeBeats) {
-  const boundaries = /* @__PURE__ */ new Set([startBeat]);
-  for (const onset of melody.onsetsBetween(startBeat, endBeat)) {
-    boundaries.add(onset);
-  }
-  for (const beat of chordChangeBeats) {
-    if (beat > startBeat + EPS4 && beat < endBeat - EPS4) {
-      boundaries.add(beat);
-    }
-  }
-  const firstGrid = Math.floor(startBeat / GRID_STEP + 1) * GRID_STEP;
-  for (let beat = firstGrid; beat < endBeat - EPS4; beat += GRID_STEP) {
-    boundaries.add(beat);
-  }
-  return [...boundaries].sort((a, b) => a - b);
-}
-function heldPitchSafety(pitch, startBeat, endBeat, prevPitch, melody, opts, profile, register, low, high, ts) {
-  let worst = 0 /* Safe */;
-  const boundaries = heldNoteBoundaries(melody, startBeat, endBeat, opts.chordChangeBeats ?? []);
-  for (const boundary of boundaries) {
-    const melodyVoice = melodySnapshotAt(melody, boundary);
-    if (melodyVoice !== void 0 && (register === "below" && pitch >= melodyVoice.pitch || register === "above" && pitch <= melodyVoice.pitch)) {
-      return null;
-    }
-    const atCounterOnset = Math.abs(boundary - startBeat) < EPS4;
-    const result = evaluateSafety({
-      profile,
-      candidatePitch: pitch,
-      prevPitch: atCounterOnset ? prevPitch : pitch,
-      chord: opts.chordAt(boundary),
-      key: opts.key,
-      otherVoices: melodyVoice ? [melodyVoice] : [],
-      strongBeat: isStrongBeat(boundary, ts),
-      vocalLow: low,
-      vocalHigh: high
-    });
-    worst = Math.max(worst, result.safety);
-    if (worst === 2 /* Dissonant */) {
-      return worst;
-    }
-  }
-  return worst;
-}
-function generateCounterMelody(opts) {
-  const melody = createNoteEventIndex(opts.melody);
-  if (melody.notes.length === 0) {
-    return [];
-  }
-  const ts = opts.ts ?? DEFAULT_TS2;
-  assertTimeSignature(ts);
-  const register = opts.register ?? "below";
-  const rhythm = opts.rhythm ?? "complement";
-  const profile = opts.profile ?? "pop";
-  const rng = createRng(opts.seed ?? 0);
-  const spanStart = melody.notes[0]?.note.startBeat ?? 0;
-  const spanEnd = melody.notes.reduce((end, n) => Math.max(end, n.endBeat), spanStart);
-  assertGenerationBudget(Math.ceil((spanEnd - spanStart) / GRID_STEP), "countermelody grid");
-  const meanPitch = melody.notes.reduce((sum, n) => sum + n.note.pitch, 0) / melody.notes.length;
-  const defaultCenter = register === "below" ? meanPitch - REGISTER_OFFSET : meanPitch + REGISTER_OFFSET;
-  const low = opts.pitchLow ?? Math.round(defaultCenter) - DEFAULT_HALF_RANGE;
-  const high = opts.pitchHigh ?? Math.round(defaultCenter) + DEFAULT_HALF_RANGE;
-  assertInteger(low, "countermelody pitchLow");
-  assertInteger(high, "countermelody pitchHigh");
-  if (low > high) {
-    throw new RangeError(
-      `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
-    );
-  }
-  assertGenerationBudget(high - low + 1, "countermelody pitch candidates");
-  assertGenerationBudget(opts.chordChangeBeats?.length ?? 0, "chord change beats");
-  for (let index = 0; index < (opts.chordChangeBeats?.length ?? 0); index += 1) {
-    assertRange(
-      opts.chordChangeBeats?.[index] ?? Number.NaN,
-      0,
-      Number.MAX_SAFE_INTEGER,
-      `chordChangeBeats[${index}]`
-    );
-  }
-  const center = (low + high) / 2;
-  const onsets = rhythm === "follow" ? followOnsets(melody) : complementOnsets(melody, ts, spanStart, spanEnd, rng);
-  assertGenerationBudget(onsets.length * (high - low + 1), "countermelody search");
-  const out = [];
-  let prevPitch;
-  for (let onsetIndex = 0; onsetIndex < onsets.length; onsetIndex += 1) {
-    const beat = onsets[onsetIndex];
-    if (beat === void 0) {
-      continue;
-    }
-    const nextOnset = onsets[onsetIndex + 1];
-    const endBeat = nextOnset ?? Math.max(spanEnd, beat + GRID_STEP);
-    const melNote = melodyNoteAt(melody, beat);
-    const melPitch = melNote?.pitch;
-    const melodyVoice = melodySnapshotAt(melody, beat);
-    const melPrev = melodyVoice?.prevPitch;
-    const chord = opts.chordAt(beat);
-    const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
-    const candidates = enumerateSafePitches(
-      {
-        profile,
-        prevPitch,
-        chord,
-        key: opts.key,
-        otherVoices,
-        strongBeat: isStrongBeat(beat, ts),
-        vocalLow: low,
-        vocalHigh: high
-      },
-      low,
-      high
-    );
-    let bestPitch;
-    let bestWorstSafety = 2 /* Dissonant */;
-    let bestScore = Number.NEGATIVE_INFINITY;
-    for (const candidate of candidates) {
-      const worstSafety = heldPitchSafety(
-        candidate,
-        beat,
-        endBeat,
-        prevPitch,
-        melody,
-        opts,
-        profile,
-        register,
-        low,
-        high,
-        ts
-      );
-      if (worstSafety === null || worstSafety === 2 /* Dissonant */) {
-        continue;
-      }
-      if (melPitch !== void 0) {
-        if (prevPitch !== void 0 && melPrev !== void 0 && // Parallel octaves are the perfect-class-zero case of this predicate,
-        // so a single check covers both parallel fifths and octaves.
-        createsParallelPerfect(prevPitch, candidate, melPrev, melPitch)) {
-          continue;
-        }
-      }
-      const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center);
-      const tie = Math.abs(score - bestScore) <= EPS4 && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
-      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS4 || tie)) {
-        bestWorstSafety = worstSafety;
-        bestScore = score;
-        bestPitch = candidate;
-      }
-    }
-    if (bestPitch === void 0) {
-      prevPitch = void 0;
-      continue;
-    }
-    const pitch = bestPitch;
-    const velocity = Math.max(
-      1,
-      Math.min(127, Math.round((melNote?.velocity ?? DEFAULT_MELODY_VELOCITY) - VELOCITY_DROP))
-    );
-    out.push({ pitch, startBeat: beat, durationBeat: endBeat - beat, velocity });
-    prevPitch = pitch;
-  }
-  return out;
-}
 
-// src/generate/drums/internal.ts
-var GM = {
-  BD: 36,
-  SD: 38,
-  SIDESTICK: 37,
-  HANDCLAP: 39,
-  CHH: 42,
-  FHH: 44,
-  OHH: 46,
-  CRASH: 49,
-  RIDE: 51,
-  TAMBOURINE: 54,
-  TOM_H: 50,
-  TOM_M: 47,
-  TOM_L: 45,
-  SHAKER: 82
-};
-var EIGHTH = 0.5;
-var SIXTEENTH = 0.25;
-var STYLE_MAP = {
-  // Standard pop pulse: kick on beats 1 and 3, backbeat snare on 2 and 4.
-  standard: { style: "standard", feel: "straight", ghostBoost: false, snareBeat3: false },
-  funk: { style: "upbeat", feel: "straight", ghostBoost: true, snareBeat3: false },
-  shuffle: { style: "standard", feel: "shuffle", ghostBoost: false, snareBeat3: false },
-  bossa: { style: "latin", feel: "straight", ghostBoost: false, snareBeat3: false },
-  trap: { style: "trap", feel: "straight", ghostBoost: false, snareBeat3: true },
-  halftime: { style: "sparse", feel: "straight", ghostBoost: false, snareBeat3: true },
-  breakbeat: { style: "rock", feel: "straight", ghostBoost: false, snareBeat3: false },
-  // Four-on-the-floor dance kick with idol-style auxiliary percussion.
-  house: { style: "fourOnFloor", feel: "straight", ghostBoost: false, snareBeat3: false },
-  // Synth-pop pulse with denser 16th hi-hats and busy kick syncopation.
-  synthpop: { style: "synth", feel: "straight", ghostBoost: true, snareBeat3: false }
-};
-function mapStyle(style) {
-  return STYLE_MAP[style];
-}
-function mapSection(section) {
-  switch (section) {
-    case "intro":
-      return "intro";
-    case "verse":
-      return "a";
-    case "prechorus":
-      return "b";
-    case "chorus":
-      return "chorus";
-    case "bridge":
-      return "bridge";
-    case "outro":
-      return "outro";
-  }
-}
-function mapDensity(density) {
-  if (density < 0.34) {
-    return "thin";
-  }
-  if (density < 0.67) {
-    return "normal";
-  }
-  return "thick";
-}
-function feelSwingAmount(feel) {
-  if (feel === "swing") {
-    return 0.33;
-  }
-  if (feel === "shuffle") {
-    return 0.5;
-  }
-  return 0;
-}
-function ghostMoodCategory(style) {
-  if (style === "sparse") {
-    return 0 /* Calm */;
-  }
-  if (style === "trap" || style === "upbeat") {
-    return 2 /* Energetic */;
-  }
-  return 1 /* Standard */;
-}
-function percMoodCategory(style) {
-  switch (style) {
-    case "sparse":
-      return 0 /* Calm */;
-    case "upbeat":
-    case "latin":
-      return 2 /* Energetic */;
-    case "fourOnFloor":
-      return 3 /* Idol */;
-    case "trap":
-    case "rock":
-      return 4 /* RockDark */;
-    default:
-      return 1 /* Standard */;
-  }
-}
-function sectionIndex(section) {
-  switch (section) {
-    case "intro":
-      return 0;
-    case "a":
-      return 1;
-    case "b":
-      return 2;
-    case "chorus":
-      return 3;
-    case "bridge":
-      return 4;
-    case "outro":
-      return 6;
-  }
-}
-function sectionEnergy(section) {
-  switch (section) {
-    case "intro":
-    case "outro":
-      return "low";
-    case "a":
-    case "bridge":
-      return "medium";
-    case "b":
-      return "high";
-    case "chorus":
-      return "peak";
-  }
-}
-function sectionVelocityMultiplier(section) {
-  switch (section) {
-    case "intro":
-    case "outro":
-      return 0.8;
-    case "a":
-      return 0.9;
-    case "b":
-      return 1;
-    case "chorus":
-      return 1.1;
-    case "bridge":
-      return 0.85;
-  }
-}
-function sectionDensityMultiplier(section) {
-  switch (section) {
-    case "intro":
-      return 0.5;
-    case "a":
-      return 0.7;
-    case "b":
-      return 0.85;
-    case "chorus":
-      return 1;
-    case "bridge":
-      return 0.6;
-    case "outro":
-      return 0.6;
-  }
-}
-function calculateVelocity(section, beat) {
-  const base = 80;
-  const beatAdj = beat === 0 ? 10 : beat === 2 ? 5 : 0;
-  const velocity = (base + beatAdj) * sectionVelocityMultiplier(section);
-  return clampVel(velocity);
-}
-function clampVel(velocity) {
-  return Math.max(1, Math.min(127, Math.round(velocity)));
-}
 
-// src/generate/drums/ghost.ts
-var GHOST_DENSITY_TABLE = [
-  /* intro     */
-  [0, 1, 1],
-  /* a         */
-  [0, 1, 2],
-  /* b         */
-  [1, 2, 2],
-  /* chorus    */
-  [1, 2, 3],
-  /* bridge    */
-  [1, 1, 2],
-  /* interlude */
-  [0, 1, 1],
-  /* outro     */
-  [0, 1, 1]
-];
-function levelToProbability(level) {
-  switch (level) {
-    case 0:
-      return 0;
-    case 1:
-      return 0.15;
-    case 2:
-      return 0.3;
-    case 3:
-      return 0.45;
-  }
-}
-function clampLevel(level) {
-  return Math.max(0, Math.min(3, level));
-}
-function adjustForBpm(level, bpm) {
-  if (bpm >= 160 && level !== 0) {
-    return clampLevel(level - 1);
-  }
-  if (bpm <= 90 && level !== 3) {
-    return clampLevel(level + 1);
-  }
-  return level;
-}
-function getGhostDensity(mood, section, backingDensity, bpm) {
-  const row = GHOST_DENSITY_TABLE[sectionIndex(section)] ?? GHOST_DENSITY_TABLE[1];
-  const level = adjustForBpm(row?.[mood] ?? 0, bpm);
-  if (backingDensity === "thin" && level !== 0) {
-    return levelToProbability(clampLevel(level - 1));
-  }
-  if (backingDensity === "thick" && level !== 3) {
-    return levelToProbability(clampLevel(level + 1));
-  }
-  return levelToProbability(level);
-}
-function getGhostVelocity(section, beatPosition, isAfterSnare) {
-  let base = 0.4;
-  const even = beatPosition % 2 === 0 ? 0.05 : 0;
-  switch (section) {
-    case "a":
-      base = 0.35 + even;
-      break;
-    case "chorus":
-      base = 0.5 + even;
-      break;
-    case "bridge":
-      base = 0.25 + even;
-      break;
-    case "b":
-      base = 0.4 + even;
-      break;
-    case "intro":
-    case "outro":
-      base = 0.38;
-      break;
-  }
-  if (isAfterSnare) {
-    base += 0.1;
-  }
-  return Math.max(0.25, Math.min(0.65, base));
-}
-function getGhostProbabilityAtPosition(beat, sixteenthInBeat) {
-  const nearSnare = beat === 0 && sixteenthInBeat === 3 || beat === 1 && sixteenthInBeat === 1 || beat === 2 && sixteenthInBeat === 3 || beat === 3 && sixteenthInBeat === 1;
-  return nearSnare ? 0.6 : 0.25;
-}
-function selectGhostPositions(mood, rng) {
-  if (mood === 2 /* Energetic */) {
-    return ["e", "a"];
-  }
-  if (mood === 0 /* Calm */) {
-    return rng.prob(0.5) ? ["e"] : [];
-  }
-  return ["e"];
-}
 
-// src/generate/drums/hihat.ts
-var HH_16TH_BPM_THRESHOLD = 150;
-var FHH_VEL_MIN = 45;
-var FHH_VEL_MAX = 60;
-var OHH_VEL_BOOST = 7;
-function shouldPlayHiHat(role) {
-  return role !== "fxOnly";
-}
-function roleHiHatInstrument(role, useRide) {
-  if (role === "ambient") {
-    return GM.RIDE;
-  }
-  return useRide ? GM.RIDE : GM.CHH;
-}
-function sparser(level) {
-  if (level === "sixteenth") {
-    return "eighth";
-  }
-  if (level === "eighth") {
-    return "quarter";
-  }
-  return "quarter";
-}
-function denser(level) {
-  if (level === "quarter") {
-    return "eighth";
-  }
-  if (level === "eighth") {
-    return "sixteenth";
-  }
-  return "sixteenth";
-}
-function getHiHatLevel(section, style, backingDensity, bpm, rng) {
-  const allow16th = bpm < HH_16TH_BPM_THRESHOLD;
-  let base = "eighth";
-  if (style === "sparse") {
-    base = section === "chorus" ? "eighth" : "quarter";
-  } else if (style === "fourOnFloor") {
-    if (allow16th && section === "chorus" && rng.prob(0.25)) {
-      return "sixteenth";
-    }
-    return "eighth";
-  } else if (style === "synth") {
-    if (!allow16th) {
-      return "eighth";
-    }
-    if (section === "a" && rng.prob(0.2)) {
-      return "eighth";
-    }
-    return "sixteenth";
-  } else if (style === "trap") {
-    return allow16th ? "sixteenth" : "eighth";
-  } else if (style === "latin") {
-    if (allow16th && section === "chorus" && rng.prob(0.3)) {
-      return "sixteenth";
-    }
-    return "eighth";
-  } else {
-    switch (section) {
-      case "intro":
-        base = "quarter";
-        break;
-      case "outro":
-        base = "eighth";
-        break;
-      case "a":
-        base = rng.prob(0.3) ? "quarter" : "eighth";
-        break;
-      case "b":
-        base = allow16th && rng.prob(0.25) ? "sixteenth" : "eighth";
-        break;
-      case "chorus":
-        base = allow16th && rng.prob(0.35) ? "sixteenth" : "eighth";
-        break;
-      case "bridge":
-        base = "eighth";
-        break;
-    }
-  }
-  if (backingDensity === "thin") {
-    base = sparser(base);
-  } else if (backingDensity === "thick") {
-    base = denser(base);
-  }
-  if (!allow16th && base === "sixteenth") {
-    base = "eighth";
-  }
-  return base;
-}
-function hiHatVelocityMultiplier(sixteenth, rng) {
-  let baseValue;
-  switch (sixteenth) {
-    case 0:
-      baseValue = 0.95;
-      break;
-    case 2:
-      baseValue = 0.75;
-      break;
-    case 1:
-      baseValue = 0.55;
-      break;
-    default:
-      baseValue = 0.5;
-      break;
-  }
-  return baseValue * rng.float(0.95, 1.05);
-}
-function openHiHatBarInterval(section, style) {
-  if (style === "sparse") {
-    return section === "chorus" ? 4 : 0;
-  }
-  switch (section) {
-    case "intro":
-      return style === "fourOnFloor" ? 4 : 0;
-    case "a":
-      return style === "fourOnFloor" || style === "upbeat" ? 2 : 4;
-    case "b":
-      return 2;
-    case "chorus":
-      return style === "rock" || style === "fourOnFloor" ? 1 : 2;
-    case "bridge":
-      return 0;
-    case "outro":
-      return 4;
-  }
-}
-function openHiHatBeat(section, rng) {
-  if (section === "chorus") {
-    const choice = rng.range(0, 3);
-    if (choice < 2) {
-      return 3;
-    }
-    if (choice < 3) {
-      return 1;
-    }
-    return 2;
-  }
-  return 3;
-}
-function shouldUseFootHiHat(section, role) {
-  if (role === "fxOnly") {
-    return false;
-  }
-  switch (section) {
-    case "intro":
-    case "bridge":
-    case "outro":
-      return true;
-    default:
-      return role === "ambient" || role === "minimal";
-  }
-}
-function sectionHiHatType(section, role) {
-  if (role === "ambient") {
-    return "ride";
-  }
-  if (role === "minimal") {
-    return "pedal";
-  }
-  switch (section) {
-    case "intro":
-    case "a":
-      return "pedal";
-    case "b":
-      return "closed";
-    case "chorus":
-      return "open";
-    case "bridge":
-      return "ride";
-    case "outro":
-      return "halfOpen";
-  }
-}
-function hiHatNote(type) {
-  switch (type) {
-    case "pedal":
-      return GM.FHH;
-    case "open":
-      return GM.OHH;
-    case "ride":
-      return GM.RIDE;
-    default:
-      return GM.CHH;
-  }
-}
-function hiHatTypeVelocityMultiplier(type) {
-  switch (type) {
-    case "halfOpen":
-      return 0.75;
-    case "pedal":
-      return 0.65;
-    case "open":
-      return 1;
-    case "ride":
-      return 0.9;
-    default:
-      return 0.85;
-  }
-}
-function shouldAddOpenHHAccent(section, beat, bar, rng) {
-  if (section !== "chorus" && section !== "b") {
-    return false;
-  }
-  if (section === "chorus") {
-    if (beat === 1 || beat === 3) {
-      return rng.prob(0.6);
-    }
-    return false;
-  }
-  if (beat === 3 && bar % 2 === 1) {
-    return rng.prob(0.4);
-  }
-  return false;
-}
-function footHiHatVelocity(rng) {
-  return rng.range(FHH_VEL_MIN, FHH_VEL_MAX);
-}
-function shouldUseRideForSection(section, style) {
-  if (style === "rock" && section === "chorus") {
-    return true;
-  }
-  if (style === "sparse") {
-    return false;
-  }
-  return section === "bridge";
-}
-function shouldUseBridgeCrossStick(section, beat) {
-  return section === "bridge" && (beat === 1 || beat === 3);
-}
 
-// src/generate/drums/swing.ts
-var SIXTEENTH2 = 0.25;
-var EIGHTH2 = 0.5;
-var HALF_16TH = 0.125;
-var DELTA_16 = 1 / 3 - 1 / 4;
-var DELTA_8 = (2 / 3 - 1 / 2) / 2 + (2 / 3 - 1 / 2) / 2;
-function effectiveSwing(feel, swingAmount) {
-  if (feel === "straight") {
-    return 0;
-  }
-  if (feel === "shuffle") {
-    return Math.min(1, swingAmount * 1.5);
-  }
-  return swingAmount;
-}
-function quantizeSwing(startBeat, swing, resolution) {
-  const clamped = Math.max(0, Math.min(1, swing));
-  if (clamped <= 0) {
-    return startBeat;
-  }
-  const base = Math.floor(startBeat);
-  const offset = startBeat - base;
-  if (resolution === "sixteenth") {
-    if (offset >= HALF_16TH && offset < SIXTEENTH2 + HALF_16TH) {
-      return base + SIXTEENTH2 + DELTA_16 * clamped;
-    }
-    if (offset >= SIXTEENTH2 + HALF_16TH && offset < EIGHTH2 + HALF_16TH) {
-      return base + EIGHTH2 + DELTA_8 * clamped;
-    }
-    if (offset >= EIGHTH2 + HALF_16TH && offset < 3 * SIXTEENTH2 + HALF_16TH) {
-      return base + 3 * SIXTEENTH2 + DELTA_16 * clamped;
-    }
-    return startBeat;
-  }
-  if (offset >= SIXTEENTH2 && offset < 3 * SIXTEENTH2) {
-    return base + EIGHTH2 + DELTA_8 * clamped;
-  }
-  return startBeat;
-}
 
-// src/generate/drums/beat.ts
-function swing16(tick, feel, swingAmount) {
-  return quantizeSwing(tick, effectiveSwing(feel, swingAmount), "sixteenth");
-}
-function hatSwingFactor(style) {
-  if (style === "trap") {
-    return 0;
-  }
-  if (style === "latin") {
-    return 0.35;
-  }
-  return 0.5;
-}
-function generateKickForBeat(ctx, sec, kick) {
-  if (ctx.inPrechorusLift) {
-    return;
-  }
-  const on = [kick.beat1, kick.beat2, kick.beat3, kick.beat4][ctx.beat] ?? false;
-  const and = [kick.beat1and, kick.beat2and, kick.beat3and, kick.beat4and][ctx.beat] ?? false;
-  if (on) {
-    ctx.track.add(GM.BD, ctx.beatTick, EIGHTH, ctx.velocity);
-  }
-  if (and) {
-    const andTick = swing16(ctx.beatTick + EIGHTH, sec.feel, ctx.swingAmount);
-    ctx.track.add(GM.BD, andTick, EIGHTH, ctx.velocity * 0.85);
-  }
-}
-function generateSnareForBeat(ctx, sec, isIntroFirst) {
-  if (ctx.inPrechorusLift) {
-    return;
-  }
-  const snareOn = sec.snareBeat3 ? ctx.beat === 2 : ctx.beat === 1 || ctx.beat === 3;
-  if (!snareOn || isIntroFirst) {
-    return;
-  }
-  if (sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat)) {
-    return;
-  }
-  const backbeatVel = Math.min(127, ctx.velocity + 16);
-  const promoteSparseChorus = sec.style === "sparse" && ctx.section === "chorus" && sec.role === "full";
-  if (promoteSparseChorus) {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  } else if (sec.style === "sparse" || sec.role === "ambient") {
-    if (sec.role !== "fxOnly" && sec.role !== "minimal") {
-      ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.8);
-    }
-  } else {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  }
-}
-function generateGhostNotesForBeat(ctx, sec) {
-  if (ctx.beat !== 0 && ctx.beat !== 2) {
-    return;
-  }
-  const positions = selectGhostPositions(sec.ghostMood, ctx.rng);
-  let ghostProb = getGhostDensity(sec.ghostMood, ctx.section, sec.backingDensity, ctx.bpm);
-  if (sec.ghostBoost) {
-    ghostProb = Math.min(1, ghostProb * 1.4);
-  }
-  for (const pos of positions) {
-    const sixteenthInBeat = pos === "e" ? 1 : 3;
-    const posProb = getGhostProbabilityAtPosition(ctx.beat, sixteenthInBeat);
-    if (!ctx.rng.prob(ghostProb * posProb)) {
-      continue;
-    }
-    const variation = ctx.rng.float(0.85, 1.15);
-    const ghostBase = getGhostVelocity(ctx.section, ctx.beat / 2, false);
-    let ghostVel = ctx.velocity * ghostBase * variation;
-    if (pos === "a") {
-      ghostVel *= 0.9;
-    }
-    const offset = pos === "e" ? SIXTEENTH : 3 * SIXTEENTH;
-    const tick = swing16(ctx.beatTick + offset, sec.feel, ctx.swingAmount);
-    ctx.track.add(GM.SD, tick, SIXTEENTH, ghostVel);
-  }
-}
-function generatePreChorusBuildup(ctx, sec, isSectionLastBar) {
-  if (sec.style === "sparse") {
-    if (isSectionLastBar && ctx.beat === 3) {
-      ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, Math.max(45, ctx.velocity * 0.75));
-      ctx.track.add(GM.CRASH, ctx.beatTick + EIGHTH + SIXTEENTH, SIXTEENTH, ctx.velocity * 0.9);
-    }
-    return;
-  }
-  const barsInLift = 2;
-  const barInLift = ctx.bar - (ctx.sectionBars - barsInLift);
-  const progress = (barInLift * 4 + ctx.beat) / (barsInLift * 4);
-  const buildupVel = ctx.velocity * (0.5 + 0.5 * progress);
-  ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, buildupVel);
-  ctx.track.add(GM.SD, ctx.beatTick + EIGHTH, EIGHTH, buildupVel * 0.85);
-  if (isSectionLastBar && ctx.beat === 3) {
-    ctx.track.add(GM.CRASH, ctx.beatTick + EIGHTH + SIXTEENTH, SIXTEENTH, ctx.velocity * 1.1);
-  }
-}
-function generateHiHatForBeat(ctx, sec) {
-  if (!shouldPlayHiHat(sec.role)) {
-    if (sec.useFootHh && (ctx.beat === 0 || ctx.beat === 2)) {
-      ctx.track.add(GM.FHH, ctx.beatTick, EIGHTH, footHiHatVelocity(ctx.rng));
-    }
-    return;
-  }
-  const crossStick = sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat);
-  const hhInstrument = crossStick ? GM.SIDESTICK : roleHiHatInstrument(sec.role, sec.useRide);
-  const hhType = sectionHiHatType(ctx.section, sec.role);
-  const typeMult = hiHatTypeVelocityMultiplier(hhType);
-  const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat;
-  const dm = sec.densityMult;
-  if (sec.hhLevel === "quarter") {
-    const introRest = ctx.section === "intro" && ctx.beat !== 0;
-    if (!introRest) {
-      if (isDynamicOpen) {
-        ctx.track.add(
-          GM.OHH,
-          ctx.beatTick,
-          EIGHTH,
-          ctx.velocity * dm * 0.75 * typeMult + OHH_VEL_BOOST
-        );
-      } else {
-        ctx.track.add(
-          hhInstrument,
-          ctx.beatTick,
-          EIGHTH,
-          Math.max(20, ctx.velocity * dm * 0.75 * typeMult)
-        );
-      }
-    } else if (sec.useFootHh) {
-      ctx.track.add(GM.FHH, ctx.beatTick, EIGHTH, footHiHatVelocity(ctx.rng));
-    }
-    return;
-  }
-  if (sec.hhLevel === "eighth") {
-    for (let eighth = 0; eighth < 2; eighth += 1) {
-      let hhTick = ctx.beatTick + eighth * EIGHTH;
-      if (eighth === 1) {
-        hhTick = swing16(hhTick, sec.feel, ctx.swingAmount);
-      }
-      if (ctx.section === "intro" && eighth === 1) {
-        if (sec.useFootHh && ctx.beat % 2 === 0) {
-          ctx.track.add(GM.FHH, hhTick, EIGHTH, footHiHatVelocity(ctx.rng));
-        }
-        continue;
-      }
-      const hhVel = Math.max(20, ctx.velocity * dm * typeMult * (eighth === 0 ? 0.9 : 0.65));
-      if (isDynamicOpen && eighth === 0) {
-        ctx.track.add(GM.OHH, hhTick, EIGHTH, hhVel + OHH_VEL_BOOST);
-        continue;
-      }
-      let useOpen = false;
-      if (sec.style === "fourOnFloor" && eighth === 1) {
-        const openProb = Math.max(0.15, Math.min(0.8, 45 / ctx.bpm));
-        useOpen = (ctx.beat === 1 || ctx.beat === 3) && ctx.rng.prob(openProb);
-      } else if (eighth === 0) {
-        useOpen = shouldAddOpenHHAccent(ctx.section, ctx.beat, ctx.bar, ctx.rng);
-      }
-      if (useOpen) {
-        ctx.track.add(hiHatNote("open"), hhTick, EIGHTH, Math.max(20, hhVel * 1.1));
-      } else {
-        ctx.track.add(hhInstrument, hhTick, EIGHTH / 2, hhVel);
-      }
-    }
-    return;
-  }
-  for (let sixteenth = 0; sixteenth < 4; sixteenth += 1) {
-    let hhTick = ctx.beatTick + sixteenth * SIXTEENTH;
-    if (sixteenth === 1 || sixteenth === 3) {
-      const swung = effectiveSwing(sec.feel, ctx.swingAmount) * hatSwingFactor(sec.style);
-      hhTick = quantizeSwing(hhTick, swung, "sixteenth");
-    }
-    const metricVel = hiHatVelocityMultiplier(sixteenth, ctx.rng);
-    const hhVel = Math.max(20, ctx.velocity * dm * typeMult * metricVel);
-    if (isDynamicOpen && sixteenth === 0) {
-      ctx.track.add(GM.OHH, hhTick, SIXTEENTH, hhVel + OHH_VEL_BOOST);
-      continue;
-    }
-    if (ctx.beat === 3 && sixteenth === 3) {
-      const openProb = Math.max(0.1, Math.min(0.4, 30 / ctx.bpm));
-      if (ctx.rng.prob(openProb)) {
-        ctx.track.add(GM.OHH, hhTick, SIXTEENTH, Math.max(20, hhVel * 1.2));
-        continue;
-      }
-    }
-    ctx.track.add(hhInstrument, hhTick, SIXTEENTH / 2, hhVel);
-  }
-}
 
-// src/generate/drums/euclid.ts
-function euclideanRhythm(pulses, steps, rotation = 0) {
-  assertPositiveInt(steps, "euclidean steps");
-  assertInteger(pulses, "euclidean pulses");
-  assertInteger(rotation, "euclidean rotation");
-  assertGenerationBudget(steps, "euclidean pattern steps");
-  const p = Math.max(0, Math.min(pulses, steps));
-  const base = bjorklund(p, steps);
-  const shift = (rotation % steps + steps) % steps;
-  if (shift === 0) {
-    return base;
-  }
-  return base.map((_, i) => base[(i - shift + steps) % steps] ?? false);
-}
-function bjorklund(pulses, steps) {
-  if (pulses === 0) {
-    return Array.from({ length: steps }, () => false);
-  }
-  if (pulses >= steps) {
-    return Array.from({ length: steps }, () => true);
-  }
-  let head = Array.from({ length: pulses }, () => [true]);
-  let remainder = Array.from({ length: steps - pulses }, () => [false]);
-  while (remainder.length > 1) {
-    const count = Math.min(head.length, remainder.length);
-    const next = [];
-    for (let i = 0; i < count; i += 1) {
-      next.push([...head[i] ?? [], ...remainder[i] ?? []]);
-    }
-    remainder = head.length > count ? head.slice(count) : remainder.slice(count);
-    head = next;
-  }
-  return [...head.flat(), ...remainder.flat()];
-}
 
-// src/generate/drums/fills.ts
-function getFillStartBeat(energy) {
-  switch (energy) {
-    case "low":
-      return 3;
-    case "medium":
-      return 2;
-    case "high":
-    case "peak":
-      return 0;
-  }
-}
-function selectFillType(from, to, style, nextEnergy, rng) {
-  if (style === "sparse") {
-    return rng.range(0, 1) === 0 ? "simpleCrash" : "breakdownFill";
-  }
-  const toChorus = to === "chorus";
-  const fromIntro = from === "intro";
-  const highEnergy = style === "rock" || style === "fourOnFloor";
-  if (nextEnergy === "low") {
-    switch (rng.range(0, 2)) {
-      case 0:
-        return "simpleCrash";
-      case 1:
-        return "breakdownFill";
-      default:
-        return "halfTimeFill";
-    }
-  }
-  if (toChorus) {
-    const choice2 = rng.range(0, 7);
-    if (highEnergy) {
-      switch (choice2) {
-        case 0:
-        case 1:
-          return "tomDescend";
-        case 2:
-          return "snareRoll";
-        case 3:
-          return "linearFill";
-        case 4:
-          return "bdSnareAlternate";
-        case 5:
-          return "flamsAndDrags";
-        case 6:
-          return "tomShuffle";
-        default:
-          return "ghostToAccent";
-      }
-    }
-    switch (choice2) {
-      case 0:
-      case 1:
-        return "snareTomCombo";
-      case 2:
-        return "tomDescend";
-      case 3:
-        return "ghostToAccent";
-      case 4:
-        return "hiHatChoke";
-      case 5:
-        return "linearFill";
-      default:
-        return "snareRoll";
-    }
-  }
-  if (fromIntro) {
-    switch (rng.range(0, 5)) {
-      case 0:
-      case 1:
-        return "snareRoll";
-      case 2:
-        return "simpleCrash";
-      case 3:
-        return "ghostToAccent";
-      case 4:
-        return "breakdownFill";
-      default:
-        return "halfTimeFill";
-    }
-  }
-  const choice = rng.range(0, 7);
-  if (highEnergy) {
-    switch (choice) {
-      case 0:
-        return "tomDescend";
-      case 1:
-        return "snareRoll";
-      case 2:
-        return "tomAscend";
-      case 3:
-        return "snareTomCombo";
-      case 4:
-        return "linearFill";
-      case 5:
-        return "bdSnareAlternate";
-      case 6:
-        return "flamsAndDrags";
-      default:
-        return "tomShuffle";
-    }
-  }
-  switch (choice) {
-    case 0:
-    case 1:
-      return "snareRoll";
-    case 2:
-      return "snareTomCombo";
-    case 3:
-      return "ghostToAccent";
-    case 4:
-      return "hiHatChoke";
-    case 5:
-      return "halfTimeFill";
-    default:
-      return "breakdownFill";
-  }
-}
-function generateFill(track, beatTick, beat, fillType, velocity) {
-  const fillVel = velocity * 0.9;
-  const accentVel = velocity * 0.95;
-  const S = SIXTEENTH;
-  const E = EIGHTH;
-  if (beat === 0) {
-    track.add(GM.BD, beatTick, E, fillVel);
-    track.add(GM.SD, beatTick + E, E, fillVel - 5);
-    return;
-  }
-  if (beat === 1) {
-    track.add(GM.SD, beatTick, E, fillVel);
-    track.add(GM.TOM_H, beatTick + E, E, fillVel - 3);
-    return;
-  }
-  switch (fillType) {
-    case "snareRoll":
-      if (beat === 2) {
-        for (let i = 0; i < 4; i += 1) {
-          track.add(GM.SD, beatTick + i * S, S, fillVel * (0.6 + 0.1 * i));
-        }
-      } else {
-        for (let i = 0; i < 3; i += 1) {
-          track.add(GM.SD, beatTick + i * S, S, fillVel * (0.7 + 0.1 * i));
-        }
-        track.add(GM.SD, beatTick + 3 * S, S, accentVel);
-      }
-      break;
-    case "tomDescend":
-      if (beat === 2) {
-        track.add(GM.SD, beatTick, E, fillVel);
-        track.add(GM.TOM_H, beatTick + E, E, fillVel - 5);
-      } else {
-        track.add(GM.TOM_H, beatTick, S, fillVel);
-        track.add(GM.TOM_M, beatTick + S, S, fillVel - 3);
-        track.add(GM.TOM_M, beatTick + E, S, fillVel - 5);
-        track.add(GM.TOM_L, beatTick + E + S, S, accentVel);
-      }
-      break;
-    case "tomAscend":
-      if (beat === 2) {
-        track.add(GM.SD, beatTick, E, fillVel);
-        track.add(GM.TOM_L, beatTick + E, E, fillVel - 5);
-      } else {
-        track.add(GM.TOM_L, beatTick, S, fillVel);
-        track.add(GM.TOM_M, beatTick + S, S, fillVel + 3);
-        track.add(GM.TOM_M, beatTick + E, S, fillVel + 5);
-        track.add(GM.TOM_H, beatTick + E + S, S, accentVel);
-      }
-      break;
-    case "snareTomCombo":
-      if (beat === 2) {
-        track.add(GM.SD, beatTick, E, fillVel);
-        track.add(GM.SD, beatTick + E, S, fillVel - 5);
-        track.add(GM.TOM_H, beatTick + E + S, S, fillVel);
-      } else {
-        track.add(GM.TOM_M, beatTick, S, fillVel);
-        track.add(GM.SD, beatTick + S, S, fillVel - 3);
-        track.add(GM.TOM_L, beatTick + E, S, fillVel + 2);
-        track.add(GM.BD, beatTick + E + S, S, accentVel);
-      }
-      break;
-    case "simpleCrash":
-      if (beat === 3) {
-        track.add(GM.BD, beatTick + E + S, S, accentVel);
-        track.add(GM.CRASH, beatTick + E + S, E, accentVel);
-      }
-      break;
-    case "linearFill":
-      if (beat === 2) {
-        track.add(GM.BD, beatTick, S, fillVel);
-        track.add(GM.SD, beatTick + S, S, fillVel);
-        track.add(GM.TOM_H, beatTick + 2 * S, S, fillVel);
-        track.add(GM.TOM_M, beatTick + 3 * S, S, fillVel);
-      } else {
-        track.add(GM.TOM_L, beatTick, S, fillVel + 3);
-        track.add(GM.SD, beatTick + S, S, fillVel + 5);
-        track.add(GM.BD, beatTick + 2 * S, S, fillVel + 7);
-        track.add(GM.SD, beatTick + 3 * S, S, accentVel);
-      }
-      break;
-    case "ghostToAccent":
-      if (beat === 2) {
-        const ghost = fillVel * 0.4;
-        track.add(GM.SD, beatTick, S, ghost);
-        track.add(GM.SD, beatTick + S, S, ghost + 10);
-        track.add(GM.SD, beatTick + 2 * S, S, ghost + 20);
-        track.add(GM.SD, beatTick + 3 * S, S, ghost + 30);
-      } else {
-        track.add(GM.SD, beatTick, E, fillVel);
-        track.add(GM.SD, beatTick + E, E, accentVel);
-      }
-      break;
-    case "bdSnareAlternate":
-      if (beat === 2) {
-        track.add(GM.BD, beatTick, S, fillVel);
-        track.add(GM.SD, beatTick + S, S, fillVel);
-        track.add(GM.BD, beatTick + 2 * S, S, fillVel + 3);
-        track.add(GM.SD, beatTick + 3 * S, S, fillVel + 3);
-      } else {
-        track.add(GM.BD, beatTick, S, fillVel + 5);
-        track.add(GM.SD, beatTick + S, S, fillVel + 5);
-        track.add(GM.BD, beatTick + 2 * S, S, accentVel);
-        track.add(GM.SD, beatTick + 3 * S, S, accentVel);
-      }
-      break;
-    case "hiHatChoke":
-      if (beat === 2) {
-        track.add(GM.OHH, beatTick, E, fillVel);
-        track.add(GM.OHH, beatTick + E, E, fillVel + 5);
-      } else {
-        track.add(GM.OHH, beatTick, S, fillVel + 8);
-        track.add(GM.CHH, beatTick + S, S, accentVel);
-        track.add(GM.SD, beatTick + E, E, accentVel);
-      }
-      break;
-    case "tomShuffle":
-      if (beat === 2) {
-        track.add(GM.TOM_H, beatTick, E, fillVel);
-        track.add(GM.TOM_M, beatTick + E + S / 2, S, fillVel - 5);
-      } else {
-        track.add(GM.TOM_M, beatTick, E, fillVel);
-        track.add(GM.TOM_L, beatTick + E + S / 2, S, fillVel + 5);
-      }
-      break;
-    case "breakdownFill":
-      if (beat === 3) {
-        track.add(GM.SD, beatTick + E, S, accentVel);
-      }
-      break;
-    case "flamsAndDrags":
-      if (beat === 2) {
-        track.add(GM.SD, beatTick - S / 4, S / 4, fillVel * 0.5);
-        track.add(GM.SD, beatTick, E, fillVel);
-        track.add(GM.SD, beatTick + E, S / 2, fillVel * 0.6);
-        track.add(GM.SD, beatTick + E + S / 2, S / 2, fillVel * 0.6);
-        track.add(GM.SD, beatTick + E + S, E, fillVel);
-      } else {
-        track.add(GM.SD, beatTick - S / 4, S / 4, fillVel * 0.5);
-        track.add(GM.SD, beatTick, 1, accentVel);
-      }
-      break;
-    case "halfTimeFill":
-      if (beat === 2) {
-        track.add(GM.SD, beatTick, 1, accentVel);
-        track.add(GM.BD, beatTick, 1, fillVel);
-      } else if (beat === 3) {
-        track.add(GM.SD, beatTick, EIGHTH, accentVel);
-        track.add(GM.SD, beatTick + E, S, fillVel * 0.6);
-        track.add(GM.SD, beatTick + E + S, S, accentVel);
-      }
-      break;
-  }
-}
 
-// src/generate/drums/hit.ts
-var HitList = class {
-  hits = [];
-  /** Append a hit, clamping velocity and dropping non-positive positions. */
-  add(pitch, startBeat, durationBeat, velocity) {
-    this.hits.push({
-      pitch,
-      startBeat: Math.max(0, startBeat),
-      durationBeat,
-      velocity: clampVel(velocity)
-    });
-  }
-  /** True when a crash already sits within a 16th of `startBeat`. */
-  hasCrashNear(startBeat) {
-    return this.hits.some(
-      (h) => h.pitch === GM.CRASH && h.startBeat >= startBeat && h.startBeat < startBeat + 0.25
-    );
-  }
-};
 
-// src/generate/drums/kick.ts
-var EMPTY = {
-  beat1: false,
-  beat1and: false,
-  beat2: false,
-  beat2and: false,
-  beat3: false,
-  beat3and: false,
-  beat4: false,
-  beat4and: false
-};
-function isInPreChorusLift(section, bar, sectionBars, nextIsChorus) {
-  if (section !== "b" || !nextIsChorus || sectionBars < 3) {
-    return false;
-  }
-  return bar >= sectionBars - 2;
-}
-function getKickPattern(section, style, bar, rng) {
-  const p = { ...EMPTY };
-  if (section === "outro") {
-    p.beat1 = true;
-    p.beat3 = true;
-    return p;
-  }
-  switch (style) {
-    case "sparse":
-      p.beat1 = true;
-      if (section === "chorus" && bar % 2 === 1) {
-        p.beat3 = true;
-      }
-      break;
-    case "fourOnFloor":
-      p.beat1 = p.beat2 = p.beat3 = p.beat4 = true;
-      if (section === "chorus" && rng.prob(0.2)) {
-        p.beat2and = true;
-      }
-      break;
-    case "upbeat":
-      p.beat1 = true;
-      p.beat3 = true;
-      if (section === "b" || section === "chorus") {
-        p.beat2and = rng.prob(0.7);
-      }
-      if (section === "chorus") {
-        p.beat4and = rng.prob(0.6);
-      }
-      break;
-    case "rock":
-      p.beat1 = true;
-      p.beat3 = true;
-      if (section === "chorus") {
-        p.beat2and = rng.prob(0.65);
-        p.beat4and = rng.prob(0.4);
-      } else if (section === "b") {
-        p.beat2and = rng.prob(0.3);
-      }
-      break;
-    case "synth":
-      p.beat1 = true;
-      p.beat3 = true;
-      if (section === "b" || section === "chorus") {
-        p.beat2and = rng.prob(0.75);
-      }
-      if (section === "chorus") {
-        p.beat4and = rng.prob(0.65);
-      }
-      break;
-    case "trap":
-      p.beat1 = true;
-      p.beat2and = rng.prob(0.8);
-      p.beat3 = rng.prob(0.3);
-      p.beat4and = rng.prob(0.7);
-      break;
-    case "latin":
-      p.beat1 = true;
-      p.beat2and = true;
-      p.beat3 = true;
-      p.beat4and = rng.prob(0.5);
-      break;
-    default:
-      p.beat1 = true;
-      p.beat3 = true;
-      if (section === "b") {
-        p.beat2and = rng.prob(0.5);
-      } else if (section === "chorus") {
-        p.beat2and = rng.prob(0.55);
-        p.beat4and = rng.prob(0.35);
-      }
-      break;
-  }
-  return p;
-}
+var _chunkMPTVJIVGcjs = require('../chunk-MPTVJIVG.cjs');
+require('../chunk-MTMZTMWM.cjs');
+require('../chunk-2A2QMA74.cjs');
 
-// src/generate/drums/percussion.ts
-var F = [false, false, false];
-var PERC_TABLE = [
-  /* calm */
-  [F, F, F, F, F, F, F, F, F],
-  /* std  */
-  [F, F, [false, true, false], [true, false, true], F, F, F, F, [true, false, true]],
-  /* ener */
-  [
-    F,
-    [false, true, false],
-    [false, true, false],
-    [true, true, true],
-    F,
-    F,
-    F,
-    F,
-    [true, true, true]
-  ],
-  /* idol */
-  [
-    F,
-    [false, true, false],
-    [false, true, false],
-    [true, true, true],
-    F,
-    F,
-    F,
-    F,
-    [true, true, true]
-  ],
-  /* rock */
-  [F, F, F, [false, false, true], F, F, F, F, [false, false, true]]
-];
-function getPercussionConfig(mood, section) {
-  const row = PERC_TABLE[mood] ?? PERC_TABLE[1 /* Standard */];
-  const act = row?.[sectionIndex(section)] ?? F;
-  return {
-    tambourine: act[0],
-    shaker: act[1],
-    handclap: act[2],
-    shaker16th: act[1]
-  };
-}
-function generateAuxPercussionForBar(track, barStart, config, role, densityMult, rng, bpm) {
-  if (role === "minimal") {
-    return;
-  }
-  if (config.tambourine) {
-    for (let beat = 1; beat <= 3; beat += 2) {
-      const raw = 70 * densityMult * rng.float(0.9, 1.1);
-      track.add(GM.TAMBOURINE, barStart + beat, EIGHTH, Math.max(40, Math.min(90, raw)));
-    }
-  }
-  if (config.shaker) {
-    const use16th = config.shaker16th && bpm < HH_16TH_BPM_THRESHOLD;
-    if (use16th) {
-      const velCurve = [0.75, 0.45, 0.6, 0.45];
-      for (let beat = 0; beat < 4; beat += 1) {
-        for (let sub = 0; sub < 4; sub += 1) {
-          const raw = 80 * (velCurve[sub] ?? 0.5) * densityMult * rng.float(0.9, 1.1);
-          track.add(
-            GM.SHAKER,
-            barStart + beat + sub * SIXTEENTH,
-            SIXTEENTH,
-            Math.max(25, Math.min(85, raw))
-          );
-        }
-      }
-    } else {
-      const velCurve = [0.75, 0.55];
-      for (let beat = 0; beat < 4; beat += 1) {
-        for (let sub = 0; sub < 2; sub += 1) {
-          const raw = 80 * (velCurve[sub] ?? 0.6) * densityMult * rng.float(0.9, 1.1);
-          track.add(
-            GM.SHAKER,
-            barStart + beat + sub * EIGHTH,
-            EIGHTH,
-            Math.max(25, Math.min(85, raw))
-          );
-        }
-      }
-    }
-  }
-  if (config.handclap) {
-    for (let beat = 1; beat <= 3; beat += 2) {
-      const raw = 85 * densityMult * rng.float(0.9, 1.1);
-      track.add(GM.HANDCLAP, barStart + beat, EIGHTH, Math.max(50, Math.min(100, raw)));
-    }
-  }
-}
 
-// src/generate/drums/index.ts
-function generateDrums(opts) {
-  assertPositiveInt(opts.bars, "drum bars");
-  assertRange(opts.bpm, Number.MIN_VALUE, 1e3, "drum bpm");
-  assertRange(opts.density, 0, 1, "drum density");
-  assertGenerationBudget(opts.bars * 128, "drum hits");
-  if (opts.euclideanKick) {
-    const steps = opts.euclideanKick.steps ?? 16;
-    assertInteger(steps, "euclidean steps", 1, 16);
-    assertInteger(opts.euclideanKick.pulses, "euclidean pulses");
-    assertInteger(opts.euclideanKick.rotation ?? 0, "euclidean rotation");
-  }
-  const track = new HitList();
-  const rng = createRng(opts.seed ?? 0);
-  const mapping = mapStyle(opts.style);
-  const style = mapping.style;
-  const feel = opts.feel ?? mapping.feel;
-  const role = opts.role ?? "full";
-  const playMainVoices = role !== "fxOnly";
-  const section = mapSection(opts.section);
-  const backingDensity = mapDensity(opts.density);
-  const swingAmount = feelSwingAmount(feel);
-  let densityMult = sectionDensityMultiplier(section);
-  if (backingDensity === "thin") {
-    densityMult *= 0.75;
-  } else if (backingDensity === "thick") {
-    densityMult *= 1.15;
-  }
-  const sec = {
-    style,
-    feel,
-    densityMult,
-    backingDensity,
-    hhLevel: getHiHatLevel(section, style, backingDensity, opts.bpm, rng),
-    useGhostNotes: (section === "b" || section === "chorus" || section === "bridge") && style !== "sparse",
-    ghostBoost: mapping.ghostBoost,
-    useRide: shouldUseRideForSection(section, style),
-    useFootHh: shouldUseFootHiHat(section, role),
-    role,
-    ghostMood: ghostMoodCategory(style),
-    snareBeat3: mapping.snareBeat3
-  };
-  const ohhBarInterval = openHiHatBarInterval(section, style);
-  const energy = sectionEnergy(section);
-  const fillStartBeat = getFillStartBeat(energy);
-  const percMood = percMoodCategory(style);
-  const nextSection = opts.nextSection ? mapSection(opts.nextSection) : section;
-  const nextEnergy = sectionEnergy(nextSection);
-  const euclidSteps = opts.euclideanKick?.steps ?? 16;
-  const euclidKick = opts.euclideanKick ? euclideanRhythm(opts.euclideanKick.pulses, euclidSteps, opts.euclideanKick.rotation ?? 0) : void 0;
-  const reuseSectionKick = (section === "b" || section === "chorus") && style !== "sparse";
-  let sectionKick;
-  for (let bar = 0; bar < opts.bars; bar += 1) {
-    const barStart = bar * 4;
-    const isLastBar = bar === opts.bars - 1;
-    if (bar === 0 && section === "chorus") {
-      track.add(GM.CRASH, barStart, 0.5, 100 * densityMult);
-    }
-    let barHasOpenHh = false;
-    let openHhBeatIndex = 3;
-    if (ohhBarInterval > 0 && bar % ohhBarInterval === ohhBarInterval - 1) {
-      openHhBeatIndex = openHiHatBeat(section, rng);
-      barHasOpenHh = !track.hasCrashNear(barStart + openHhBeatIndex);
-    }
-    let kick;
-    if (!euclidKick && reuseSectionKick) {
-      sectionKick ??= getKickPattern(section, style, 0, rng);
-      kick = sectionKick;
-    } else if (!euclidKick) {
-      kick = getKickPattern(section, style, bar, rng);
-    }
-    const inLift = isInPreChorusLift(section, bar, opts.bars, section === "b");
-    let currentFill = "snareRoll";
-    for (let beat = 0; beat < 4; beat += 1) {
-      const beatTick = barStart + beat;
-      const velocity = calculateVelocity(section, beat);
-      if (opts.fills && isLastBar && !inLift && beat >= fillStartBeat) {
-        if (beat === fillStartBeat) {
-          currentFill = selectFillType(section, nextSection, style, nextEnergy, rng);
-        }
-        if (playMainVoices) {
-          const before = track.hits.length;
-          generateFill(track, beatTick, beat, currentFill, velocity);
-          if (track.hits.length > before) {
-            continue;
-          }
-        } else {
-          continue;
-        }
-      }
-      const ctx = {
-        track,
-        beatTick,
-        beat,
-        velocity,
-        section,
-        bpm: opts.bpm,
-        bar,
-        sectionBars: opts.bars,
-        inPrechorusLift: inLift,
-        swingAmount,
-        barHasOpenHh,
-        openHhBeat: openHhBeatIndex,
-        rng
-      };
-      if (playMainVoices) {
-        if (inLift) {
-          generatePreChorusBuildup(ctx, sec, isLastBar);
-        }
-        if (euclidKick && !inLift) {
-          const stepLength = 4 / euclidSteps;
-          for (let step = 0; step < euclidKick.length; step += 1) {
-            const onset = step * stepLength;
-            if (euclidKick[step] && Math.floor(onset) === beat) {
-              const wholeBeat = Math.abs(onset - Math.round(onset)) < 1e-9;
-              track.add(
-                GM.BD,
-                barStart + onset,
-                Math.min(0.5, stepLength),
-                velocity * (wholeBeat ? 1 : 0.85)
-              );
-            }
-          }
-        } else if (kick) {
-          generateKickForBeat(ctx, sec, kick);
-        }
-        generateSnareForBeat(ctx, sec, section === "intro" && bar === 0);
-        if (sec.useGhostNotes && !inLift) {
-          generateGhostNotesForBeat(ctx, sec);
-        }
-      }
-      generateHiHatForBeat(ctx, sec);
-    }
-    if (sec.useFootHh && shouldPlayHiHat(role)) {
-      for (let fhhBeat = 0; fhhBeat < 4; fhhBeat += 2) {
-        const fhhTick = barStart + fhhBeat;
-        const occupied = track.hits.some((h) => h.pitch === GM.FHH && h.startBeat === fhhTick);
-        if (!occupied) {
-          track.add(GM.FHH, fhhTick, 0.5, footHiHatVelocity(rng));
-        }
-      }
-    }
-    let percussionConfig = getPercussionConfig(percMood, section);
-    if (role === "fxOnly" && !percussionConfig.tambourine && !percussionConfig.shaker && !percussionConfig.handclap) {
-      percussionConfig = {
-        tambourine: false,
-        shaker: true,
-        handclap: false,
-        shaker16th: false
-      };
-    }
-    generateAuxPercussionForBar(
-      track,
-      barStart,
-      percussionConfig,
-      role,
-      densityMult,
-      rng,
-      opts.bpm
-    );
-  }
-  return track.hits;
-}
 
-// src/generate/groove/index.ts
-var DEFAULT_TS3 = { numerator: 4, denominator: 4 };
-var DEFAULT_TIMING = 0.02;
-var DEFAULT_VELOCITY_JITTER = 8;
-var DEFAULT_ACCENT = 12;
-var DEFAULT_BASE_VELOCITY = 80;
-var MAX_METRIC_WEIGHT = 3;
-var MIN_VELOCITY = 1;
-var MAX_VELOCITY = 127;
-function humanize(events, opts = {}) {
-  const ts = opts.ts ?? DEFAULT_TS3;
-  assertTimeSignature(ts);
-  assertNoteEvents(events, "humanize events");
-  const timing = opts.timing ?? DEFAULT_TIMING;
-  const velocityJitter = opts.velocity ?? DEFAULT_VELOCITY_JITTER;
-  const accent = opts.accent ?? DEFAULT_ACCENT;
-  const baseVelocity = opts.baseVelocity ?? DEFAULT_BASE_VELOCITY;
-  assertRange(timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
-  assertRange(velocityJitter, 0, 127, "humanize velocity jitter");
-  assertRange(accent, 0, 127, "humanize accent");
-  assertRange(baseVelocity, 0, 127, "humanize base velocity");
-  const rng = createRng(opts.seed ?? 0);
-  return events.map((event) => {
-    const timingOffset = rng.float(-timing, timing);
-    const startBeat = Math.max(0, event.startBeat + timingOffset);
-    const weight = metricWeight(event.startBeat, ts);
-    const accentBoost = weight / MAX_METRIC_WEIGHT * accent;
-    const velocityOffset = rng.float(-velocityJitter, velocityJitter);
-    const rawVelocity = (event.velocity ?? baseVelocity) + accentBoost + velocityOffset;
-    const velocity = Math.min(MAX_VELOCITY, Math.max(MIN_VELOCITY, Math.round(rawVelocity)));
-    return {
-      pitch: event.pitch,
-      startBeat,
-      durationBeat: event.durationBeat,
-      velocity
-    };
-  });
-}
-function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
-  const barIndex = Math.floor(beat / barBeats);
-  const modBeat = beat - barIndex * barBeats;
-  let slotIndex = Math.round(modBeat * subdivision);
-  let effectiveBarIndex = barIndex;
-  if (slotIndex >= slotsPerBar) {
-    slotIndex = 0;
-    effectiveBarIndex += 1;
-  }
-  return {
-    quantizedBeat: effectiveBarIndex * barBeats + slotIndex / subdivision,
-    slotIndex
-  };
-}
-function extractGrooveTemplate(events, ts, subdivision) {
-  assertTimeSignature(ts);
-  assertNoteEvents(events, "groove source events");
-  assertPositiveInt(subdivision, "groove subdivision");
-  const barBeats = beatsPerBar(ts);
-  const slotsPerBar = Math.round(barBeats * subdivision);
-  assertGenerationBudget(slotsPerBar, "groove template slots");
-  const offsetSums = new Array(slotsPerBar).fill(0);
-  const velocitySums = new Array(slotsPerBar).fill(0);
-  const counts = new Array(slotsPerBar).fill(0);
-  const velocityCounts = new Array(slotsPerBar).fill(0);
-  for (const event of events) {
-    const { quantizedBeat, slotIndex } = quantizeToGrid(
-      event.startBeat,
-      barBeats,
-      subdivision,
-      slotsPerBar
-    );
-    offsetSums[slotIndex] = (offsetSums[slotIndex] ?? 0) + (event.startBeat - quantizedBeat);
-    counts[slotIndex] = (counts[slotIndex] ?? 0) + 1;
-    if (event.velocity !== void 0) {
-      velocitySums[slotIndex] = (velocitySums[slotIndex] ?? 0) + event.velocity;
-      velocityCounts[slotIndex] = (velocityCounts[slotIndex] ?? 0) + 1;
-    }
-  }
-  const slots = [];
-  for (let i = 0; i < slotsPerBar; i += 1) {
-    const count = counts[i] ?? 0;
-    if (count === 0) {
-      slots.push({ timingOffset: 0, velocity: null });
-      continue;
-    }
-    const velocityCount = velocityCounts[i] ?? 0;
-    slots.push({
-      timingOffset: (offsetSums[i] ?? 0) / count,
-      velocity: velocityCount > 0 ? (velocitySums[i] ?? 0) / velocityCount : null
-    });
-  }
-  return { subdivision, slotsPerBar, slots, ts };
-}
-function applyGrooveTemplate(events, template, ts) {
-  assertTimeSignature(ts);
-  assertNoteEvents(events, "groove target events");
-  assertPositiveInt(template.subdivision, "template subdivision");
-  assertPositiveInt(template.slotsPerBar, "template slotsPerBar");
-  assertGenerationBudget(template.slots.length, "template slots");
-  if (template.slots.length !== template.slotsPerBar) {
-    throw new RangeError("template slots length must equal slotsPerBar");
-  }
-  if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
-    throw new Error(
-      `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(ts)}`
-    );
-  }
-  const barBeats = beatsPerBar(ts);
-  return events.map((event) => {
-    const { quantizedBeat, slotIndex } = quantizeToGrid(
-      event.startBeat,
-      barBeats,
-      template.subdivision,
-      template.slotsPerBar
-    );
-    const slot = template.slots[slotIndex];
-    const startBeat = quantizedBeat + (slot?.timingOffset ?? 0);
-    const velocity = slot && slot.velocity !== null && slot.velocity !== void 0 ? Math.round(slot.velocity) : event.velocity;
-    return {
-      pitch: event.pitch,
-      startBeat,
-      durationBeat: event.durationBeat,
-      velocity
-    };
-  });
-}
 
-// src/analyze/functional/internal.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
-function isNeapolitan(chord, key) {
-  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === "maj";
-}
+var _chunk357ZDPVUcjs = require('../chunk-357ZDPVU.cjs');
+require('../chunk-KQN2ZYND.cjs');
+require('../chunk-YFJXS3AU.cjs');
+require('../chunk-WFDXOLUB.cjs');
+require('../chunk-BSLTLGM3.cjs');
+require('../chunk-PI3UXRWK.cjs');
 
-// src/analyze/functional/roman.ts
-var ROMAN = ["I", "II", "III", "IV", "V", "VI", "VII"];
-var OFFSET_SPELLING = [
-  [1, ""],
-  [2, "b"],
-  [2, ""],
-  [3, "b"],
-  [3, ""],
-  [4, ""],
-  [4, "#"],
-  [5, ""],
-  [6, "b"],
-  [6, ""],
-  [7, "b"],
-  [7, ""]
-];
-var ROMAN_STYLE = {
-  maj: { lower: false, suffix: "" },
-  min: { lower: true, suffix: "" },
-  dim: { lower: true, suffix: "o" },
-  aug: { lower: false, suffix: "+" },
-  maj7: { lower: false, suffix: "maj7" },
-  min7: { lower: true, suffix: "7" },
-  dom7: { lower: false, suffix: "7" },
-  dim7: { lower: true, suffix: "o7" },
-  m7b5: { lower: true, suffix: "\xF87" },
-  minMaj7: { lower: true, suffix: "maj7" },
-  aug7: { lower: false, suffix: "+7" },
-  augMaj7: { lower: false, suffix: "+maj7" },
-  majb5: { lower: false, suffix: "b5" },
-  "6": { lower: false, suffix: "add6" },
-  min6: { lower: true, suffix: "add6" },
-  "6/9": { lower: false, suffix: "69" },
-  sus2: { lower: false, suffix: "sus2" },
-  sus4: { lower: false, suffix: "sus4" },
-  add9: { lower: false, suffix: "add9" },
-  add11: { lower: false, suffix: "add11" },
-  maj9: { lower: false, suffix: "maj9" },
-  min9: { lower: true, suffix: "9" },
-  dom9: { lower: false, suffix: "9" },
-  "7b9": { lower: false, suffix: "7b9" },
-  "7#9": { lower: false, suffix: "7#9" },
-  "7#11": { lower: false, suffix: "7#11" },
-  "7b13": { lower: false, suffix: "7b13" },
-  "11": { lower: false, suffix: "11" },
-  "13": { lower: false, suffix: "13" },
-  "5": { lower: false, suffix: "5" }
-};
-var SUFFIX_QUALITY = new Map(
-  Object.entries(ROMAN_STYLE).map(
-    ([quality, style]) => [`${style.lower ? "l" : "u"}:${style.suffix}`, quality]
-  )
-);
-function romanStyle(quality) {
-  return ROMAN_STYLE[quality];
-}
-function romanSpelling(rootPc, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const diatonic = tones.indexOf(mod12(rootPc));
-  if (diatonic >= 0) {
-    return { degreeNumber: diatonic + 1, accidental: "" };
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    const degreeNumber2 = i + 1;
-    if (degreeNumber2 === 1 || degreeNumber2 === 5) {
-      continue;
-    }
-    if (mod12((tones[i] ?? 0) - 1) === mod12(rootPc)) {
-      return { degreeNumber: degreeNumber2, accidental: "b" };
-    }
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    if (mod12((tones[i] ?? 0) + 1) === mod12(rootPc)) {
-      return { degreeNumber: i + 1, accidental: "#" };
-    }
-  }
-  const [degreeNumber, accidental] = OFFSET_SPELLING[mod12(rootPc - key.rootPc)] ?? [1, ""];
-  return { degreeNumber, accidental };
-}
-function baseMarker(quality) {
-  if (quality === "dim" || quality === "dim7") {
-    return "o";
-  }
-  if (quality === "m7b5") {
-    return "\xF8";
-  }
-  if (quality === "aug" || quality === "aug7") {
-    return "+";
-  }
-  if (quality === "augMaj7") {
-    return "+maj7";
-  }
-  if (quality === "maj7" || quality === "minMaj7") {
-    return "maj7";
-  }
-  return "";
-}
-var TRIAD_FIGURES = { 1: "6", 2: "64" };
-var SEVENTH_FIGURES = { 1: "65", 2: "43", 3: "42" };
-var TRIAD_FIGURE_QUALITIES = /* @__PURE__ */ new Set(["maj", "min", "dim", "aug"]);
-var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
-  "maj7",
-  "min7",
-  "dom7",
-  "dim7",
-  "m7b5",
-  "minMaj7",
-  "aug7",
-  "augMaj7"
-]);
-function chordToRoman(chord, key) {
-  const { degreeNumber, accidental } = romanSpelling(chord.rootPc, key);
-  const { lower, suffix } = romanStyle(chord.quality);
-  const numeral = ROMAN[degreeNumber - 1] ?? "I";
-  const cased = lower ? numeral.toLowerCase() : numeral;
-  let inversion = 0;
-  if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => mod12(chord.rootPc + iv) === chord.bassPc);
-    if (idx > 0) {
-      inversion = idx;
-    }
-  }
-  if (inversion > 0) {
-    const figure = SEVENTH_FIGURE_QUALITIES.has(chord.quality) ? SEVENTH_FIGURES[inversion] : TRIAD_FIGURE_QUALITIES.has(chord.quality) ? TRIAD_FIGURES[inversion] : void 0;
-    if (figure !== void 0) {
-      return `${accidental}${cased}${baseMarker(chord.quality)}${figure}`;
-    }
-  }
-  return `${accidental}${cased}${suffix}`;
-}
 
-// src/analyze/functional/function.ts
-var FUNCTION_BY_OFFSET = [
-  "tonic",
-  // 0  I
-  "subdominant",
-  // 1  bII (Neapolitan)
-  "subdominant",
-  // 2  ii
-  "tonic",
-  // 3  bIII
-  "tonic",
-  // 4  iii
-  "subdominant",
-  // 5  IV
-  "dominant",
-  // 6  #IV / bV
-  "dominant",
-  // 7  V
-  "subdominant",
-  // 8  bVI
-  "tonic",
-  // 9  vi
-  "subdominant",
-  // 10 bVII
-  "dominant"
-  // 11 vii
-];
-function isMinorKey(key) {
-  const hasMinorThird = key.modeMask12 >> 3 & 1;
-  const hasMajorThird = key.modeMask12 >> 4 & 1;
-  return Boolean(hasMinorThird) && !hasMajorThird;
-}
-function functionOf(chord, key) {
-  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? "tonic";
-}
-function isDiatonic(chord, key) {
-  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
-}
-function parallelKey(key) {
-  return {
-    rootPc: mod12(key.rootPc),
-    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK
-  };
-}
 
-// src/analyze/functional/borrowed.ts
-function isHarmonicMinorAlteration(chord, key) {
-  return isMinorKey(key) && isDiatonic(chord, { rootPc: mod12(key.rootPc), modeMask12: HARMONIC_MINOR_MASK });
-}
-function isBorrowedChord(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return false;
-  }
-  if (isHarmonicMinorAlteration(chord, key)) {
-    return false;
-  }
-  return isDiatonic(chord, parallelKey(key));
-}
-function borrowedSource(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return null;
-  }
-  if (isNeapolitan(chord, key)) {
-    return "neapolitan";
-  }
-  if (isBorrowedChord(chord, key)) {
-    return isMinorKey(key) ? "parallel-major" : "parallel-minor";
-  }
-  return null;
-}
 
-// src/theory/harmony/index.ts
-function roleOf(pitch, chord, chordId = 0) {
-  const interval = ((Math.trunc(pitch) - chord.rootPc) % 12 + 12) % 12;
-  const tones = new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
-  const hasThird = tones.has(3) || tones.has(4);
-  const isSuspendedTone = !hasThird && (interval === 5 && tones.has(5) || interval === 2 && tones.has(2));
-  const chordRole = chordToneRole(pitch, chord);
-  let role;
-  let lock;
-  if (isSuspendedTone) {
-    role = "third";
-    lock = "quality";
-  } else if (chordRole !== null) {
-    role = chordRole;
-    lock = chordRole === "root" ? "identity" : chordRole === "third" ? "quality" : "voicing";
-  } else {
-    role = "tension";
-    lock = "voicing";
-  }
-  return { role, lock, belongsToChordId: chordId };
-}
 
-// src/generate/harmonize/index.ts
-var FALLBACK = { rootPc: 0, quality: "maj", secondaryDominant: false, base: 0 };
-var DEFAULT_METER = { numerator: 4, denominator: 4 };
-var COMFORT_LOW = 55;
-var COMFORT_HIGH = 79;
-var TESSITURA_WEIGHT = 1e-3;
-var TIE_BREAK_JITTER = 1e-6;
-function pitchClass5(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function inferKey(melody) {
-  let best = majorKey(0);
-  let bestScore = Number.NEGATIVE_INFINITY;
-  const candidates = [];
-  for (let tonic = 0; tonic < 12; tonic += 1) {
-    candidates.push(majorKey(tonic), minorKey(tonic));
-  }
-  for (const key of candidates) {
-    const tonic = pitchClass5(key.rootPc);
-    const isMinor = key.modeMask12 === NATURAL_MINOR_MASK;
-    const leadingTone = (tonic + 11) % 12;
-    let score = 0;
-    for (const n of melody) {
-      const w = Math.max(0.25, n.durationBeat);
-      const pc = pitchClass5(n.pitch);
-      if (isScaleTone(n.pitch, key) || isMinor && pc === leadingTone) {
-        score += w;
-      }
-      if (pc === tonic) {
-        score += 0.5 * w;
-      }
-    }
-    if (score > bestScore) {
-      bestScore = score;
-      best = key;
-    }
-  }
-  return best;
-}
-function buildCandidates(key, reharmonize) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const candidates = tones.map((rootPc, degree) => ({
-    rootPc,
-    quality: diatonicTriad(degree, key).quality,
-    degree,
-    secondaryDominant: false,
-    base: 0
-  }));
-  if (reharmonize !== "diatonic") {
-    for (const target of [1, 3, 4, 5]) {
-      const targetRoot = tones[target] ?? 0;
-      candidates.push({
-        rootPc: (targetRoot + 7) % 12,
-        quality: "dom7",
-        secondaryDominant: true,
-        targetDegree: target,
-        base: 1.5
-      });
-    }
-  }
-  if (reharmonize === "borrowed") {
-    const parallel = parallelKey(key);
-    const parallelTones = scaleTonesInDegreeOrder(parallel);
-    for (let degree = 0; degree < parallelTones.length; degree += 1) {
-      const chord = diatonicTriad(degree, parallel);
-      if (!isDiatonic(chord, key)) {
-        candidates.push({
-          rootPc: chord.rootPc,
-          quality: chord.quality,
-          secondaryDominant: false,
-          base: 1.25
-        });
-      }
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return candidates.filter((candidate) => {
-    const id = `${candidate.rootPc}:${candidate.quality}`;
-    if (seen.has(id)) {
-      return false;
-    }
-    seen.add(id);
-    return true;
-  });
-}
-function emissionCost(seg, cand, melody, key) {
-  const pcs = chordPitchClasses(makeChord(cand.rootPc, cand.quality));
-  let cost = cand.base;
-  for (const idx of seg.noteIndices) {
-    const note = melody[idx];
-    if (!note) {
-      continue;
-    }
-    const overlapStart = Math.max(note.startBeat, seg.startBeat);
-    const overlap = Math.min(note.startBeat + note.durationBeat, seg.endBeat) - overlapStart;
-    if (overlap <= 0) {
-      continue;
-    }
-    const w = Math.max(0.25, overlap);
-    if (pcs.includes(pitchClass5(note.pitch))) {
-      continue;
-    }
-    const strong = isStrongBeat(overlapStart, DEFAULT_METER);
-    cost += (strong ? 10 : 2) * w;
-    if (!isScaleTone(note.pitch, key)) {
-      cost += w;
-    }
-  }
-  return cost;
-}
-function tessituraCost(melody) {
-  let cost = 0;
-  for (const n of melody) {
-    if (n.pitch < COMFORT_LOW) {
-      cost += (COMFORT_LOW - n.pitch) * TESSITURA_WEIGHT;
-    } else if (n.pitch > COMFORT_HIGH) {
-      cost += (n.pitch - COMFORT_HIGH) * TESSITURA_WEIGHT;
-    }
-  }
-  return cost;
-}
-function transitionCost(prev, cur, tonicPc) {
-  let cost = 0;
-  if ((prev.rootPc - cur.rootPc + 12) % 12 === 7) {
-    cost -= 2;
-  }
-  if (prev.rootPc === (tonicPc + 7) % 12 && (prev.quality === "maj" || prev.quality === "dom7") && cur.rootPc === tonicPc) {
-    cost -= 3;
-  }
-  if (prev.secondaryDominant) {
-    cost += cur.degree === prev.targetDegree ? -3 : 2;
-  }
-  const dist = Math.min((prev.rootPc - cur.rootPc + 12) % 12, (cur.rootPc - prev.rootPc + 12) % 12);
-  cost += dist * 0.3;
-  return cost;
-}
-function harmonizeOnce(melody, key, candidates, segments, jitter) {
-  const tonicPc = pitchClass5(key.rootPc);
-  const n = candidates.length;
-  const candAt = (i) => candidates[i] ?? FALLBACK;
-  const seg0 = segments[0];
-  let dp = candidates.map(
-    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key) : 0) + (jitter[ci] ?? 0)
-  );
-  const back = [];
-  for (let s = 1; s < segments.length; s += 1) {
-    const seg = segments[s];
-    if (!seg) {
-      continue;
-    }
-    const next = [];
-    const ptr = [];
-    for (let c = 0; c < n; c += 1) {
-      let best = Number.POSITIVE_INFINITY;
-      let bestPrev = 0;
-      for (let p = 0; p < n; p += 1) {
-        const cost = (dp[p] ?? Number.POSITIVE_INFINITY) + transitionCost(candAt(p), candAt(c), tonicPc);
-        if (cost < best) {
-          best = cost;
-          bestPrev = p;
-        }
-      }
-      next[c] = best + emissionCost(seg, candAt(c), melody, key) + (jitter[c] ?? 0);
-      ptr[c] = bestPrev;
-    }
-    dp = next;
-    back.push(ptr);
-  }
-  let bestCost = Number.POSITIVE_INFINITY;
-  let bestEnd = 0;
-  for (let c = 0; c < n; c += 1) {
-    const cadence = candAt(c).rootPc === tonicPc ? -2 : 0;
-    const total = (dp[c] ?? Number.POSITIVE_INFINITY) + cadence;
-    if (total < bestCost) {
-      bestCost = total;
-      bestEnd = c;
-    }
-  }
-  const path = new Array(segments.length).fill(bestEnd);
-  for (let s = segments.length - 2; s >= 0; s -= 1) {
-    const ptr = back[s];
-    const nextIdx = path[s + 1] ?? bestEnd;
-    path[s] = ptr ? ptr[nextIdx] ?? bestEnd : bestEnd;
-  }
-  return { cost: bestCost, path };
-}
-function harmonizeMelody(opts) {
-  const noteIndex = createNoteEventIndex(opts.melody);
-  const key = opts.key === "infer" ? inferKey(opts.melody) : opts.key;
-  const candidates = buildCandidates(key, opts.reharmonize);
-  const candAt = (i) => candidates[i] ?? FALLBACK;
-  const rng = createRng(opts.seed ?? 0);
-  const jitter = candidates.map(() => rng.next() * TIE_BREAK_JITTER);
-  const melodyEnd = noteIndex.notes.reduce((m, n) => Math.max(m, n.endBeat), 0);
-  const requestedHr = assertRange(
-    opts.harmonicRhythm,
-    Number.MIN_VALUE,
-    Number.MAX_SAFE_INTEGER,
-    "harmonic rhythm"
-  );
-  const hr = Math.max(0.25, requestedHr);
-  const segCount = Math.max(1, Math.ceil(melodyEnd / hr));
-  assertGenerationBudget(segCount, "harmonic segments");
-  assertGenerationBudget(segCount * candidates.length * candidates.length, "harmonization search");
-  const segments = Array.from({ length: segCount }, (_, s) => ({
-    startBeat: s * hr,
-    endBeat: (s + 1) * hr,
-    noteIndices: []
-  }));
-  let memberships = 0;
-  for (const indexed of noteIndex.notes) {
-    const first = Math.max(0, Math.floor(indexed.note.startBeat / hr));
-    const lastExclusive = Math.min(segCount, Math.ceil(indexed.endBeat / hr - Number.EPSILON));
-    memberships += Math.max(0, lastExclusive - first);
-    assertGenerationBudget(memberships, "note-to-segment memberships");
-    for (let segment = first; segment < lastExclusive; segment += 1) {
-      segments[segment]?.noteIndices.push(indexed.originalIndex);
-    }
-  }
-  const transposes = [0];
-  if (opts.placement.transposeSearch) {
-    for (let s = -6; s <= 6; s += 1) {
-      if (s !== 0) {
-        transposes.push(s);
-      }
-    }
-  }
-  if (opts.placement.octaveSearch) {
-    for (const o of [-12, 12]) {
-      if (!transposes.includes(o)) {
-        transposes.push(o);
-      }
-    }
-  }
-  let bestCost = Number.POSITIVE_INFINITY;
-  let bestTs = 0;
-  let bestPath = [];
-  let bestMelody = opts.melody;
-  for (const ts of transposes) {
-    const shifted = opts.melody.map((n) => ({ ...n, pitch: n.pitch + ts }));
-    const { cost, path } = harmonizeOnce(shifted, key, candidates, segments, jitter);
-    const total = cost + tessituraCost(shifted);
-    if (total < bestCost) {
-      bestCost = total;
-      bestTs = ts;
-      bestPath = path;
-      bestMelody = shifted;
-    }
-  }
-  const chords = bestPath.map((ci, s) => {
-    const cand = candAt(ci);
-    const chord = {
-      rootPc: cand.rootPc,
-      quality: cand.quality,
-      startBeat: segments[s]?.startBeat ?? s * hr
-    };
-    if (cand.degree !== void 0) {
-      chord.degree = cand.degree;
-    }
-    if (cand.secondaryDominant) {
-      chord.secondaryDominant = true;
-    }
-    return chord;
-  });
-  const melodyRoles = bestMelody.map((note, noteIndex2) => {
-    const segIdx = Math.min(segments.length - 1, Math.max(0, Math.floor(note.startBeat / hr)));
-    const cand = candAt(bestPath[segIdx] ?? 0);
-    const chord = makeChord(cand.rootPc, cand.quality);
-    return { noteIndex: noteIndex2, role: roleOf(note.pitch, chord).role };
-  });
-  return { transposeSemitones: bestTs, key, chords, melodyRoles };
-}
 
-// src/generate/motif/index.ts
-function pitchClass6(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-var MIN_TILE_SPAN = 1 / 256;
-function upScaleTone(pitch, key) {
-  for (let d = 1; d <= 12; d += 1) {
-    if (isScaleTone(pitch + d, key)) {
-      return pitch + d;
-    }
-  }
-  return pitch + 12;
-}
-function downScaleTone(pitch, key) {
-  for (let d = 1; d <= 12; d += 1) {
-    if (isScaleTone(pitch - d, key)) {
-      return pitch - d;
-    }
-  }
-  return pitch - 12;
-}
-function stepDiatonic(pitch, degrees, key) {
-  let p = nearestScaleTone(pitch, key);
-  const steps = Math.abs(Math.trunc(degrees));
-  for (let i = 0; i < steps; i += 1) {
-    p = degrees >= 0 ? upScaleTone(p, key) : downScaleTone(p, key);
-  }
-  return p;
-}
-function nearestChordTone(pitch, chord) {
-  const pcs = chordPitchClasses(chord);
-  for (let d = 0; d <= 12; d += 1) {
-    if (pcs.includes(pitchClass6(pitch - d))) {
-      return pitch - d;
-    }
-    if (pcs.includes(pitchClass6(pitch + d))) {
-      return pitch + d;
-    }
-  }
-  return pitch;
-}
-function cellOrigin(notes) {
-  let origin = Number.POSITIVE_INFINITY;
-  for (const note of notes) {
-    origin = Math.min(origin, note.startBeat);
-  }
-  return Number.isFinite(origin) ? origin : 0;
-}
-function cellEnd(notes) {
-  let end = Number.NEGATIVE_INFINITY;
-  for (const note of notes) {
-    end = Math.max(end, note.startBeat + note.durationBeat);
-  }
-  return Number.isFinite(end) ? end : 0;
-}
-function cellSpan(cell) {
-  if (cell.notes.length === 0) {
-    return 0;
-  }
-  const start = cellOrigin(cell.notes);
-  const end = cellEnd(cell.notes);
-  return end - start;
-}
-function clone(cell) {
-  return { notes: cell.notes.map((n) => ({ ...n })) };
-}
-function contourOffsets(contour, count) {
-  const offsets = [];
-  for (let i = 0; i < count; i += 1) {
-    switch (contour) {
-      case "ascending":
-        offsets.push(i);
-        break;
-      case "descending":
-        offsets.push(-i);
-        break;
-      case "arch":
-        offsets.push(Math.min(i, count - 1 - i));
-        break;
-      case "wave":
-        offsets.push([0, 1, 0, -1][i % 4] ?? 0);
-        break;
-    }
-  }
-  return offsets;
-}
-function generateMotif(opts) {
-  const contour = opts.contour ?? "arch";
-  const bars = assertPositiveInt(opts.bars, "motif bars");
-  const totalBeats = bars * 4;
-  const noteCount = Math.max(3, bars * 2);
-  assertGenerationBudget(noteCount, "motif notes");
-  const beatsPerNote = totalBeats / noteCount;
-  const rng = createRng(opts.seed ?? 0);
-  const requestedJitter = assertFiniteNumber(opts.jitter ?? 0, "motif jitter");
-  const jitterProb = Math.min(1, Math.max(0, requestedJitter));
-  const tonic = pitchClass6(opts.key.rootPc) + 60;
-  const offsets = contourOffsets(contour, noteCount);
-  const notes = [];
-  for (let i = 0; i < noteCount; i += 1) {
-    let jitter = 0;
-    if (jitterProb > 0 && rng.next() < jitterProb) {
-      jitter = rng.next() < 0.5 ? 1 : -1;
-    }
-    let pitch = stepDiatonic(tonic, (offsets[i] ?? 0) + jitter, opts.key);
-    const startBeat = i * beatsPerNote;
-    if (opts.chord && startBeat % 4 === 0) {
-      pitch = nearestChordTone(pitch, opts.chord);
-    }
-    notes.push({ pitch, startBeat, durationBeat: beatsPerNote });
-  }
-  return { notes };
-}
-function transformMotif(cell, t, amount, key) {
-  assertNoteEvents(cell.notes, "motif notes");
-  if (amount !== void 0) {
-    assertFiniteNumber(amount, "motif transform amount");
-  }
-  if ((t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
-    assertInteger(amount, "diatonic transform amount");
-  }
-  if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
-    throw new RangeError("time transform amount must be positive");
-  }
-  const notes = cell.notes;
-  switch (t) {
-    case "transposeChromatic": {
-      const semis = amount ?? 0;
-      return { notes: notes.map((n) => ({ ...n, pitch: n.pitch + semis })) };
-    }
-    case "transposeDiatonic": {
-      const degrees = amount ?? 1;
-      return {
-        notes: notes.map((n) => ({
-          ...n,
-          // With a key, shift by scale degrees; without one, fall back to a
-          // chromatic shift of `degrees` semitones.
-          pitch: key ? stepDiatonic(n.pitch, degrees, key) : n.pitch + degrees
-        }))
-      };
-    }
-    case "invert": {
-      const pivot = notes[0]?.pitch ?? 0;
-      return { notes: notes.map((n) => ({ ...n, pitch: 2 * pivot - n.pitch })) };
-    }
-    case "retrograde": {
-      if (notes.length === 0) {
-        return { notes: [] };
-      }
-      const start = cellOrigin(notes);
-      const end = cellEnd(notes);
-      return {
-        notes: notes.map((n) => ({
-          pitch: n.pitch,
-          startBeat: start + (end - (n.startBeat + n.durationBeat)),
-          durationBeat: n.durationBeat
-        }))
-      };
-    }
-    case "augment":
-      return scaleTime(cell, amount ?? 2);
-    case "diminish":
-      return scaleTime(cell, 1 / (amount ?? 2));
-    case "sequence": {
-      const degrees = amount ?? 2;
-      const span = cellSpan(cell);
-      const copy = transformMotif(cell, "transposeDiatonic", degrees, key);
-      const shifted = copy.notes.map((n) => ({ ...n, startBeat: n.startBeat + span }));
-      return { notes: [...clone(cell).notes, ...shifted] };
-    }
-  }
-}
-function scaleTime(cell, factor) {
-  const origin = cellOrigin(cell.notes);
-  return {
-    notes: cell.notes.map((n) => ({
-      pitch: n.pitch,
-      startBeat: origin + (n.startBeat - origin) * factor,
-      durationBeat: n.durationBeat * factor
-    }))
-  };
-}
-function developMotif(cell, timeline, key, bars) {
-  assertPositiveInt(bars, "development bars");
-  assertNoteEvents(cell.notes, "motif notes");
-  const span = cellSpan(cell);
-  const totalBeats = bars * 4;
-  const origin = cellOrigin(cell.notes);
-  const out = [];
-  if (span <= 0) {
-    return clone(cell);
-  }
-  const tileSpan = Math.max(span, MIN_TILE_SPAN);
-  const tileCount = Math.ceil(totalBeats / tileSpan);
-  assertGenerationBudget(tileCount * cell.notes.length, "developed motif notes");
-  for (let k = 0; k < tileCount; k += 1) {
-    const offset = k * tileSpan;
-    for (const n of cell.notes) {
-      const startBeat = offset + (n.startBeat - origin);
-      if (startBeat >= totalBeats) {
-        continue;
-      }
-      const chord = timeline.at(startBeat);
-      let pitch = n.pitch;
-      if (chord) {
-        const isMember = chordPitchClasses(chord).includes(pitchClass6(pitch));
-        pitch = isMember ? pitch : nearestChordTone(pitch, chord);
-      } else {
-        pitch = nearestScaleTone(pitch, key);
-      }
-      out.push({ pitch, startBeat, durationBeat: n.durationBeat });
-    }
-  }
-  return { notes: out };
-}
 
-// src/generate/progression/index.ts
-var PRESETS = [
-  {
-    id: "fourChordPop",
-    name: "Four Chord Pop",
-    degrees: [0, 4, 5, 3],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "pop1",
-    name: "Pop 1",
-    degrees: [0, 5, 3, 4],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "axis",
-    name: "Axis",
-    degrees: [5, 3, 0, 4],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol", "rock"]
-  },
-  {
-    id: "pop2",
-    name: "Pop 2",
-    degrees: [3, 0, 4, 5],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "classic",
-    name: "Classic",
-    degrees: [0, 3, 4, 0],
-    functional: "cadenceStrong",
-    styles: ["dance", "idol", "rock"]
-  },
-  {
-    id: "pop3",
-    name: "Pop 3",
-    degrees: [0, 3, 5, 4],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "royalRoad",
-    name: "Royal Road",
-    degrees: [3, 4, 2, 5],
-    functional: "tensionBuild",
-    styles: ["dance", "idol"]
-  },
-  {
-    id: "minor1",
-    name: "Minor 1",
-    degrees: [5, 4, 3, 4],
-    functional: "tensionBuild",
-    styles: ["idol", "rock"]
-  },
-  {
-    id: "minor2",
-    name: "Minor 2",
-    degrees: [5, 3, 4, 0],
-    functional: "tensionBuild",
-    styles: ["idol", "rock"]
-  },
-  {
-    id: "pop4",
-    name: "Pop 4",
-    degrees: [0, 4, 2, 3],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "pop5",
-    name: "Pop 5",
-    degrees: [0, 2, 3, 4],
-    functional: "stable",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "rock1",
-    name: "Rock 1",
-    degrees: [0, 10, 3, 0],
-    functional: "tensionBuild",
-    styles: ["rock"]
-  },
-  {
-    id: "rock2",
-    name: "Rock 2",
-    degrees: [0, 3, 10, 0],
-    functional: "tensionBuild",
-    styles: ["rock"]
-  },
-  {
-    id: "extended4",
-    name: "Extended 4",
-    degrees: [0, 4, 5, 2],
-    functional: "stable",
-    styles: ["minimal", "dance"]
-  },
-  {
-    id: "minor3",
-    name: "Minor 3",
-    degrees: [5, 0, 4, 3],
-    functional: "loop",
-    styles: ["dance", "idol"]
-  },
-  {
-    id: "aeolianPop",
-    name: "Aeolian Pop",
-    degrees: [5, 8, 10, 0],
-    functional: "tensionBuild",
-    styles: ["minimal", "dance", "idol", "rock"]
-  },
-  {
-    id: "animeHighEnergy1",
-    name: "Anime High Energy 1",
-    degrees: [5, 2, 3, 0],
-    functional: "loop",
-    styles: ["dance", "idol"]
-  },
-  {
-    id: "jazzPop",
-    name: "Jazz Pop",
-    degrees: [1, 4, 0, 5],
-    functional: "cadenceStrong",
-    styles: ["minimal", "dance"]
-  },
-  {
-    id: "animeHighEnergy2",
-    name: "Anime High Energy 2",
-    degrees: [5, 1, 4, 0],
-    functional: "cadenceStrong",
-    styles: ["dance", "idol"]
-  },
-  {
-    id: "cityPop",
-    name: "City Pop",
-    degrees: [0, 5, 1, 4],
-    functional: "stable",
-    styles: ["minimal", "dance"]
-  },
-  {
-    id: "extended5",
-    name: "Extended 5",
-    degrees: [0, 4, 5, 2, 3],
-    functional: "loop",
-    styles: ["minimal", "dance", "idol"]
-  },
-  {
-    id: "neapolitanPop",
-    name: "Neapolitan Pop",
-    degrees: [5, 12, 13, 4, 0],
-    functional: "cadenceStrong",
-    styles: ["minimal", "dance", "idol"]
-  }
-];
-var BORROWED_OFFSET = {
-  8: 8,
-  // bVI
-  10: 10,
-  // bVII
-  11: 3,
-  // bIII
-  12: 5,
-  // iv
-  13: 1,
-  // bII
-  14: 6
-  // #IV
-};
-function progressions() {
-  return PRESETS.map((p) => ({ ...p, degrees: [...p.degrees], styles: [...p.styles] }));
-}
-function progressionsByStyle(style) {
-  return progressions().filter((p) => p.styles.includes(style));
-}
-function degreeToRootPc(degree, key) {
-  if (degree >= 0 && degree <= 6) {
-    const tones = scaleTonesInDegreeOrder(key);
-    return tones.length > 0 ? tones[degree % tones.length] ?? key.rootPc % 12 : key.rootPc % 12;
-  }
-  const offset = BORROWED_OFFSET[degree] ?? 0;
-  return ((key.rootPc % 12 + offset) % 12 + 12) % 12;
-}
-function autoQuality(degree, key) {
-  if (degree >= 0 && degree <= 6) {
-    return diatonicTriad(degree, key).quality;
-  }
-  if (degree === 14) {
-    return "dim";
-  }
-  if (degree === 12) {
-    return "min";
-  }
-  return "maj";
-}
-function generateProgression(opts) {
-  assertPositiveInt(opts.bars, "progression bars");
-  assertGenerationBudget(opts.bars, "progression chords");
-  const seed = opts.seed ?? 0;
-  let preset;
-  if (opts.presetId !== void 0) {
-    preset = PRESETS.find((p) => p.id === opts.presetId);
-    if (preset === void 0) {
-      throw new Error(`Unknown progression preset: ${opts.presetId}`);
-    }
-  }
-  if (preset === void 0) {
-    const pool = PRESETS.filter((p) => p.styles.includes(opts.style));
-    const candidates = pool.length > 0 ? pool : PRESETS;
-    const rng = createRng(seed);
-    const index = Math.floor(rng.next() * candidates.length) % candidates.length;
-    preset = candidates[index] ?? PRESETS[0];
-  }
-  const degrees = preset?.degrees ?? [0];
-  const chords = [];
-  for (let bar = 0; bar < opts.bars; bar += 1) {
-    const degree = degrees[bar % degrees.length] ?? 0;
-    const quality = opts.ext !== void 0 && opts.ext !== "auto" ? opts.ext : autoQuality(degree, opts.key);
-    const chord = {
-      rootPc: degreeToRootPc(degree, opts.key),
-      quality,
-      startBeat: bar * 4,
-      degree: degree >= 0 && degree <= 6 ? degree : void 0
-    };
-    chords.push(chord);
-  }
-  if (opts.reharmonize) {
-    const tonicPc = (opts.key.rootPc % 12 + 12) % 12;
-    const rrng = createRng((seed ^ 2654435769) >>> 0);
-    for (let i = 0; i < chords.length - 1; i += 1) {
-      const cur = chords[i];
-      const next = chords[i + 1];
-      if (!cur || !next) {
-        continue;
-      }
-      const domRoot = (next.rootPc + 7) % 12;
-      const targetsTonic = (next.rootPc - tonicPc + 12) % 12 === 0;
-      const alreadySecondary = cur.rootPc === domRoot && cur.quality === "dom7";
-      const isResolutionTarget = chords[i - 1]?.secondaryDominant === true;
-      if (targetsTonic || alreadySecondary || isResolutionTarget) {
-        continue;
-      }
-      if (rrng.next() < 0.5) {
-        chords[i] = {
-          rootPc: domRoot,
-          quality: "dom7",
-          startBeat: cur.startBeat,
-          secondaryDominant: true
-        };
-      }
-    }
-  }
-  return chords;
-}
 
-// src/analyze/detect/index.ts
-function pitchClass7(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(pitchClass7))].sort((a, b) => a - b);
-}
-function assertPitches(pitches) {
-  assertGenerationBudget(pitches.length, "detection pitches");
-  for (let index = 0; index < pitches.length; index += 1) {
-    assertFiniteNumber(pitches[index] ?? Number.NaN, `pitches[${index}]`);
-  }
-}
-function detectChord(pitches, opts = {}) {
-  assertPitches(pitches);
-  if (opts.bassPc !== void 0) assertFiniteNumber(opts.bassPc, "bassPc");
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const inputKind = opts.input === void 0 || opts.input === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : opts.input;
-  const bassPc = opts.bassPc !== void 0 ? pitchClass7(opts.bassPc) : inputKind === "midi" ? pitchClass7(pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
-  const inputSet = new Set(input);
-  const matches = [];
-  const qualities = chordQualities();
-  for (const rootPc of input) {
-    for (const quality of qualities) {
-      const chord = makeChord(rootPc, quality);
-      const tones = chordPitchClasses(chord);
-      const toneSet = new Set(tones);
-      const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = pitchClass7(rootPc + 7);
-      if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
-        continue;
-      }
-      const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => pitchClass7(rootPc + iv) === bassPc);
-      const inversion = bassPc === void 0 ? null : bassIndex > 0 ? bassIndex : 0;
-      const match = {
-        rootPc,
-        quality,
-        missingPcs,
-        extraPcs,
-        exact: extraPcs.length === 0 && missingPcs.length === 0,
-        inversion
-      };
-      if (bassPc !== void 0 && bassPc !== rootPc) {
-        match.bassPc = bassPc;
-      }
-      matches.push(match);
-    }
-  }
-  matches.sort((a, b) => {
-    if (a.extraPcs.length !== b.extraPcs.length) {
-      return a.extraPcs.length - b.extraPcs.length;
-    }
-    if (a.missingPcs.length !== b.missingPcs.length) {
-      return a.missingPcs.length - b.missingPcs.length;
-    }
-    if (a.inversion === 0 !== (b.inversion === 0)) {
-      return a.inversion === 0 ? -1 : 1;
-    }
-    const aSize = chordPitchClasses(makeChord(a.rootPc, a.quality)).length;
-    const bSize = chordPitchClasses(makeChord(b.rootPc, b.quality)).length;
-    return bSize - aSize;
-  });
-  return matches;
-}
-function detectChordBest(pitches, opts = {}) {
-  const best = detectChord(pitches, opts)[0];
-  if (!best) {
-    return null;
-  }
-  return makeChord(best.rootPc, best.quality, best.bassPc);
-}
 
-// src/generate/reharmony/index.ts
-function mod122(n) {
-  return (n % 12 + 12) % 12;
-}
-function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => mod122(iv) === semitone);
-}
-function isDominantType(chord) {
-  return hasInterval(chord, 4) && hasInterval(chord, 10);
-}
-function isStableTarget(chord) {
-  const hasFifth = hasInterval(chord, 7);
-  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);
-  return hasFifth && hasThird && !isDominantType(chord);
-}
-function commonToneCount(a, b) {
-  const set = new Set(b);
-  return a.filter((pc) => set.has(pc)).length;
-}
-function diatonicTriadsOf(key) {
-  const degrees = scaleTonesInDegreeOrder(key).length;
-  const triads = [];
-  for (let degree = 0; degree < degrees; degree += 1) {
-    triads.push(diatonicTriad(degree, key));
-  }
-  return triads;
-}
-function sameChord(a, b) {
-  return mod122(a.rootPc) === mod122(b.rootPc) && a.quality === b.quality;
-}
-var THIRD_OFFSETS = [3, 4, 8, 9];
-function substituteChord(chord, key, opts) {
-  const original = chordPitchClasses(chord);
-  const candidates = [];
-  if (isDominantType(chord)) {
-    candidates.push({ chord: makeChord(mod122(chord.rootPc + 6), "dom7"), type: "tritone" });
-  }
-  if (isStableTarget(chord)) {
-    candidates.push({
-      chord: makeChord(mod122(chord.rootPc + 7), "dom7"),
-      type: "secondary-dominant"
-    });
-  }
-  for (const triad of diatonicTriadsOf(key)) {
-    const offset = mod122(triad.rootPc - chord.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(original, chordPitchClasses(triad)) === 2) {
-      candidates.push({ chord: triad, type: "relative" });
-    }
-  }
-  const targetFunction = functionOf(chord, key);
-  for (const triad of diatonicTriadsOf(parallelKey(key))) {
-    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {
-      candidates.push({ chord: triad, type: "borrowed" });
-    }
-  }
-  for (const offset of THIRD_OFFSETS) {
-    for (const quality of ["maj", "min"]) {
-      const mediant = makeChord(mod122(chord.rootPc + offset), quality);
-      if (commonToneCount(original, chordPitchClasses(mediant)) === 1 && !isDiatonic(mediant, key)) {
-        candidates.push({ chord: mediant, type: "chromatic-mediant" });
-      }
-    }
-  }
-  const melodyPcs = opts?.melodyPcs?.map(mod122);
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const candidate of candidates) {
-    if (sameChord(candidate.chord, chord)) {
-      continue;
-    }
-    const dedupeKey = `${mod122(candidate.chord.rootPc)}:${candidate.chord.quality}`;
-    if (seen.has(dedupeKey)) {
-      continue;
-    }
-    seen.add(dedupeKey);
-    if (melodyPcs !== void 0) {
-      const pcs = new Set(chordPitchClasses(candidate.chord));
-      if (!melodyPcs.every((pc) => pcs.has(pc))) {
-        continue;
-      }
-    }
-    results.push({
-      chord: candidate.chord,
-      type: candidate.type,
-      roman: chordToRoman(candidate.chord, key),
-      function: functionOf(candidate.chord, key)
-    });
-  }
-  return results;
-}
-function modalInterchangePalette(key) {
-  const palette = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (chord) => {
-    const dedupeKey = `${mod122(chord.rootPc)}:${chord.quality}`;
-    if (seen.has(dedupeKey)) {
-      return;
-    }
-    seen.add(dedupeKey);
-    palette.push({
-      chord,
-      roman: chordToRoman(chord, key),
-      source: borrowedSource(chord, key)
-    });
-  };
-  for (const triad of diatonicTriadsOf(parallelKey(key))) {
-    if (!isDiatonic(triad, key)) {
-      add(triad);
-    }
-  }
-  const neapolitan = makeChord(mod122(key.rootPc + 1), "maj");
-  if (!isDiatonic(neapolitan, key)) {
-    add(neapolitan);
-  }
-  return palette;
-}
-function negativeHarmonyMirror(chord, key) {
-  const tonic = mod122(key.rootPc);
-  const mirror = (p) => mod122(2 * tonic + 7 - p);
-  const pcs = chordPitchClasses(chord).map(mirror);
-  const bassPc = chord.bassPc !== void 0 ? mirror(chord.bassPc) : void 0;
-  const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
-  const detected = detectChordBest(pitches);
-  if (detected) {
-    if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return makeChord(detected.rootPc, detected.quality);
-    }
-    return detected;
-  }
-  const quality = chord.quality;
-  return makeChord(mirror(chord.rootPc), quality, bassPc);
-}
 
-// src/generate/rhythm/index.ts
-var DEFAULT_SUBDIVISION = 2;
-var DEFAULT_DENSITY = 0.5;
-var DEFAULT_BARS = 1;
-function onsetWeightCurve(weight) {
-  switch (weight) {
-    case 3:
-      return 1;
-    case 2:
-      return 0.8;
-    case 1:
-      return 0.55;
-    default:
-      return 0.25;
-  }
-}
-function generateRhythm(ts, opts = {}) {
-  const seed = opts.seed ?? 0;
-  const bars = opts.bars ?? DEFAULT_BARS;
-  const subdivision = opts.subdivision ?? DEFAULT_SUBDIVISION;
-  const requestedDensity = assertFiniteNumber(opts.density ?? DEFAULT_DENSITY, "rhythm density");
-  const density = Math.min(1, Math.max(0, requestedDensity));
-  assertPositiveInt(bars, "rhythm bars");
-  assertPositiveInt(subdivision, "rhythm subdivision");
-  const barBeats = beatsPerBar(ts);
-  const spanBeats = barBeats * bars;
-  const step = 1 / subdivision;
-  const slotCount = Math.round(spanBeats * subdivision);
-  assertGenerationBudget(slotCount, "rhythm grid slots");
-  const slotsPerBar = Math.round(barBeats * subdivision);
-  const rng = createRng(seed);
-  const positions = [];
-  for (let i = 0; i < slotCount; i += 1) {
-    const position = i * step;
-    if (i % slotsPerBar === 0) {
-      positions.push(position);
-      continue;
-    }
-    const weight = metricWeight(position, ts);
-    const probability = onsetWeightCurve(weight) * density;
-    if (rng.prob(probability)) {
-      positions.push(position);
-    }
-  }
-  const events = [];
-  for (let i = 0; i < positions.length; i += 1) {
-    const position = positions[i] ?? 0;
-    const nextPosition = positions[i + 1] ?? spanBeats;
-    events.push({ position, duration: nextPosition - position });
-  }
-  return events;
-}
-function rhythmDensity(events, ts) {
-  if (events.length === 0) {
-    return 0;
-  }
-  const last = events[events.length - 1];
-  const spanBeats = (last?.position ?? 0) + (last?.duration ?? 0);
-  const bars = spanBeats / beatsPerBar(ts);
-  return bars > 0 ? events.length / bars : 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyGrooveTemplate,
-  developMotif,
-  extractGrooveTemplate,
-  generateBassLine,
-  generateCounterMelody,
-  generateDrums,
-  generateMotif,
-  generateProgression,
-  generateRhythm,
-  harmonizeMelody,
-  humanize,
-  modalInterchangePalette,
-  negativeHarmonyMirror,
-  onsetWeightCurve,
-  progressions,
-  progressionsByStyle,
-  rhythmDensity,
-  substituteChord,
-  transformMotif
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BASS_STYLES = _chunkMPTVJIVGcjs.BASS_STYLES; exports.BORROWED_DEGREES = _chunkMPTVJIVGcjs.BORROWED_DEGREES; exports.DRUM_NOTES = _chunkMPTVJIVGcjs.DRUM_NOTES; exports.applyGrooveTemplate = _chunkMPTVJIVGcjs.applyGrooveTemplate; exports.developMotif = _chunkMPTVJIVGcjs.developMotif; exports.drumVoiceOf = _chunkMPTVJIVGcjs.drumVoiceOf; exports.extractGrooveTemplate = _chunkMPTVJIVGcjs.extractGrooveTemplate; exports.generateBassLine = _chunkMPTVJIVGcjs.generateBassLine; exports.generateCounterMelody = _chunkMPTVJIVGcjs.generateCounterMelody; exports.generateDrums = _chunkMPTVJIVGcjs.generateDrums; exports.generateMotif = _chunkMPTVJIVGcjs.generateMotif; exports.generateProgression = _chunkMPTVJIVGcjs.generateProgression; exports.generateRhythm = _chunkMPTVJIVGcjs.generateRhythm; exports.harmonizeMelody = _chunkMPTVJIVGcjs.harmonizeMelody; exports.humanize = _chunkMPTVJIVGcjs.humanize; exports.modalInterchangePalette = _chunk357ZDPVUcjs.modalInterchangePalette; exports.motifToNoteEvents = _chunkMPTVJIVGcjs.motifToNoteEvents; exports.negativeHarmonyMirror = _chunk357ZDPVUcjs.negativeHarmonyMirror; exports.onsetWeightCurve = _chunkMPTVJIVGcjs.onsetWeightCurve; exports.pickProgressionPreset = _chunkMPTVJIVGcjs.pickProgressionPreset; exports.progressions = _chunkMPTVJIVGcjs.progressions; exports.progressionsByStyle = _chunkMPTVJIVGcjs.progressionsByStyle; exports.rhythmDensity = _chunkMPTVJIVGcjs.rhythmDensity; exports.rhythmToNoteEvents = _chunkMPTVJIVGcjs.rhythmToNoteEvents; exports.substituteChord = _chunk357ZDPVUcjs.substituteChord; exports.transformMotif = _chunkMPTVJIVGcjs.transformMotif;
 //# sourceMappingURL=index.cjs.map