@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-7NKDPF74.js

@@ -1,3077 +0,0 @@
-import {
-  createRng
-} from "./chunk-HKGYCQ34.js";
-import {
-  beatsPerBar,
-  createNoteEventIndex,
-  formatTimeSignature,
-  isStrongBeat,
-  metricWeight
-} from "./chunk-YLEMGEFH.js";
-import {
-  isDiatonic,
-  parallelKey
-} from "./chunk-KMHOICIY.js";
-import {
-  roleOf
-} from "./chunk-NKIBQ6PT.js";
-import {
-  enumerateSafePitches,
-  evaluateSafety
-} from "./chunk-NYYWMV2C.js";
-import {
-  NATURAL_MINOR_MASK,
-  chordPitchClasses,
-  chordToneRole,
-  createsParallelPerfect,
-  diatonicTriad,
-  isForbiddenMelodicLeap,
-  isScaleTone,
-  majorKey,
-  makeChord,
-  minorKey,
-  nearestScaleTone,
-  scaleTonesInDegreeOrder
-} from "./chunk-D2FAJBYL.js";
-import {
-  InvalidInputError,
-  assertFiniteNumber,
-  assertGenerationBudget,
-  assertInteger,
-  assertNoteEvents,
-  assertOneOf,
-  assertPositiveInt,
-  assertRange,
-  assertTimeSignature,
-  dropSilentNotes,
-  pitchClassOf
-} from "./chunk-XEBG3G53.js";
-
-// src/generate/bass/index.ts
-var BASS_STYLES = ["root", "rootFifth", "pop", "walking", "arpeggio"];
-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 EPS = 1e-9;
-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 = pitchClassOf(chord.rootPc + interval);
-    if (!seen.has(pc)) {
-      seen.add(pc);
-      pcs.push(pc);
-    }
-  }
-  if (pcs.length === 0) {
-    pcs.push(pitchClassOf(chord.rootPc));
-  }
-  return pcs;
-}
-function fifthPcOf(chord) {
-  const fifths = new Set(chord.intervals.map((i) => pitchClassOf(i)));
-  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
-  return chosen === void 0 ? pitchClassOf(chord.rootPc) : pitchClassOf(chord.rootPc + chosen);
-}
-function bassPcOf(chord) {
-  return pitchClassOf(chord.bassPc ?? chord.rootPc);
-}
-function beatPositions(start, end) {
-  const positions = [];
-  for (let p = start; p < end - EPS; 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 + EPS && mid < seg.endBeat - EPS) {
-    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);
-        const dropped = base - 12;
-        emit(ctx, pos, rootPc, dropped >= 0 ? dropped : base);
-      } 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;
-  const chromatic = target + dir;
-  if (ctx.rng.prob(0.5)) {
-    return foldIntoBand(chromatic, ctx.low);
-  }
-  const cand = nearestScaleTone(target + dir * 2, ctx.key);
-  const step = Math.abs(cand - target);
-  return foldIntoBand(step >= 1 && step <= 2 ? cand : chromatic, ctx.low);
-}
-function foldIntoBand(midi, low) {
-  let result = midi;
-  while (result < low) {
-    result += 12;
-  }
-  while (result > low + 12) {
-    result -= 12;
-  }
-  return result;
-}
-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, pitchClassOf(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 InvalidInputError(`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 = assertOneOf(opts.style ?? DEFAULT_STYLE, BASS_STYLES, "bass 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 <= EPS) {
-      continue;
-    }
-    out.push({
-      pitch: note.pitch,
-      startBeat: note.startBeat,
-      durationBeat,
-      velocity: note.velocity
-    });
-  }
-  return out;
-}
-
-// src/generate/countermelody/index.ts
-var DEFAULT_TS2 = { numerator: 4, denominator: 4 };
-var EPS2 = 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;
-var TIE_BREAK_JITTER = 1e-6;
-function isWholeBeat(beat) {
-  return Math.abs(beat - Math.round(beat)) < EPS2;
-}
-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) < EPS2;
-  const previous = attacked ? melodyNoteAt(melody, beat - EPS2 * 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 - EPS2; 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 - EPS2) {
-      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 + EPS2 && beat < endBeat - EPS2) {
-      boundaries.add(beat);
-    }
-  }
-  const firstGrid = Math.floor(startBeat / GRID_STEP + 1) * GRID_STEP;
-  for (let beat = firstGrid; beat < endBeat - EPS2; beat += GRID_STEP) {
-    boundaries.add(beat);
-  }
-  return [...boundaries].sort((a, b) => a - b);
-}
-function boundaryContexts(melody, harmony, startBeat, endBeat, ts) {
-  const boundaries = heldNoteBoundaries(melody, startBeat, endBeat, harmony.chordChangeBeats);
-  return boundaries.map((boundary) => {
-    const melodyVoice = melodySnapshotAt(melody, boundary);
-    return {
-      melodyVoice,
-      otherVoices: melodyVoice === void 0 ? [] : [melodyVoice],
-      chord: harmony.chordAt(boundary),
-      strongBeat: isStrongBeat(boundary, ts),
-      atCounterOnset: Math.abs(boundary - startBeat) < EPS2
-    };
-  });
-}
-function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low, high) {
-  let worst = 0 /* Safe */;
-  for (const context of contexts) {
-    const melodyVoice = context.melodyVoice;
-    if (melodyVoice !== void 0 && (register === "below" && pitch >= melodyVoice.pitch || register === "above" && pitch <= melodyVoice.pitch)) {
-      return null;
-    }
-    const result = evaluateSafety(
-      {
-        profile,
-        candidatePitch: pitch,
-        prevPitch: context.atCounterOnset ? prevPitch : pitch,
-        chord: context.chord,
-        key,
-        otherVoices: context.otherVoices,
-        strongBeat: context.strongBeat,
-        vocalLow: low,
-        vocalHigh: high
-      },
-      { suggestions: false }
-    );
-    worst = Math.max(worst, result.safety);
-    if (worst === 2 /* Dissonant */) {
-      return worst;
-    }
-  }
-  return worst;
-}
-function generateCounterMelody(opts) {
-  const timeline = opts.timeline;
-  const chordAt = timeline === void 0 ? opts.chordAt : (beat) => timeline.at(beat);
-  if (chordAt === void 0) {
-    throw new TypeError("countermelody needs a timeline or a chordAt callback");
-  }
-  const chordChangeBeats = timeline === void 0 ? opts.chordChangeBeats ?? [] : timeline.segments.flatMap((segment) => [segment.startBeat, segment.endBeat]);
-  const register = opts.register ?? "below";
-  const melody = createNoteEventIndex(opts.melody, {
-    allowNonPositiveDuration: true,
-    tieBreak: register === "below" ? "highest" : "lowest"
-  });
-  const ts = opts.ts ?? DEFAULT_TS2;
-  assertTimeSignature(ts);
-  const rhythm = assertOneOf(opts.rhythm ?? "complement", ["complement", "follow"], "rhythm");
-  const profile = assertOneOf(opts.profile ?? "pop", ["strict", "pop"], "safety profile");
-  const rng = createRng(opts.seed ?? 0);
-  if (opts.pitchLow !== void 0) {
-    assertInteger(opts.pitchLow, "countermelody pitchLow");
-  }
-  if (opts.pitchHigh !== void 0) {
-    assertInteger(opts.pitchHigh, "countermelody pitchHigh");
-  }
-  if (melody.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
-    return [];
-  }
-  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 InvalidInputError(
-      `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
-    );
-  }
-  assertGenerationBudget(high - low + 1, "countermelody pitch candidates");
-  assertGenerationBudget(chordChangeBeats.length, "chord change beats");
-  for (let index = 0; index < chordChangeBeats.length; index += 1) {
-    assertRange(
-      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);
-  const boundaryEstimate = onsets.length + Math.ceil((spanEnd - spanStart) / GRID_STEP) + melody.notes.length + chordChangeBeats.length;
-  assertGenerationBudget(boundaryEstimate * (high - low + 1), "countermelody search");
-  const jitter = Array.from({ length: high - low + 1 }, () => rng.next() * TIE_BREAK_JITTER);
-  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 contexts = boundaryContexts(melody, { chordAt, chordChangeBeats }, beat, endBeat, ts);
-    const chord = contexts[0]?.chord ?? 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,
-        contexts,
-        prevPitch,
-        opts.key,
-        profile,
-        register,
-        low,
-        high
-      );
-      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) + (jitter[candidate - low] ?? 0);
-      const tie = Math.abs(score - bestScore) <= EPS2 && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
-      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS2 || 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 DRUM_FEELS = ["straight", "swing", "shuffle"];
-var GROOVE_STYLES = [
-  "standard",
-  "funk",
-  "shuffle",
-  "bossa",
-  "trap",
-  "halftime",
-  "breakbeat",
-  "house",
-  "synthpop"
-];
-var DRUM_ROLES = ["full", "ambient", "minimal", "fxOnly"];
-var PUBLIC_SECTIONS = [
-  "intro",
-  "verse",
-  "prechorus",
-  "chorus",
-  "bridge",
-  "outro"
-];
-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) {
-  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;
-  }
-  return Math.max(0.25, Math.min(0.65, base));
-}
-function getGhostProbabilityAtPosition(beat, sixteenthInBeat) {
-  const leadsIntoBackbeat = (beat === 0 || beat === 2) && sixteenthInBeat === 3;
-  return leadsIntoBackbeat ? 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 styleSwingFactor(style) {
-  if (style === "trap") {
-    return 0;
-  }
-  if (style === "latin") {
-    return 0.35;
-  }
-  return 0.5;
-}
-function sectionSwing(sec, swingAmount) {
-  return effectiveSwing(sec.feel, swingAmount) * styleSwingFactor(sec.style);
-}
-function swing16(tick, sec, swingAmount) {
-  return quantizeSwing(tick, sectionSwing(sec, swingAmount), "sixteenth");
-}
-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, 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 (sec.role === "fxOnly") {
-    return;
-  }
-  if (sec.role === "minimal") {
-    ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.65);
-    return;
-  }
-  if (promoteSparseChorus) {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  } else if (sec.style === "sparse" || sec.role === "ambient") {
-    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);
-    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, 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, 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 !== 0) {
-      hhTick = swing16(hhTick, sec, ctx.swingAmount);
-    }
-    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 DRUM_NOTES = {
-  kick: GM.BD,
-  snare: GM.SD,
-  sideStick: GM.SIDESTICK,
-  handClap: GM.HANDCLAP,
-  closedHiHat: GM.CHH,
-  pedalHiHat: GM.FHH,
-  openHiHat: GM.OHH,
-  crash: GM.CRASH,
-  ride: GM.RIDE,
-  tambourine: GM.TAMBOURINE,
-  highTom: GM.TOM_H,
-  midTom: GM.TOM_M,
-  lowTom: GM.TOM_L,
-  shaker: GM.SHAKER
-};
-var VOICE_BY_NOTE = new Map(
-  Object.entries(DRUM_NOTES).map(([voice, note]) => [note, voice])
-);
-function drumVoiceOf(pitch) {
-  return VOICE_BY_NOTE.get(pitch);
-}
-var ONSET_KEY_SCALE = 128;
-var HitList = class {
-  hits = [];
-  /** Onset keys already occupied, as `pitch:quantizedBeat`. */
-  #onsets = /* @__PURE__ */ new Set();
-  /** Append a hit, clamping velocity and dropping non-positive positions. */
-  add(pitch, startBeat, durationBeat, velocity) {
-    const beat = Math.max(0, startBeat);
-    this.hits.push({
-      pitch,
-      startBeat: beat,
-      durationBeat,
-      velocity: clampVel(velocity)
-    });
-    this.#onsets.add(onsetKey(pitch, beat));
-  }
-  /** Whether a hit of this pitch already starts exactly at `startBeat`. */
-  hasOnset(pitch, startBeat) {
-    return this.#onsets.has(onsetKey(pitch, startBeat));
-  }
-  /** True when a crash already sits within a 16th of `startBeat`. */
-  hasCrashNear(startBeat) {
-    const steps = Math.round(0.25 * ONSET_KEY_SCALE);
-    for (let step = 0; step < steps; step += 1) {
-      if (this.#onsets.has(onsetKey(GM.CRASH, startBeat + step / ONSET_KEY_SCALE))) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-function onsetKey(pitch, startBeat) {
-  return `${pitch}:${Math.round(startBeat * ONSET_KEY_SCALE)}`;
-}
-
-// 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;
-}
-
-// 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
-var MAX_HITS_PER_BAR = 128;
-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 * MAX_HITS_PER_BAR, "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 publicStyle = assertOneOf(opts.style, GROOVE_STYLES, "drum style");
-  const publicSection = assertOneOf(opts.section, PUBLIC_SECTIONS, "drum section");
-  if (opts.nextSection !== void 0) {
-    assertOneOf(opts.nextSection, PUBLIC_SECTIONS, "drum nextSection");
-  }
-  const track = new HitList();
-  const rng = createRng(opts.seed ?? 0);
-  const mapping = mapStyle(publicStyle);
-  const style = mapping.style;
-  const feel = opts.feel === void 0 ? mapping.feel : assertOneOf(opts.feel, DRUM_FEELS, "drum feel");
-  const role = opts.role === void 0 ? "full" : assertOneOf(opts.role, DRUM_ROLES, "drum role");
-  const playMainVoices = role !== "fxOnly";
-  const section = mapSection(publicSection);
-  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, nextSection === "chorus");
-    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;
-        if (!track.hasOnset(GM.FHH, fhhTick)) {
-          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].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-}
-
-// src/generate/groove/index.ts
-var DEFAULT_TS3 = { numerator: 4, denominator: 4 };
-var DEFAULT_GROOVE_SUBDIVISION = 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", { allowNonPositiveDuration: true });
-  const sounding = dropSilentNotes(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 sounding.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 = DEFAULT_GROOVE_SUBDIVISION) {
-  assertTimeSignature(ts);
-  assertNoteEvents(events, "groove source events", { allowNonPositiveDuration: true });
-  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 dropSilentNotes(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", { allowNonPositiveDuration: true });
-  assertPositiveInt(template.subdivision, "template subdivision");
-  assertPositiveInt(template.slotsPerBar, "template slotsPerBar");
-  assertGenerationBudget(template.slots.length, "template slots");
-  if (template.slots.length !== template.slotsPerBar) {
-    throw new InvalidInputError("template slots length must equal slotsPerBar");
-  }
-  if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
-    throw new InvalidInputError(
-      `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(ts)}`
-    );
-  }
-  const barBeats = beatsPerBar(ts);
-  return dropSilentNotes(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/generate/harmonize/index.ts
-var FALLBACK = {
-  rootPc: 0,
-  quality: "maj",
-  secondaryDominant: false,
-  base: 0,
-  pcs: chordPitchClasses(makeChord(0, "maj"))
-};
-var DEFAULT_HARMONIC_RHYTHM = 2;
-var DEFAULT_PLACEMENT = { transposeSearch: false, octaveSearch: false };
-var DEFAULT_METER = { numerator: 4, denominator: 4 };
-var COMFORT_LOW = 55;
-var COMFORT_HIGH = 79;
-var TESSITURA_WEIGHT = 1e-3;
-var TIE_BREAK_JITTER2 = 1e-6;
-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 = pitchClassOf(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 = pitchClassOf(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) => {
-    const quality = diatonicTriad(degree, key).quality;
-    return {
-      rootPc,
-      quality,
-      degree,
-      secondaryDominant: false,
-      base: 0,
-      pcs: chordPitchClasses(makeChord(rootPc, quality))
-    };
-  });
-  if (reharmonize !== "diatonic") {
-    for (const target of [1, 3, 4, 5]) {
-      const targetRoot = tones[target] ?? 0;
-      const rootPc = (targetRoot + 7) % 12;
-      candidates.push({
-        rootPc,
-        quality: "dom7",
-        secondaryDominant: true,
-        targetDegree: target,
-        base: 1.5,
-        pcs: chordPitchClasses(makeChord(rootPc, "dom7"))
-      });
-    }
-  }
-  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,
-          pcs: chordPitchClasses(chord)
-        });
-      }
-    }
-  }
-  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, ts) {
-  const pcs = cand.pcs;
-  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(pitchClassOf(note.pitch))) {
-      continue;
-    }
-    const strong = isStrongBeat(overlapStart, ts);
-    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, ts) {
-  const tonicPc = pitchClassOf(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, ts) : 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, ts) + (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, { allowNonPositiveDuration: true });
-  const ts = opts.ts ?? DEFAULT_METER;
-  assertTimeSignature(ts);
-  const requestedKey = opts.key ?? "infer";
-  const key = requestedKey === "infer" ? inferKey(opts.melody) : requestedKey;
-  const placement = opts.placement ?? DEFAULT_PLACEMENT;
-  if (noteIndex.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
-    return { transposeSemitones: 0, key, chords: [], melodyRoles: [] };
-  }
-  const candidates = buildCandidates(key, opts.reharmonize ?? "diatonic");
-  const candAt = (i) => candidates[i] ?? FALLBACK;
-  const rng = createRng(opts.seed ?? 0);
-  const jitter = candidates.map(() => rng.next() * TIE_BREAK_JITTER2);
-  const melodyEnd = noteIndex.notes.reduce((m, n) => Math.max(m, n.endBeat), 0);
-  const hr = assertRange(
-    opts.harmonicRhythm ?? DEFAULT_HARMONIC_RHYTHM,
-    Number.MIN_VALUE,
-    Number.MAX_SAFE_INTEGER,
-    "harmonic rhythm"
-  );
-  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) {
-    if (indexed.note.durationBeat <= 0) {
-      continue;
-    }
-    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 (placement.transposeSearch) {
-    for (let s = -6; s <= 6; s += 1) {
-      if (s !== 0) {
-        transposes.push(s);
-      }
-    }
-  }
-  if (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 shift of transposes) {
-    const shifted = opts.melody.map((n) => ({ ...n, pitch: n.pitch + shift }));
-    const { cost, path } = harmonizeOnce(shifted, key, candidates, segments, jitter, ts);
-    const total = cost + tessituraCost(shifted);
-    if (total < bestCost) {
-      bestCost = total;
-      bestTs = shift;
-      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
-var MIN_TILE_SPAN = 1 / 256;
-var DEFAULT_TS4 = { numerator: 4, denominator: 4 };
-var EPS3 = 1e-9;
-function isDownbeat(startBeat, barBeats) {
-  const bar = startBeat / barBeats;
-  return Math.abs(bar - Math.round(bar)) < EPS3;
-}
-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(pitchClassOf(pitch - d))) {
-      return pitch - d;
-    }
-    if (pcs.includes(pitchClassOf(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 barBeats = beatsPerBar(opts.ts ?? DEFAULT_TS4);
-  const totalBeats = bars * barBeats;
-  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 = pitchClassOf(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 && isDownbeat(startBeat, barBeats)) {
-      pitch = nearestChordTone(pitch, opts.chord);
-    }
-    notes.push({ pitch, startBeat, durationBeat: beatsPerNote });
-  }
-  return { notes };
-}
-function motifToNoteEvents(cell) {
-  return cell.notes.map((note) => ({ ...note }));
-}
-function transformMotif(cell, t, amount, key) {
-  return assertInRange(transformUnchecked(cell, t, amount, key));
-}
-function assertInRange(cell) {
-  for (const note of cell.notes) {
-    if (note.pitch < 0 || note.pitch > 127) {
-      throw new InvalidInputError(
-        `transformed motif pitch ${note.pitch} is outside the MIDI range 0..127`
-      );
-    }
-  }
-  return cell;
-}
-function transformUnchecked(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 InvalidInputError("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, ts = DEFAULT_TS4) {
-  assertPositiveInt(bars, "development bars");
-  assertNoteEvents(cell.notes, "motif notes");
-  const span = cellSpan(cell);
-  const totalBeats = bars * beatsPerBar(ts);
-  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(pitchClassOf(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 BORROWED_DEGREES = {
-  /** Flat submediant: bVI. */
-  bVI: 8,
-  /** Flat subtonic: bVII. */
-  bVII: 10,
-  /** Flat mediant: bIII. */
-  bIII: 11,
-  /** Minor subdominant borrowed from the parallel minor: iv. */
-  iv: 12,
-  /** Neapolitan: bII. */
-  bII: 13,
-  /** Sharp subdominant, the diminished #IV. */
-  sharpIV: 14
-};
-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 = {
-  [BORROWED_DEGREES.bVI]: 8,
-  [BORROWED_DEGREES.bVII]: 10,
-  [BORROWED_DEGREES.bIII]: 3,
-  [BORROWED_DEGREES.iv]: 5,
-  [BORROWED_DEGREES.bII]: 1,
-  [BORROWED_DEGREES.sharpIV]: 6
-};
-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 resolveCycle(degrees, key, ext) {
-  const steps = [];
-  for (const degree of degrees) {
-    const step = {
-      source: degree,
-      rootPc: degreeToRootPc(degree, key),
-      quality: ext !== void 0 && ext !== "auto" ? ext : autoQuality(degree, key)
-    };
-    if (degree >= 0 && degree <= 6) {
-      step.degree = degree;
-    }
-    const previous = steps[steps.length - 1];
-    if (previous !== void 0 && previous.source !== step.source && sameStep(previous, step)) {
-      continue;
-    }
-    steps.push(step);
-  }
-  const first = steps[0];
-  const last = steps[steps.length - 1];
-  if (steps.length > 1 && first !== void 0 && last !== void 0 && first.source !== last.source && sameStep(first, last)) {
-    steps.pop();
-  }
-  return steps.length > 0 ? steps : [{ source: 0, degree: 0, rootPc: degreeToRootPc(0, key), quality: "maj" }];
-}
-function sameStep(a, b) {
-  return a.rootPc === b.rootPc && a.quality === b.quality;
-}
-function pickProgressionPreset(style, seed = 0) {
-  const pool = PRESETS.filter((preset) => preset.styles.includes(style));
-  if (pool.length === 0) {
-    throw new InvalidInputError(`Unknown progression style: ${style}`);
-  }
-  const rng = createRng(seed);
-  const index = Math.floor(rng.next() * pool.length) % pool.length;
-  return pool[index] ?? PRESETS[0];
-}
-function generateProgression(opts) {
-  assertPositiveInt(opts.bars, "progression bars");
-  assertGenerationBudget(opts.bars, "progression chords");
-  const seed = opts.seed ?? 0;
-  let preset;
-  if (opts.preset !== void 0) {
-    if (opts.preset.degrees.length === 0) {
-      throw new InvalidInputError("progression preset must name at least one degree");
-    }
-    preset = {
-      id: opts.preset.id ?? "custom",
-      name: opts.preset.name ?? "Custom",
-      degrees: opts.preset.degrees,
-      functional: opts.preset.functional ?? "loop",
-      styles: opts.preset.styles ?? [opts.style]
-    };
-  }
-  if (preset === void 0 && opts.presetId !== void 0) {
-    preset = PRESETS.find((p) => p.id === opts.presetId);
-    if (preset === void 0) {
-      throw new InvalidInputError(`Unknown progression preset: ${opts.presetId}`);
-    }
-  }
-  preset ??= pickProgressionPreset(opts.style, seed);
-  const cycle = resolveCycle(preset?.degrees ?? [0], opts.key, opts.ext);
-  const chords = [];
-  for (let bar = 0; bar < opts.bars; bar += 1) {
-    const step = cycle[bar % cycle.length];
-    const chord = {
-      rootPc: step?.rootPc ?? 0,
-      quality: step?.quality ?? "maj",
-      startBeat: bar * 4
-    };
-    if (step?.degree !== void 0) {
-      chord.degree = step.degree;
-    }
-    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/generate/rhythm/index.ts
-var DEFAULT_RHYTHM_VELOCITY = 96;
-function rhythmToNoteEvents(events, pitch, velocity = DEFAULT_RHYTHM_VELOCITY) {
-  assertFiniteNumber(pitch, "pitch");
-  assertRange(velocity, 0, 127, "velocity");
-  return events.map((event) => ({
-    pitch,
-    startBeat: event.position,
-    durationBeat: event.duration,
-    velocity
-  }));
-}
-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 density = assertRange(opts.density ?? DEFAULT_DENSITY, 0, 1, "rhythm density");
-  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;
-}
-
-export {
-  BASS_STYLES,
-  generateBassLine,
-  generateCounterMelody,
-  DRUM_NOTES,
-  drumVoiceOf,
-  generateDrums,
-  humanize,
-  extractGrooveTemplate,
-  applyGrooveTemplate,
-  harmonizeMelody,
-  generateMotif,
-  motifToNoteEvents,
-  transformMotif,
-  developMotif,
-  BORROWED_DEGREES,
-  progressions,
-  progressionsByStyle,
-  pickProgressionPreset,
-  generateProgression,
-  rhythmToNoteEvents,
-  onsetWeightCurve,
-  generateRhythm,
-  rhythmDensity
-};
-//# sourceMappingURL=chunk-7NKDPF74.js.map