@libraz/libcantus 0.9.2 → 0.9.4

package/dist/chunk-4HLLZPXT.cjs

@@ -0,0 +1,3077 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkRUMU3UA6cjs = require('./chunk-RUMU3UA6.cjs');
+
+
+
+
+
+
+var _chunk36N73KZ3cjs = require('./chunk-36N73KZ3.cjs');
+
+
+
+var _chunkCAN76NCUcjs = require('./chunk-CAN76NCU.cjs');
+
+
+var _chunkFCANXBATcjs = require('./chunk-FCANXBAT.cjs');
+
+
+
+var _chunkQ6OP4U43cjs = require('./chunk-Q6OP4U43.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkFNDWXRRIcjs = require('./chunk-FNDWXRRI.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7MGZ7D62cjs = require('./chunk-7MGZ7D62.cjs');
+
+// 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 = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + interval);
+    if (!seen.has(pc)) {
+      seen.add(pc);
+      pcs.push(pc);
+    }
+  }
+  if (pcs.length === 0) {
+    pcs.push(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc));
+  }
+  return pcs;
+}
+function fifthPcOf(chord) {
+  const fifths = new Set(chord.intervals.map((i) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, i)));
+  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
+  return chosen === void 0 ? _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc) : _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + chosen);
+}
+function bassPcOf(chord) {
+  return _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, _nullishCoalesce(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 = _nullishCoalesce(midiOverride, () => ( placePc(pc, ctx.prevMidi, ctx.low)));
+  const velocity = _chunk36N73KZ3cjs.isStrongBeat.call(void 0, 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 (_chunk36N73KZ3cjs.isStrongBeat.call(void 0, 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 = _nullishCoalesce(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 = _chunkFNDWXRRIcjs.nearestScaleTone.call(void 0, 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, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, midi), midi);
+      return;
+    }
+    const pc = _nullishCoalesce(tones[i % tones.length], () => ( bassPcOf(seg.chord)));
+    ctx.prevMidi = emit(ctx, pos, pc);
+  });
+}
+function generateBassLine(opts) {
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, opts.segments.length, "bass segments");
+  for (let index = 0; index < opts.segments.length; index += 1) {
+    const segment = opts.segments[index];
+    if (!segment) continue;
+    _chunk7MGZ7D62cjs.assertRange.call(void 0, segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
+    _chunk7MGZ7D62cjs.assertRange.call(void 0, segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
+    if (segment.endBeat <= segment.startBeat) {
+      throw new (0, _chunk7MGZ7D62cjs.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 = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS));
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  const style = _chunk7MGZ7D62cjs.assertOneOf.call(void 0, _nullishCoalesce(opts.style, () => ( DEFAULT_STYLE)), BASS_STYLES, "bass style");
+  const octave = _nullishCoalesce(opts.octave, () => ( DEFAULT_OCTAVE));
+  _chunk7MGZ7D62cjs.assertInteger.call(void 0, octave, "bass octave", -1, 9);
+  const estimatedNotes = segments.reduce(
+    (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
+    0
+  );
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, estimatedNotes, "bass notes");
+  const low = octave * 12 + 12;
+  const ctx = {
+    ts,
+    low,
+    key: opts.key,
+    rng: _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([ctx, 'access', _2 => _2.notes, 'access', _3 => _3[i + 1], 'optionalAccess', _4 => _4.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 _optionalChain([melody, 'access', _5 => _5.at, 'call', _6 => _6(beat), 'optionalAccess', _7 => _7.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 (_chunk36N73KZ3cjs.isStrongBeat.call(void 0, 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 && _chunkFNDWXRRIcjs.chordToneRole.call(void 0, 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 (_chunkFNDWXRRIcjs.isForbiddenMelodicLeap.call(void 0, 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: _chunk36N73KZ3cjs.isStrongBeat.call(void 0, 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 = _chunkQ6OP4U43cjs.evaluateSafety.call(void 0, 
+      {
+        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 ? _nullishCoalesce(opts.chordChangeBeats, () => ( [])) : timeline.segments.flatMap((segment) => [segment.startBeat, segment.endBeat]);
+  const register = _nullishCoalesce(opts.register, () => ( "below"));
+  const melody = _chunk36N73KZ3cjs.createNoteEventIndex.call(void 0, opts.melody, {
+    allowNonPositiveDuration: true,
+    tieBreak: register === "below" ? "highest" : "lowest"
+  });
+  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS2));
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  const rhythm = _chunk7MGZ7D62cjs.assertOneOf.call(void 0, _nullishCoalesce(opts.rhythm, () => ( "complement")), ["complement", "follow"], "rhythm");
+  const profile = _chunk7MGZ7D62cjs.assertOneOf.call(void 0, _nullishCoalesce(opts.profile, () => ( "pop")), ["strict", "pop"], "safety profile");
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(opts.seed, () => ( 0)));
+  if (opts.pitchLow !== void 0) {
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, opts.pitchLow, "countermelody pitchLow");
+  }
+  if (opts.pitchHigh !== void 0) {
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, opts.pitchHigh, "countermelody pitchHigh");
+  }
+  if (melody.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
+    return [];
+  }
+  const spanStart = _nullishCoalesce(_optionalChain([melody, 'access', _8 => _8.notes, 'access', _9 => _9[0], 'optionalAccess', _10 => _10.note, 'access', _11 => _11.startBeat]), () => ( 0));
+  const spanEnd = melody.notes.reduce((end, n) => Math.max(end, n.endBeat), spanStart);
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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 = _nullishCoalesce(opts.pitchLow, () => ( Math.round(defaultCenter) - DEFAULT_HALF_RANGE));
+  const high = _nullishCoalesce(opts.pitchHigh, () => ( Math.round(defaultCenter) + DEFAULT_HALF_RANGE));
+  _chunk7MGZ7D62cjs.assertInteger.call(void 0, low, "countermelody pitchLow");
+  _chunk7MGZ7D62cjs.assertInteger.call(void 0, high, "countermelody pitchHigh");
+  if (low > high) {
+    throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)(
+      `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
+    );
+  }
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, high - low + 1, "countermelody pitch candidates");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, chordChangeBeats.length, "chord change beats");
+  for (let index = 0; index < chordChangeBeats.length; index += 1) {
+    _chunk7MGZ7D62cjs.assertRange.call(void 0, 
+      _nullishCoalesce(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;
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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 = _nullishCoalesce(nextOnset, () => ( Math.max(spanEnd, beat + GRID_STEP)));
+    const melNote = melodyNoteAt(melody, beat);
+    const melPitch = _optionalChain([melNote, 'optionalAccess', _12 => _12.pitch]);
+    const melodyVoice = melodySnapshotAt(melody, beat);
+    const melPrev = _optionalChain([melodyVoice, 'optionalAccess', _13 => _13.prevPitch]);
+    const contexts = boundaryContexts(melody, { chordAt, chordChangeBeats }, beat, endBeat, ts);
+    const chord = _nullishCoalesce(_optionalChain([contexts, 'access', _14 => _14[0], 'optionalAccess', _15 => _15.chord]), () => ( chordAt(beat)));
+    const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
+    const candidates = _chunkQ6OP4U43cjs.enumerateSafePitches.call(void 0, 
+      {
+        profile,
+        prevPitch,
+        chord,
+        key: opts.key,
+        otherVoices,
+        strongBeat: _chunk36N73KZ3cjs.isStrongBeat.call(void 0, 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.
+        _chunkFNDWXRRIcjs.createsParallelPerfect.call(void 0, prevPitch, candidate, melPrev, melPitch)) {
+          continue;
+        }
+      }
+      const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center) + (_nullishCoalesce(jitter[candidate - low], () => ( 0)));
+      const tie = Math.abs(score - bestScore) <= EPS2 && candidate < (_nullishCoalesce(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((_nullishCoalesce(_optionalChain([melNote, 'optionalAccess', _16 => _16.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 = _nullishCoalesce(GHOST_DENSITY_TABLE[sectionIndex(section)], () => ( GHOST_DENSITY_TABLE[1]));
+  const level = adjustForBpm(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _17 => _17[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 = _nullishCoalesce([kick.beat1, kick.beat2, kick.beat3, kick.beat4][ctx.beat], () => ( false));
+  const and = _nullishCoalesce([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) {
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, steps, "euclidean steps");
+  _chunk7MGZ7D62cjs.assertInteger.call(void 0, pulses, "euclidean pulses");
+  _chunk7MGZ7D62cjs.assertInteger.call(void 0, rotation, "euclidean rotation");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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) => _nullishCoalesce(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([..._nullishCoalesce(head[i], () => ( [])), ..._nullishCoalesce(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 = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.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;
+  }
+}, _class);
+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 = _nullishCoalesce(PERC_TABLE[mood], () => ( PERC_TABLE[1 /* Standard */]));
+  const act = _nullishCoalesce(_optionalChain([row, 'optionalAccess', _18 => _18[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 * (_nullishCoalesce(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 * (_nullishCoalesce(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) {
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, opts.bars, "drum bars");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, opts.bpm, Number.MIN_VALUE, 1e3, "drum bpm");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, opts.density, 0, 1, "drum density");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, opts.bars * MAX_HITS_PER_BAR, "drum hits");
+  if (opts.euclideanKick) {
+    const steps = _nullishCoalesce(opts.euclideanKick.steps, () => ( 16));
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, steps, "euclidean steps", 1, 16);
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, opts.euclideanKick.pulses, "euclidean pulses");
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, _nullishCoalesce(opts.euclideanKick.rotation, () => ( 0)), "euclidean rotation");
+  }
+  const publicStyle = _chunk7MGZ7D62cjs.assertOneOf.call(void 0, opts.style, GROOVE_STYLES, "drum style");
+  const publicSection = _chunk7MGZ7D62cjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum section");
+  if (opts.nextSection !== void 0) {
+    _chunk7MGZ7D62cjs.assertOneOf.call(void 0, opts.nextSection, PUBLIC_SECTIONS, "drum nextSection");
+  }
+  const track = new HitList();
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(opts.seed, () => ( 0)));
+  const mapping = mapStyle(publicStyle);
+  const style = mapping.style;
+  const feel = opts.feel === void 0 ? mapping.feel : _chunk7MGZ7D62cjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "drum feel");
+  const role = opts.role === void 0 ? "full" : _chunk7MGZ7D62cjs.assertOneOf.call(void 0, 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 = _nullishCoalesce(_optionalChain([opts, 'access', _19 => _19.euclideanKick, 'optionalAccess', _20 => _20.steps]), () => ( 16));
+  const euclidKick = opts.euclideanKick ? euclideanRhythm(opts.euclideanKick.pulses, euclidSteps, _nullishCoalesce(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 = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS3));
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, events, "humanize events", { allowNonPositiveDuration: true });
+  const sounding = _chunk7MGZ7D62cjs.dropSilentNotes.call(void 0, events);
+  const timing = _nullishCoalesce(opts.timing, () => ( DEFAULT_TIMING));
+  const velocityJitter = _nullishCoalesce(opts.velocity, () => ( DEFAULT_VELOCITY_JITTER));
+  const accent = _nullishCoalesce(opts.accent, () => ( DEFAULT_ACCENT));
+  const baseVelocity = _nullishCoalesce(opts.baseVelocity, () => ( DEFAULT_BASE_VELOCITY));
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, velocityJitter, 0, 127, "humanize velocity jitter");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, accent, 0, 127, "humanize accent");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, baseVelocity, 0, 127, "humanize base velocity");
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(opts.seed, () => ( 0)));
+  return sounding.map((event) => {
+    const timingOffset = rng.float(-timing, timing);
+    const startBeat = Math.max(0, event.startBeat + timingOffset);
+    const weight = _chunk36N73KZ3cjs.metricWeight.call(void 0, event.startBeat, ts);
+    const accentBoost = weight / MAX_METRIC_WEIGHT * accent;
+    const velocityOffset = rng.float(-velocityJitter, velocityJitter);
+    const rawVelocity = (_nullishCoalesce(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) {
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, events, "groove source events", { allowNonPositiveDuration: true });
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, subdivision, "groove subdivision");
+  const barBeats = _chunk36N73KZ3cjs.beatsPerBar.call(void 0, ts);
+  const slotsPerBar = Math.round(barBeats * subdivision);
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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 _chunk7MGZ7D62cjs.dropSilentNotes.call(void 0, events)) {
+    const { quantizedBeat, slotIndex } = quantizeToGrid(
+      event.startBeat,
+      barBeats,
+      subdivision,
+      slotsPerBar
+    );
+    offsetSums[slotIndex] = (_nullishCoalesce(offsetSums[slotIndex], () => ( 0))) + (event.startBeat - quantizedBeat);
+    counts[slotIndex] = (_nullishCoalesce(counts[slotIndex], () => ( 0))) + 1;
+    if (event.velocity !== void 0) {
+      velocitySums[slotIndex] = (_nullishCoalesce(velocitySums[slotIndex], () => ( 0))) + event.velocity;
+      velocityCounts[slotIndex] = (_nullishCoalesce(velocityCounts[slotIndex], () => ( 0))) + 1;
+    }
+  }
+  const slots = [];
+  for (let i = 0; i < slotsPerBar; i += 1) {
+    const count = _nullishCoalesce(counts[i], () => ( 0));
+    if (count === 0) {
+      slots.push({ timingOffset: 0, velocity: null });
+      continue;
+    }
+    const velocityCount = _nullishCoalesce(velocityCounts[i], () => ( 0));
+    slots.push({
+      timingOffset: (_nullishCoalesce(offsetSums[i], () => ( 0))) / count,
+      velocity: velocityCount > 0 ? (_nullishCoalesce(velocitySums[i], () => ( 0))) / velocityCount : null
+    });
+  }
+  return { subdivision, slotsPerBar, slots, ts };
+}
+function applyGrooveTemplate(events, template, ts) {
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, events, "groove target events", { allowNonPositiveDuration: true });
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, template.subdivision, "template subdivision");
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, template.slotsPerBar, "template slotsPerBar");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, template.slots.length, "template slots");
+  if (template.slots.length !== template.slotsPerBar) {
+    throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)("template slots length must equal slotsPerBar");
+  }
+  if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
+    throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)(
+      `Groove template meter ${_chunk36N73KZ3cjs.formatTimeSignature.call(void 0, template.ts)} does not match apply-time meter ${_chunk36N73KZ3cjs.formatTimeSignature.call(void 0, ts)}`
+    );
+  }
+  const barBeats = _chunk36N73KZ3cjs.beatsPerBar.call(void 0, ts);
+  return _chunk7MGZ7D62cjs.dropSilentNotes.call(void 0, events).map((event) => {
+    const { quantizedBeat, slotIndex } = quantizeToGrid(
+      event.startBeat,
+      barBeats,
+      template.subdivision,
+      template.slotsPerBar
+    );
+    const slot = template.slots[slotIndex];
+    const startBeat = quantizedBeat + (_nullishCoalesce(_optionalChain([slot, 'optionalAccess', _21 => _21.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: _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, 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 = _chunkFNDWXRRIcjs.majorKey.call(void 0, 0);
+  let bestScore = Number.NEGATIVE_INFINITY;
+  const candidates = [];
+  for (let tonic = 0; tonic < 12; tonic += 1) {
+    candidates.push(_chunkFNDWXRRIcjs.majorKey.call(void 0, tonic), _chunkFNDWXRRIcjs.minorKey.call(void 0, tonic));
+  }
+  for (const key of candidates) {
+    const tonic = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc);
+    const isMinor = key.modeMask12 === _chunkFNDWXRRIcjs.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 = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, n.pitch);
+      if (_chunkFNDWXRRIcjs.isScaleTone.call(void 0, 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 = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder.call(void 0, key);
+  const candidates = tones.map((rootPc, degree) => {
+    const quality = _chunkFNDWXRRIcjs.diatonicTriad.call(void 0, degree, key).quality;
+    return {
+      rootPc,
+      quality,
+      degree,
+      secondaryDominant: false,
+      base: 0,
+      pcs: _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, rootPc, quality))
+    };
+  });
+  if (reharmonize !== "diatonic") {
+    for (const target of [1, 3, 4, 5]) {
+      const targetRoot = _nullishCoalesce(tones[target], () => ( 0));
+      const rootPc = (targetRoot + 7) % 12;
+      candidates.push({
+        rootPc,
+        quality: "dom7",
+        secondaryDominant: true,
+        targetDegree: target,
+        base: 1.5,
+        pcs: _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, rootPc, "dom7"))
+      });
+    }
+  }
+  if (reharmonize === "borrowed") {
+    const parallel = _chunkCAN76NCUcjs.parallelKey.call(void 0, key);
+    const parallelTones = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder.call(void 0, parallel);
+    for (let degree = 0; degree < parallelTones.length; degree += 1) {
+      const chord = _chunkFNDWXRRIcjs.diatonicTriad.call(void 0, degree, parallel);
+      if (!_chunkCAN76NCUcjs.isDiatonic.call(void 0, chord, key)) {
+        candidates.push({
+          rootPc: chord.rootPc,
+          quality: chord.quality,
+          secondaryDominant: false,
+          base: 1.25,
+          pcs: _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, 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(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, note.pitch))) {
+      continue;
+    }
+    const strong = _chunk36N73KZ3cjs.isStrongBeat.call(void 0, overlapStart, ts);
+    cost += (strong ? 10 : 2) * w;
+    if (!_chunkFNDWXRRIcjs.isScaleTone.call(void 0, 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 = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc);
+  const n = candidates.length;
+  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
+  const seg0 = segments[0];
+  let dp = candidates.map(
+    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key, ts) : 0) + (_nullishCoalesce(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 = (_nullishCoalesce(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) + (_nullishCoalesce(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 = (_nullishCoalesce(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 = _nullishCoalesce(path[s + 1], () => ( bestEnd));
+    path[s] = ptr ? _nullishCoalesce(ptr[nextIdx], () => ( bestEnd)) : bestEnd;
+  }
+  return { cost: bestCost, path };
+}
+function harmonizeMelody(opts) {
+  const noteIndex = _chunk36N73KZ3cjs.createNoteEventIndex.call(void 0, opts.melody, { allowNonPositiveDuration: true });
+  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_METER));
+  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  const requestedKey = _nullishCoalesce(opts.key, () => ( "infer"));
+  const key = requestedKey === "infer" ? inferKey(opts.melody) : requestedKey;
+  const placement = _nullishCoalesce(opts.placement, () => ( DEFAULT_PLACEMENT));
+  if (noteIndex.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
+    return { transposeSemitones: 0, key, chords: [], melodyRoles: [] };
+  }
+  const candidates = buildCandidates(key, _nullishCoalesce(opts.reharmonize, () => ( "diatonic")));
+  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(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 = _chunk7MGZ7D62cjs.assertRange.call(void 0, 
+    _nullishCoalesce(opts.harmonicRhythm, () => ( DEFAULT_HARMONIC_RHYTHM)),
+    Number.MIN_VALUE,
+    Number.MAX_SAFE_INTEGER,
+    "harmonic rhythm"
+  );
+  const segCount = Math.max(1, Math.ceil(melodyEnd / hr));
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, segCount, "harmonic segments");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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);
+    _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, memberships, "note-to-segment memberships");
+    for (let segment = first; segment < lastExclusive; segment += 1) {
+      _optionalChain([segments, 'access', _22 => _22[segment], 'optionalAccess', _23 => _23.noteIndices, 'access', _24 => _24.push, 'call', _25 => _25(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: _nullishCoalesce(_optionalChain([segments, 'access', _26 => _26[s], 'optionalAccess', _27 => _27.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(_nullishCoalesce(bestPath[segIdx], () => ( 0)));
+    const chord = _chunkFNDWXRRIcjs.makeChord.call(void 0, cand.rootPc, cand.quality);
+    return { noteIndex: noteIndex2, role: _chunkFCANXBATcjs.roleOf.call(void 0, 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 (_chunkFNDWXRRIcjs.isScaleTone.call(void 0, pitch + d, key)) {
+      return pitch + d;
+    }
+  }
+  return pitch + 12;
+}
+function downScaleTone(pitch, key) {
+  for (let d = 1; d <= 12; d += 1) {
+    if (_chunkFNDWXRRIcjs.isScaleTone.call(void 0, pitch - d, key)) {
+      return pitch - d;
+    }
+  }
+  return pitch - 12;
+}
+function stepDiatonic(pitch, degrees, key) {
+  let p = _chunkFNDWXRRIcjs.nearestScaleTone.call(void 0, 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 = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord);
+  for (let d = 0; d <= 12; d += 1) {
+    if (pcs.includes(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, pitch - d))) {
+      return pitch - d;
+    }
+    if (pcs.includes(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, 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(_nullishCoalesce([0, 1, 0, -1][i % 4], () => ( 0)));
+        break;
+    }
+  }
+  return offsets;
+}
+function generateMotif(opts) {
+  const contour = _nullishCoalesce(opts.contour, () => ( "arch"));
+  const bars = _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, opts.bars, "motif bars");
+  const barBeats = _chunk36N73KZ3cjs.beatsPerBar.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS4)));
+  const totalBeats = bars * barBeats;
+  const noteCount = Math.max(3, bars * 2);
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, noteCount, "motif notes");
+  const beatsPerNote = totalBeats / noteCount;
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, _nullishCoalesce(opts.seed, () => ( 0)));
+  const requestedJitter = _chunk7MGZ7D62cjs.assertFiniteNumber.call(void 0, _nullishCoalesce(opts.jitter, () => ( 0)), "motif jitter");
+  const jitterProb = Math.min(1, Math.max(0, requestedJitter));
+  const tonic = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, 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, (_nullishCoalesce(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 (0, _chunk7MGZ7D62cjs.InvalidInputError)(
+        `transformed motif pitch ${note.pitch} is outside the MIDI range 0..127`
+      );
+    }
+  }
+  return cell;
+}
+function transformUnchecked(cell, t, amount, key) {
+  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, cell.notes, "motif notes");
+  if (amount !== void 0) {
+    _chunk7MGZ7D62cjs.assertFiniteNumber.call(void 0, amount, "motif transform amount");
+  }
+  if ((t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
+    _chunk7MGZ7D62cjs.assertInteger.call(void 0, amount, "diatonic transform amount");
+  }
+  if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
+    throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)("time transform amount must be positive");
+  }
+  const notes = cell.notes;
+  switch (t) {
+    case "transposeChromatic": {
+      const semis = _nullishCoalesce(amount, () => ( 0));
+      return { notes: notes.map((n) => ({ ...n, pitch: n.pitch + semis })) };
+    }
+    case "transposeDiatonic": {
+      const degrees = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([notes, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.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, _nullishCoalesce(amount, () => ( 2)));
+    case "diminish":
+      return scaleTime(cell, 1 / (_nullishCoalesce(amount, () => ( 2))));
+    case "sequence": {
+      const degrees = _nullishCoalesce(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) {
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, bars, "development bars");
+  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, cell.notes, "motif notes");
+  const span = cellSpan(cell);
+  const totalBeats = bars * _chunk36N73KZ3cjs.beatsPerBar.call(void 0, 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);
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, 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 = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord).includes(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, pitch));
+        pitch = isMember ? pitch : nearestChordTone(pitch, chord);
+      } else {
+        pitch = _chunkFNDWXRRIcjs.nearestScaleTone.call(void 0, 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 = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder.call(void 0, key);
+    return tones.length > 0 ? _nullishCoalesce(tones[degree % tones.length], () => ( key.rootPc % 12)) : key.rootPc % 12;
+  }
+  const offset = _nullishCoalesce(BORROWED_OFFSET[degree], () => ( 0));
+  return ((key.rootPc % 12 + offset) % 12 + 12) % 12;
+}
+function autoQuality(degree, key) {
+  if (degree >= 0 && degree <= 6) {
+    return _chunkFNDWXRRIcjs.diatonicTriad.call(void 0, 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 (0, _chunk7MGZ7D62cjs.InvalidInputError)(`Unknown progression style: ${style}`);
+  }
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, seed);
+  const index = Math.floor(rng.next() * pool.length) % pool.length;
+  return _nullishCoalesce(pool[index], () => ( PRESETS[0]));
+}
+function generateProgression(opts) {
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, opts.bars, "progression bars");
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, opts.bars, "progression chords");
+  const seed = _nullishCoalesce(opts.seed, () => ( 0));
+  let preset;
+  if (opts.preset !== void 0) {
+    if (opts.preset.degrees.length === 0) {
+      throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)("progression preset must name at least one degree");
+    }
+    preset = {
+      id: _nullishCoalesce(opts.preset.id, () => ( "custom")),
+      name: _nullishCoalesce(opts.preset.name, () => ( "Custom")),
+      degrees: opts.preset.degrees,
+      functional: _nullishCoalesce(opts.preset.functional, () => ( "loop")),
+      styles: _nullishCoalesce(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 (0, _chunk7MGZ7D62cjs.InvalidInputError)(`Unknown progression preset: ${opts.presetId}`);
+    }
+  }
+  preset ??= pickProgressionPreset(opts.style, seed);
+  const cycle = resolveCycle(_nullishCoalesce(_optionalChain([preset, 'optionalAccess', _30 => _30.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: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _31 => _31.rootPc]), () => ( 0)),
+      quality: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _32 => _32.quality]), () => ( "maj")),
+      startBeat: bar * 4
+    };
+    if (_optionalChain([step, 'optionalAccess', _33 => _33.degree]) !== void 0) {
+      chord.degree = step.degree;
+    }
+    chords.push(chord);
+  }
+  if (opts.reharmonize) {
+    const tonicPc = (opts.key.rootPc % 12 + 12) % 12;
+    const rrng = _chunkRUMU3UA6cjs.createRng.call(void 0, (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 = _optionalChain([chords, 'access', _34 => _34[i - 1], 'optionalAccess', _35 => _35.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) {
+  _chunk7MGZ7D62cjs.assertFiniteNumber.call(void 0, pitch, "pitch");
+  _chunk7MGZ7D62cjs.assertRange.call(void 0, 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 = _nullishCoalesce(opts.seed, () => ( 0));
+  const bars = _nullishCoalesce(opts.bars, () => ( DEFAULT_BARS));
+  const subdivision = _nullishCoalesce(opts.subdivision, () => ( DEFAULT_SUBDIVISION));
+  const density = _chunk7MGZ7D62cjs.assertRange.call(void 0, _nullishCoalesce(opts.density, () => ( DEFAULT_DENSITY)), 0, 1, "rhythm density");
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, bars, "rhythm bars");
+  _chunk7MGZ7D62cjs.assertPositiveInt.call(void 0, subdivision, "rhythm subdivision");
+  const barBeats = _chunk36N73KZ3cjs.beatsPerBar.call(void 0, ts);
+  const spanBeats = barBeats * bars;
+  const step = 1 / subdivision;
+  const slotCount = Math.round(spanBeats * subdivision);
+  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, slotCount, "rhythm grid slots");
+  const slotsPerBar = Math.round(barBeats * subdivision);
+  const rng = _chunkRUMU3UA6cjs.createRng.call(void 0, 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 = _chunk36N73KZ3cjs.metricWeight.call(void 0, 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 = _nullishCoalesce(positions[i], () => ( 0));
+    const nextPosition = _nullishCoalesce(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 = (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _36 => _36.position]), () => ( 0))) + (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _37 => _37.duration]), () => ( 0)));
+  const bars = spanBeats / _chunk36N73KZ3cjs.beatsPerBar.call(void 0, ts);
+  return bars > 0 ? events.length / bars : 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BASS_STYLES = BASS_STYLES; exports.generateBassLine = generateBassLine; exports.generateCounterMelody = generateCounterMelody; exports.DRUM_NOTES = DRUM_NOTES; exports.drumVoiceOf = drumVoiceOf; exports.generateDrums = generateDrums; exports.humanize = humanize; exports.extractGrooveTemplate = extractGrooveTemplate; exports.applyGrooveTemplate = applyGrooveTemplate; exports.harmonizeMelody = harmonizeMelody; exports.generateMotif = generateMotif; exports.motifToNoteEvents = motifToNoteEvents; exports.transformMotif = transformMotif; exports.developMotif = developMotif; exports.BORROWED_DEGREES = BORROWED_DEGREES; exports.progressions = progressions; exports.progressionsByStyle = progressionsByStyle; exports.pickProgressionPreset = pickProgressionPreset; exports.generateProgression = generateProgression; exports.rhythmToNoteEvents = rhythmToNoteEvents; exports.onsetWeightCurve = onsetWeightCurve; exports.generateRhythm = generateRhythm; exports.rhythmDensity = rhythmDensity;
+//# sourceMappingURL=chunk-4HLLZPXT.cjs.map