@libraz/libcantus 0.9.3 → 0.9.5

package/dist/{chunk-4MHA432G.js → chunk-AID75RN3.js}

@@ -1,27 +1,29 @@
 import {
   createRng
-} from "./chunk-62QZKCJQ.js";
+} from "./chunk-ZGLJM4A4.js";
 import {
   beatsPerBar,
   createNoteEventIndex,
   formatTimeSignature,
   isStrongBeat,
-  metricWeight
-} from "./chunk-I5R7ZBJS.js";
+  metricWeight,
+  pulseBeats
+} from "./chunk-2PTFGVD7.js";
 import {
   isDiatonic,
   parallelKey
-} from "./chunk-CHMXELDS.js";
+} from "./chunk-NNB67XA2.js";
 import {
   roleOf
-} from "./chunk-2ZWMSJH6.js";
+} from "./chunk-HN2OEUN2.js";
 import {
   enumerateSafePitches,
   evaluateSafety
-} from "./chunk-EH6EM37U.js";
+} from "./chunk-DZMHIGI4.js";
 import {
   NATURAL_MINOR_MASK,
   chordPitchClasses,
+  chordQualities,
   chordToneRole,
   createsParallelPerfect,
   diatonicTriad,
@@ -32,18 +34,32 @@ import {
   minorKey,
   nearestScaleTone,
   scaleTonesInDegreeOrder
-} from "./chunk-MIWO425M.js";
+} from "./chunk-KBTTEX7Q.js";
 import {
+  InvalidInputError,
+  assertDegree,
   assertFiniteNumber,
   assertGenerationBudget,
   assertInteger,
   assertNoteEvents,
+  assertOneOf,
   assertPositiveInt,
   assertRange,
-  assertTimeSignature
-} from "./chunk-FBQK3ZQN.js";
+  assertTimeSignature,
+  clampToMidi,
+  dropSilentNotes,
+  pitchClassOf,
+  soundingNotesOnly
+} from "./chunk-R2VVFAIN.js";
 
 // src/generate/bass/index.ts
+var BASS_STYLES = Object.freeze([
+  "root",
+  "rootFifth",
+  "pop",
+  "walking",
+  "arpeggio"
+]);
 var DEFAULT_TS = { numerator: 4, denominator: 4 };
 var DEFAULT_STYLE = "root";
 var DEFAULT_OCTAVE = 2;
@@ -51,9 +67,6 @@ var STRONG_VELOCITY = 100;
 var WEAK_VELOCITY = 80;
 var PICKUP_PROB = 0.35;
 var EPS = 1e-9;
-function pitchClass(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
 function placePc(pc, anchor, low) {
   const high = low + 12;
   let midi = pc + 12 * Math.round((anchor - pc) / 12);
@@ -69,29 +82,43 @@ function chordTonePcs(chord) {
   const seen = /* @__PURE__ */ new Set();
   const pcs = [];
   for (const interval of chord.intervals) {
-    const pc = pitchClass(chord.rootPc + interval);
+    const pc = pitchClassOf(chord.rootPc + interval);
     if (!seen.has(pc)) {
       seen.add(pc);
       pcs.push(pc);
     }
   }
   if (pcs.length === 0) {
-    pcs.push(pitchClass(chord.rootPc));
+    pcs.push(pitchClassOf(chord.rootPc));
   }
   return pcs;
 }
 function fifthPcOf(chord) {
-  const fifths = new Set(chord.intervals.map((i) => pitchClass(i)));
+  const fifths = new Set(chord.intervals.map((i) => pitchClassOf(i)));
   const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
-  return chosen === void 0 ? pitchClass(chord.rootPc) : pitchClass(chord.rootPc + chosen);
+  return chosen === void 0 ? pitchClassOf(chord.rootPc) : pitchClassOf(chord.rootPc + chosen);
 }
 function bassPcOf(chord) {
-  return pitchClass(chord.bassPc ?? chord.rootPc);
+  return pitchClassOf(chord.bassPc ?? chord.rootPc);
 }
-function beatPositions(start, end) {
+function beatPositions(start, end, ts) {
   const positions = [];
-  for (let p = start; p < end - EPS; p += 1) {
-    positions.push(p);
+  const barBeats = beatsPerBar(ts);
+  const pulse = pulseBeats(ts);
+  const firstBar = Math.floor(start / barBeats);
+  const lastBar = Math.floor((end - EPS) / barBeats);
+  for (let bar = firstBar; bar <= lastBar; bar += 1) {
+    const barStart = bar * barBeats;
+    const firstPulse = Math.max(0, Math.ceil((start - barStart - EPS) / pulse));
+    for (let index = firstPulse; ; index += 1) {
+      const position = barStart + index * pulse;
+      if (position >= barStart + barBeats - EPS || position >= end - EPS) {
+        break;
+      }
+      if (position >= start - EPS) {
+        positions.push(position);
+      }
+    }
   }
   if (positions.length === 0) {
     positions.push(start);
@@ -99,7 +126,10 @@ function beatPositions(start, end) {
   return positions;
 }
 function emit(ctx, pos, pc, midiOverride) {
-  const midi = midiOverride ?? placePc(pc, ctx.prevMidi, ctx.low);
+  const midi = clampToMidi(
+    midiOverride ?? placePc(pc, ctx.prevMidi, ctx.low),
+    "generated bass pitch"
+  );
   const velocity = isStrongBeat(pos, ctx.ts) ? STRONG_VELOCITY : WEAK_VELOCITY;
   ctx.notes.push({ startBeat: pos, pitch: midi, velocity });
   return midi;
@@ -115,7 +145,7 @@ function buildRootFifth(ctx, seg) {
   }
 }
 function buildPop(ctx, seg) {
-  const positions = beatPositions(seg.startBeat, seg.endBeat);
+  const positions = beatPositions(seg.startBeat, seg.endBeat, ctx.ts);
   const rootPc = bassPcOf(seg.chord);
   let emitted = false;
   for (const pos of positions) {
@@ -125,7 +155,8 @@ function buildPop(ctx, seg) {
     } else if (ctx.rng.prob(PICKUP_PROB)) {
       if (ctx.rng.prob(0.5)) {
         const base = placePc(rootPc, ctx.prevMidi, ctx.low);
-        emit(ctx, pos, rootPc, Math.max(ctx.low, base - 12));
+        const dropped = base - 12;
+        emit(ctx, pos, rootPc, dropped >= 0 ? dropped : base);
       } else {
         ctx.prevMidi = emit(ctx, pos, fifthPcOf(seg.chord));
       }
@@ -137,7 +168,7 @@ function buildPop(ctx, seg) {
 }
 function buildArpeggio(ctx, seg) {
   const tones = chordTonePcs(seg.chord);
-  const positions = beatPositions(seg.startBeat, seg.endBeat);
+  const positions = beatPositions(seg.startBeat, seg.endBeat, ctx.ts);
   positions.forEach((pos, i) => {
     const pc = tones[i % tones.length] ?? bassPcOf(seg.chord);
     ctx.prevMidi = emit(ctx, pos, pc);
@@ -145,16 +176,27 @@ function buildArpeggio(ctx, seg) {
 }
 function approachNote(ctx, target, from) {
   const dir = from <= target ? -1 : 1;
+  const chromatic = target + dir;
   if (ctx.rng.prob(0.5)) {
-    return target + dir;
+    return foldIntoBand(chromatic, ctx.low);
   }
   const cand = nearestScaleTone(target + dir * 2, ctx.key);
   const step = Math.abs(cand - target);
-  return step >= 1 && step <= 2 ? cand : target + dir;
+  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 positions = beatPositions(seg.startBeat, seg.endBeat, ctx.ts);
   const count = positions.length;
   positions.forEach((pos, i) => {
     if (i === 0) {
@@ -164,7 +206,7 @@ function buildWalking(ctx, seg, next) {
     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, pitchClass(midi), midi);
+      ctx.prevMidi = emit(ctx, pos, pitchClassOf(midi), midi);
       return;
     }
     const pc = tones[i % tones.length] ?? bassPcOf(seg.chord);
@@ -179,18 +221,27 @@ function generateBassLine(opts) {
     assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
     assertRange(segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
     if (segment.endBeat <= segment.startBeat) {
-      throw new RangeError(`segments[${index}] must have a positive duration`);
+      throw new InvalidInputError(`segments[${index}] must have a positive duration`);
     }
   }
   const segments = [...opts.segments].sort((a, b) => a.startBeat - b.startBeat);
+  for (let index = 1; index < segments.length; index += 1) {
+    const previous = segments[index - 1];
+    const current = segments[index];
+    if (previous !== void 0 && current !== void 0 && current.startBeat < previous.endBeat) {
+      throw new InvalidInputError(
+        `bass segments must not overlap: segments ${index - 1} and ${index} overlap`
+      );
+    }
+  }
   if (segments.length === 0) {
     return [];
   }
   const ts = opts.ts ?? DEFAULT_TS;
   assertTimeSignature(ts);
-  const style = opts.style ?? DEFAULT_STYLE;
+  const style = assertOneOf(opts.style ?? DEFAULT_STYLE, BASS_STYLES, "bass style");
   const octave = opts.octave ?? DEFAULT_OCTAVE;
-  assertInteger(octave, "bass octave", -1, 9);
+  assertInteger(octave, "bass octave", -1, 8);
   const estimatedNotes = segments.reduce(
     (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
     0
@@ -242,7 +293,7 @@ function generateBassLine(opts) {
       continue;
     }
     out.push({
-      pitch: note.pitch,
+      pitch: clampToMidi(note.pitch, "generated bass pitch"),
       startBeat: note.startBeat,
       durationBeat,
       velocity: note.velocity
@@ -263,6 +314,7 @@ 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;
 }
@@ -365,26 +417,40 @@ function heldNoteBoundaries(melody, startBeat, endBeat, chordChangeBeats) {
   }
   return [...boundaries].sort((a, b) => a - b);
 }
-function heldPitchSafety(pitch, startBeat, endBeat, prevPitch, melody, opts, profile, register, low, high, ts) {
-  let worst = 0 /* Safe */;
-  const boundaries = heldNoteBoundaries(melody, startBeat, endBeat, opts.chordChangeBeats ?? []);
-  for (const boundary of boundaries) {
+function boundaryContexts(melody, harmony, startBeat, endBeat, ts) {
+  const boundaries = heldNoteBoundaries(melody, startBeat, endBeat, harmony.chordChangeBeats);
+  return boundaries.map((boundary) => {
     const melodyVoice = melodySnapshotAt(melody, boundary);
+    return {
+      melodyVoice,
+      otherVoices: melodyVoice === void 0 ? [] : [melodyVoice],
+      chord: harmony.chordAt(boundary),
+      strongBeat: isStrongBeat(boundary, ts),
+      atCounterOnset: Math.abs(boundary - startBeat) < EPS2
+    };
+  });
+}
+function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low, high) {
+  let worst = 0 /* Safe */;
+  for (const context of contexts) {
+    const melodyVoice = context.melodyVoice;
     if (melodyVoice !== void 0 && (register === "below" && pitch >= melodyVoice.pitch || register === "above" && pitch <= melodyVoice.pitch)) {
       return null;
     }
-    const atCounterOnset = Math.abs(boundary - startBeat) < EPS2;
-    const result = evaluateSafety({
-      profile,
-      candidatePitch: pitch,
-      prevPitch: atCounterOnset ? prevPitch : pitch,
-      chord: opts.chordAt(boundary),
-      key: opts.key,
-      otherVoices: melodyVoice ? [melodyVoice] : [],
-      strongBeat: isStrongBeat(boundary, ts),
-      vocalLow: low,
-      vocalHigh: high
-    });
+    const result = evaluateSafety(
+      {
+        profile,
+        candidatePitch: pitch,
+        prevPitch: context.atCounterOnset ? prevPitch : pitch,
+        chord: context.chord,
+        key,
+        otherVoices: context.otherVoices,
+        strongBeat: context.strongBeat,
+        vocalLow: low,
+        vocalHigh: high
+      },
+      { suggestions: false }
+    );
     worst = Math.max(worst, result.safety);
     if (worst === 2 /* Dissonant */) {
       return worst;
@@ -393,35 +459,48 @@ function heldPitchSafety(pitch, startBeat, endBeat, prevPitch, melody, opts, pro
   return worst;
 }
 function generateCounterMelody(opts) {
-  const melody = createNoteEventIndex(opts.melody);
-  if (melody.notes.length === 0) {
-    return [];
+  const timeline = opts.timeline;
+  const chordAt = timeline === void 0 ? opts.chordAt : (beat) => timeline.at(beat);
+  if (chordAt === void 0) {
+    throw new TypeError("countermelody needs a timeline or a chordAt callback");
   }
+  const chordChangeBeats = timeline === void 0 ? opts.chordChangeBeats ?? [] : timeline.segments.flatMap((segment) => [segment.startBeat, segment.endBeat]);
+  const register = opts.register ?? "below";
+  assertNoteEvents(opts.melody, "countermelody melody", { allowNonPositiveDuration: true });
+  const melody = createNoteEventIndex(soundingNotesOnly(opts.melody), {
+    tieBreak: register === "below" ? "highest" : "lowest"
+  });
   const ts = opts.ts ?? DEFAULT_TS2;
   assertTimeSignature(ts);
-  const register = opts.register ?? "below";
-  const rhythm = opts.rhythm ?? "complement";
-  const profile = opts.profile ?? "pop";
+  const rhythm = assertOneOf(opts.rhythm ?? "complement", ["complement", "follow"], "rhythm");
+  const profile = assertOneOf(opts.profile ?? "pop", ["strict", "pop"], "safety profile");
   const rng = createRng(opts.seed ?? 0);
+  if (melody.notes.length === 0) {
+    return [];
+  }
   const spanStart = melody.notes[0]?.note.startBeat ?? 0;
   const spanEnd = melody.notes.reduce((end, n) => Math.max(end, n.endBeat), spanStart);
   assertGenerationBudget(Math.ceil((spanEnd - spanStart) / GRID_STEP), "countermelody grid");
   const meanPitch = melody.notes.reduce((sum, n) => sum + n.note.pitch, 0) / melody.notes.length;
   const defaultCenter = register === "below" ? meanPitch - REGISTER_OFFSET : meanPitch + REGISTER_OFFSET;
-  const low = opts.pitchLow ?? Math.round(defaultCenter) - DEFAULT_HALF_RANGE;
-  const high = opts.pitchHigh ?? Math.round(defaultCenter) + DEFAULT_HALF_RANGE;
-  assertInteger(low, "countermelody pitchLow");
-  assertInteger(high, "countermelody pitchHigh");
+  const low = clampToMidi(
+    opts.pitchLow ?? Math.round(defaultCenter) - DEFAULT_HALF_RANGE,
+    "countermelody pitchLow"
+  );
+  const high = clampToMidi(
+    opts.pitchHigh ?? Math.round(defaultCenter) + DEFAULT_HALF_RANGE,
+    "countermelody pitchHigh"
+  );
   if (low > high) {
-    throw new RangeError(
+    throw new InvalidInputError(
       `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
     );
   }
   assertGenerationBudget(high - low + 1, "countermelody pitch candidates");
-  assertGenerationBudget(opts.chordChangeBeats?.length ?? 0, "chord change beats");
-  for (let index = 0; index < (opts.chordChangeBeats?.length ?? 0); index += 1) {
+  assertGenerationBudget(chordChangeBeats.length, "chord change beats");
+  for (let index = 0; index < chordChangeBeats.length; index += 1) {
     assertRange(
-      opts.chordChangeBeats?.[index] ?? Number.NaN,
+      chordChangeBeats[index] ?? Number.NaN,
       0,
       Number.MAX_SAFE_INTEGER,
       `chordChangeBeats[${index}]`
@@ -429,7 +508,9 @@ function generateCounterMelody(opts) {
   }
   const center = (low + high) / 2;
   const onsets = rhythm === "follow" ? followOnsets(melody) : complementOnsets(melody, ts, spanStart, spanEnd, rng);
-  assertGenerationBudget(onsets.length * (high - low + 1), "countermelody search");
+  const boundaryEstimate = onsets.length + Math.ceil((spanEnd - spanStart) / GRID_STEP) + melody.notes.length + chordChangeBeats.length;
+  assertGenerationBudget(boundaryEstimate * (high - low + 1), "countermelody search");
+  const jitter = Array.from({ length: high - low + 1 }, () => rng.next() * TIE_BREAK_JITTER);
   const out = [];
   let prevPitch;
   for (let onsetIndex = 0; onsetIndex < onsets.length; onsetIndex += 1) {
@@ -443,7 +524,8 @@ function generateCounterMelody(opts) {
     const melPitch = melNote?.pitch;
     const melodyVoice = melodySnapshotAt(melody, beat);
     const melPrev = melodyVoice?.prevPitch;
-    const chord = opts.chordAt(beat);
+    const contexts = boundaryContexts(melody, { chordAt, chordChangeBeats }, beat, endBeat, ts);
+    const chord = contexts[0]?.chord ?? chordAt(beat);
     const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
     const candidates = enumerateSafePitches(
       {
@@ -465,16 +547,13 @@ function generateCounterMelody(opts) {
     for (const candidate of candidates) {
       const worstSafety = heldPitchSafety(
         candidate,
-        beat,
-        endBeat,
+        contexts,
         prevPitch,
-        melody,
-        opts,
+        opts.key,
         profile,
         register,
         low,
-        high,
-        ts
+        high
       );
       if (worstSafety === null || worstSafety === 2 /* Dissonant */) {
         continue;
@@ -486,7 +565,7 @@ function generateCounterMelody(opts) {
           continue;
         }
       }
-      const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center);
+      const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center) + (jitter[candidate - low] ?? 0);
       const tie = Math.abs(score - bestScore) <= EPS2 && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
       if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS2 || tie)) {
         bestWorstSafety = worstSafety;
@@ -503,7 +582,12 @@ function generateCounterMelody(opts) {
       1,
       Math.min(127, Math.round((melNote?.velocity ?? DEFAULT_MELODY_VELOCITY) - VELOCITY_DROP))
     );
-    out.push({ pitch, startBeat: beat, durationBeat: endBeat - beat, velocity });
+    out.push({
+      pitch: clampToMidi(pitch),
+      startBeat: beat,
+      durationBeat: endBeat - beat,
+      velocity
+    });
     prevPitch = pitch;
   }
   return out;
@@ -528,6 +612,27 @@ var GM = {
 };
 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 },
@@ -727,7 +832,7 @@ function getGhostDensity(mood, section, backingDensity, bpm) {
   }
   return levelToProbability(level);
 }
-function getGhostVelocity(section, beatPosition, isAfterSnare) {
+function getGhostVelocity(section, beatPosition) {
   let base = 0.4;
   const even = beatPosition % 2 === 0 ? 0.05 : 0;
   switch (section) {
@@ -748,22 +853,16 @@ function getGhostVelocity(section, beatPosition, isAfterSnare) {
       base = 0.38;
       break;
   }
-  if (isAfterSnare) {
-    base += 0.1;
-  }
   return Math.max(0.25, Math.min(0.65, base));
 }
 function getGhostProbabilityAtPosition(beat, sixteenthInBeat) {
-  const nearSnare = beat === 0 && sixteenthInBeat === 3 || beat === 1 && sixteenthInBeat === 1 || beat === 2 && sixteenthInBeat === 3 || beat === 3 && sixteenthInBeat === 1;
-  return nearSnare ? 0.6 : 0.25;
+  const leadsIntoBackbeat = (beat === 0 || beat === 2) && sixteenthInBeat === 3;
+  return leadsIntoBackbeat ? 0.6 : 0.25;
 }
-function selectGhostPositions(mood, rng) {
+function selectGhostPositions(mood) {
   if (mood === 2 /* Energetic */) {
     return ["e", "a"];
   }
-  if (mood === 0 /* Calm */) {
-    return rng.prob(0.5) ? ["e"] : [];
-  }
   return ["e"];
 }
 
@@ -779,6 +878,9 @@ function roleHiHatInstrument(role, useRide) {
   if (role === "ambient") {
     return GM.RIDE;
   }
+  if (role === "minimal") {
+    return GM.FHH;
+  }
   return useRide ? GM.RIDE : GM.CHH;
 }
 function sparser(level) {
@@ -1038,10 +1140,7 @@ function quantizeSwing(startBeat, swing, resolution) {
 }
 
 // src/generate/drums/beat.ts
-function swing16(tick, feel, swingAmount) {
-  return quantizeSwing(tick, effectiveSwing(feel, swingAmount), "sixteenth");
-}
-function hatSwingFactor(style) {
+function styleSwingFactor(style) {
   if (style === "trap") {
     return 0;
   }
@@ -1050,6 +1149,12 @@ function hatSwingFactor(style) {
   }
   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;
@@ -1060,7 +1165,7 @@ function generateKickForBeat(ctx, sec, kick) {
     ctx.track.add(GM.BD, ctx.beatTick, EIGHTH, ctx.velocity);
   }
   if (and) {
-    const andTick = swing16(ctx.beatTick + EIGHTH, sec.feel, ctx.swingAmount);
+    const andTick = swing16(ctx.beatTick + EIGHTH, sec, ctx.swingAmount);
     ctx.track.add(GM.BD, andTick, EIGHTH, ctx.velocity * 0.85);
   }
 }
@@ -1077,12 +1182,17 @@ function generateSnareForBeat(ctx, sec, isIntroFirst) {
   }
   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") {
-    if (sec.role !== "fxOnly" && sec.role !== "minimal") {
-      ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.8);
-    }
+    ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.8);
   } else {
     ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
   }
@@ -1091,7 +1201,7 @@ function generateGhostNotesForBeat(ctx, sec) {
   if (ctx.beat !== 0 && ctx.beat !== 2) {
     return;
   }
-  const positions = selectGhostPositions(sec.ghostMood, ctx.rng);
+  const positions = selectGhostPositions(sec.ghostMood);
   let ghostProb = getGhostDensity(sec.ghostMood, ctx.section, sec.backingDensity, ctx.bpm);
   if (sec.ghostBoost) {
     ghostProb = Math.min(1, ghostProb * 1.4);
@@ -1103,13 +1213,13 @@ function generateGhostNotesForBeat(ctx, sec) {
       continue;
     }
     const variation = ctx.rng.float(0.85, 1.15);
-    const ghostBase = getGhostVelocity(ctx.section, ctx.beat / 2, false);
+    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.feel, ctx.swingAmount);
+    const tick = swing16(ctx.beatTick + offset, sec, ctx.swingAmount);
     ctx.track.add(GM.SD, tick, SIXTEENTH, ghostVel);
   }
 }
@@ -1126,16 +1236,18 @@ function generatePreChorusBuildup(ctx, sec, isSectionLastBar) {
   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);
+  ctx.track.add(
+    GM.SD,
+    swing16(ctx.beatTick + EIGHTH, sec, ctx.swingAmount),
+    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);
@@ -1143,11 +1255,12 @@ function generateHiHatForBeat(ctx, sec) {
   const hhType = sectionHiHatType(ctx.section, sec.role);
   const typeMult = hiHatTypeVelocityMultiplier(hhType);
   const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat;
+  const allowsOpenHiHat = sec.role !== "ambient" && sec.role !== "minimal";
   const dm = sec.densityMult;
   if (sec.hhLevel === "quarter") {
     const introRest = ctx.section === "intro" && ctx.beat !== 0;
     if (!introRest) {
-      if (isDynamicOpen) {
+      if (isDynamicOpen && allowsOpenHiHat) {
         ctx.track.add(
           GM.OHH,
           ctx.beatTick,
@@ -1171,7 +1284,7 @@ function generateHiHatForBeat(ctx, sec) {
     for (let eighth = 0; eighth < 2; eighth += 1) {
       let hhTick = ctx.beatTick + eighth * EIGHTH;
       if (eighth === 1) {
-        hhTick = swing16(hhTick, sec.feel, ctx.swingAmount);
+        hhTick = swing16(hhTick, sec, ctx.swingAmount);
       }
       if (ctx.section === "intro" && eighth === 1) {
         if (sec.useFootHh && ctx.beat % 2 === 0) {
@@ -1180,7 +1293,7 @@ function generateHiHatForBeat(ctx, sec) {
         continue;
       }
       const hhVel = Math.max(20, ctx.velocity * dm * typeMult * (eighth === 0 ? 0.9 : 0.65));
-      if (isDynamicOpen && eighth === 0) {
+      if (isDynamicOpen && allowsOpenHiHat && eighth === 0) {
         ctx.track.add(GM.OHH, hhTick, EIGHTH, hhVel + OHH_VEL_BOOST);
         continue;
       }
@@ -1191,7 +1304,7 @@ function generateHiHatForBeat(ctx, sec) {
       } else if (eighth === 0) {
         useOpen = shouldAddOpenHHAccent(ctx.section, ctx.beat, ctx.bar, ctx.rng);
       }
-      if (useOpen) {
+      if (useOpen && allowsOpenHiHat) {
         ctx.track.add(hiHatNote("open"), hhTick, EIGHTH, Math.max(20, hhVel * 1.1));
       } else {
         ctx.track.add(hhInstrument, hhTick, EIGHTH / 2, hhVel);
@@ -1201,17 +1314,16 @@ function generateHiHatForBeat(ctx, sec) {
   }
   for (let sixteenth = 0; sixteenth < 4; sixteenth += 1) {
     let hhTick = ctx.beatTick + sixteenth * SIXTEENTH;
-    if (sixteenth === 1 || sixteenth === 3) {
-      const swung = effectiveSwing(sec.feel, ctx.swingAmount) * hatSwingFactor(sec.style);
-      hhTick = quantizeSwing(hhTick, swung, "sixteenth");
+    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) {
+    if (isDynamicOpen && allowsOpenHiHat && sixteenth === 0) {
       ctx.track.add(GM.OHH, hhTick, SIXTEENTH, hhVel + OHH_VEL_BOOST);
       continue;
     }
-    if (ctx.beat === 3 && sixteenth === 3) {
+    if (allowsOpenHiHat && 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));
@@ -1266,7 +1378,7 @@ function getFillStartBeat(energy) {
       return 2;
     case "high":
     case "peak":
-      return 0;
+      return 2;
   }
 }
 function selectFillType(from, to, style, nextEnergy, rng) {
@@ -1531,24 +1643,62 @@ function generateFill(track, beatTick, beat, fillType, velocity) {
 }
 
 // src/generate/drums/hit.ts
+var DRUM_NOTES = Object.freeze({
+  kick: GM.BD,
+  snare: GM.SD,
+  sideStick: GM.SIDESTICK,
+  handClap: GM.HANDCLAP,
+  closedHiHat: GM.CHH,
+  pedalHiHat: GM.FHH,
+  openHiHat: GM.OHH,
+  crash: GM.CRASH,
+  ride: GM.RIDE,
+  tambourine: GM.TAMBOURINE,
+  highTom: GM.TOM_H,
+  midTom: GM.TOM_M,
+  lowTom: GM.TOM_L,
+  shaker: GM.SHAKER
+});
+var VOICE_BY_NOTE = new Map(
+  Object.entries(DRUM_NOTES).map(([voice, note]) => [note, voice])
+);
+function drumVoiceOf(pitch) {
+  return VOICE_BY_NOTE.get(pitch);
+}
+var ONSET_KEY_SCALE = 128;
 var HitList = class {
   hits = [];
+  /** Onset keys already occupied, as `pitch:quantizedBeat`. */
+  #onsets = /* @__PURE__ */ new Set();
   /** Append a hit, clamping velocity and dropping non-positive positions. */
   add(pitch, startBeat, durationBeat, velocity) {
+    const beat = Math.max(0, startBeat);
     this.hits.push({
       pitch,
-      startBeat: Math.max(0, startBeat),
+      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) {
-    return this.hits.some(
-      (h) => h.pitch === GM.CRASH && h.startBeat >= startBeat && h.startBeat < startBeat + 0.25
-    );
+    const steps = Math.round(0.25 * ONSET_KEY_SCALE);
+    for (let step = 0; step < steps; step += 1) {
+      if (this.#onsets.has(onsetKey(GM.CRASH, startBeat + step / ONSET_KEY_SCALE))) {
+        return true;
+      }
+    }
+    return false;
   }
 };
+function onsetKey(pitch, startBeat) {
+  return `${pitch}:${Math.round(startBeat * ONSET_KEY_SCALE)}`;
+}
 
 // src/generate/drums/kick.ts
 var EMPTY = {
@@ -1687,12 +1837,12 @@ function getPercussionConfig(mood, section) {
     shaker16th: act[1]
   };
 }
-function generateAuxPercussionForBar(track, barStart, config, role, densityMult, rng, bpm) {
+function generateAuxPercussionForBar(track, barStart, config, role, densityMult, rng, bpm, sec, swingAmount, barBeats = 4) {
   if (role === "minimal") {
     return;
   }
   if (config.tambourine) {
-    for (let beat = 1; beat <= 3; beat += 2) {
+    for (let beat = 1; beat < barBeats; 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)));
     }
@@ -1701,12 +1851,12 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
     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 beat = 0; beat < barBeats; beat += 1) {
         for (let sub = 0; sub < 4; sub += 1) {
           const raw = 80 * (velCurve[sub] ?? 0.5) * densityMult * rng.float(0.9, 1.1);
           track.add(
             GM.SHAKER,
-            barStart + beat + sub * SIXTEENTH,
+            swing16(barStart + beat + sub * SIXTEENTH, sec, swingAmount),
             SIXTEENTH,
             Math.max(25, Math.min(85, raw))
           );
@@ -1714,12 +1864,12 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
       }
     } else {
       const velCurve = [0.75, 0.55];
-      for (let beat = 0; beat < 4; beat += 1) {
+      for (let beat = 0; beat < barBeats; beat += 1) {
         for (let sub = 0; sub < 2; sub += 1) {
           const raw = 80 * (velCurve[sub] ?? 0.6) * densityMult * rng.float(0.9, 1.1);
           track.add(
             GM.SHAKER,
-            barStart + beat + sub * EIGHTH,
+            swing16(barStart + beat + sub * EIGHTH, sec, swingAmount),
             EIGHTH,
             Math.max(25, Math.min(85, raw))
           );
@@ -1728,7 +1878,7 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
     }
   }
   if (config.handclap) {
-    for (let beat = 1; beat <= 3; beat += 2) {
+    for (let beat = 1; beat < barBeats; 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)));
     }
@@ -1736,25 +1886,34 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
 }
 
 // src/generate/drums/index.ts
+var MAX_HITS_PER_BAR = 128;
 function generateDrums(opts) {
   assertPositiveInt(opts.bars, "drum bars");
   assertRange(opts.bpm, Number.MIN_VALUE, 1e3, "drum bpm");
   assertRange(opts.density, 0, 1, "drum density");
-  assertGenerationBudget(opts.bars * 128, "drum hits");
+  assertGenerationBudget(opts.bars * MAX_HITS_PER_BAR, "drum hits");
   if (opts.euclideanKick) {
     const steps = opts.euclideanKick.steps ?? 16;
     assertInteger(steps, "euclidean steps", 1, 16);
     assertInteger(opts.euclideanKick.pulses, "euclidean pulses");
     assertInteger(opts.euclideanKick.rotation ?? 0, "euclidean rotation");
   }
+  const publicStyle = assertOneOf(opts.style, GROOVE_STYLES, "drum style");
+  const publicSection = assertOneOf(opts.section, PUBLIC_SECTIONS, "drum section");
+  if (opts.nextSection !== void 0) {
+    assertOneOf(opts.nextSection, PUBLIC_SECTIONS, "drum nextSection");
+  }
   const track = new HitList();
   const rng = createRng(opts.seed ?? 0);
-  const mapping = mapStyle(opts.style);
+  const mapping = mapStyle(publicStyle);
   const style = mapping.style;
-  const feel = opts.feel ?? mapping.feel;
-  const role = opts.role ?? "full";
+  const feel = opts.feel === void 0 ? mapping.feel : assertOneOf(opts.feel, DRUM_FEELS, "drum feel");
+  const role = opts.role === void 0 ? "full" : assertOneOf(opts.role, DRUM_ROLES, "drum role");
+  const ts = opts.ts ?? { numerator: 4, denominator: 4 };
+  assertTimeSignature(ts, "drum time signature");
+  const barBeats = beatsPerBar(ts);
   const playMainVoices = role !== "fxOnly";
-  const section = mapSection(opts.section);
+  const section = mapSection(publicSection);
   const backingDensity = mapDensity(opts.density);
   const swingAmount = feelSwingAmount(feel);
   let densityMult = sectionDensityMultiplier(section);
@@ -1788,7 +1947,7 @@ function generateDrums(opts) {
   const reuseSectionKick = (section === "b" || section === "chorus") && style !== "sparse";
   let sectionKick;
   for (let bar = 0; bar < opts.bars; bar += 1) {
-    const barStart = bar * 4;
+    const barStart = bar * barBeats;
     const isLastBar = bar === opts.bars - 1;
     if (bar === 0 && section === "chorus") {
       track.add(GM.CRASH, barStart, 0.5, 100 * densityMult);
@@ -1806,9 +1965,9 @@ function generateDrums(opts) {
     } else if (!euclidKick) {
       kick = getKickPattern(section, style, bar, rng);
     }
-    const inLift = isInPreChorusLift(section, bar, opts.bars, section === "b");
+    const inLift = isInPreChorusLift(section, bar, opts.bars, nextSection === "chorus");
     let currentFill = "snareRoll";
-    for (let beat = 0; beat < 4; beat += 1) {
+    for (let beat = 0; beat < barBeats; beat += 1) {
       const beatTick = barStart + beat;
       const velocity = calculateVelocity(section, beat);
       if (opts.fills && isLastBar && !inLift && beat >= fillStartBeat) {
@@ -1845,14 +2004,14 @@ function generateDrums(opts) {
           generatePreChorusBuildup(ctx, sec, isLastBar);
         }
         if (euclidKick && !inLift) {
-          const stepLength = 4 / euclidSteps;
+          const stepLength = barBeats / 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,
+                swing16(barStart + onset, sec, swingAmount),
                 Math.min(0.5, stepLength),
                 velocity * (wholeBeat ? 1 : 0.85)
               );
@@ -1869,10 +2028,9 @@ function generateDrums(opts) {
       generateHiHatForBeat(ctx, sec);
     }
     if (sec.useFootHh && shouldPlayHiHat(role)) {
-      for (let fhhBeat = 0; fhhBeat < 4; fhhBeat += 2) {
+      for (let fhhBeat = 0; fhhBeat < barBeats; fhhBeat += 2) {
         const fhhTick = barStart + fhhBeat;
-        const occupied = track.hits.some((h) => h.pitch === GM.FHH && h.startBeat === fhhTick);
-        if (!occupied) {
+        if (!track.hasOnset(GM.FHH, fhhTick)) {
           track.add(GM.FHH, fhhTick, 0.5, footHiHatVelocity(rng));
         }
       }
@@ -1893,14 +2051,19 @@ function generateDrums(opts) {
       role,
       densityMult,
       rng,
-      opts.bpm
+      opts.bpm,
+      sec,
+      swingAmount,
+      barBeats
     );
   }
-  return track.hits;
+  const endBeat = opts.bars * barBeats;
+  return track.hits.filter((hit) => hit.startBeat < endBeat).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;
@@ -1911,7 +2074,8 @@ var MAX_VELOCITY = 127;
 function humanize(events, opts = {}) {
   const ts = opts.ts ?? DEFAULT_TS3;
   assertTimeSignature(ts);
-  assertNoteEvents(events, "humanize events");
+  assertNoteEvents(events, "humanize events", { allowNonPositiveDuration: true });
+  const sounding = dropSilentNotes(events);
   const timing = opts.timing ?? DEFAULT_TIMING;
   const velocityJitter = opts.velocity ?? DEFAULT_VELOCITY_JITTER;
   const accent = opts.accent ?? DEFAULT_ACCENT;
@@ -1921,7 +2085,7 @@ function humanize(events, opts = {}) {
   assertRange(accent, 0, 127, "humanize accent");
   assertRange(baseVelocity, 0, 127, "humanize base velocity");
   const rng = createRng(opts.seed ?? 0);
-  return events.map((event) => {
+  return sounding.map((event) => {
     const timingOffset = rng.float(-timing, timing);
     const startBeat = Math.max(0, event.startBeat + timingOffset);
     const weight = metricWeight(event.startBeat, ts);
@@ -1951,18 +2115,19 @@ function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
     slotIndex
   };
 }
-function extractGrooveTemplate(events, ts, subdivision) {
+function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVISION) {
   assertTimeSignature(ts);
-  assertNoteEvents(events, "groove source events");
+  assertNoteEvents(events, "groove source events", { allowNonPositiveDuration: true });
   assertPositiveInt(subdivision, "groove subdivision");
   const barBeats = beatsPerBar(ts);
-  const slotsPerBar = Math.round(barBeats * subdivision);
+  const slotsPerBar = Math.ceil(barBeats * subdivision);
+  assertPositiveInt(slotsPerBar, "groove template slots");
   assertGenerationBudget(slotsPerBar, "groove template slots");
   const offsetSums = new Array(slotsPerBar).fill(0);
   const velocitySums = new Array(slotsPerBar).fill(0);
   const counts = new Array(slotsPerBar).fill(0);
   const velocityCounts = new Array(slotsPerBar).fill(0);
-  for (const event of events) {
+  for (const event of dropSilentNotes(events)) {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -1993,20 +2158,20 @@ function extractGrooveTemplate(events, ts, subdivision) {
 }
 function applyGrooveTemplate(events, template, ts) {
   assertTimeSignature(ts);
-  assertNoteEvents(events, "groove target events");
+  assertNoteEvents(events, "groove target events", { allowNonPositiveDuration: true });
   assertPositiveInt(template.subdivision, "template subdivision");
   assertPositiveInt(template.slotsPerBar, "template slotsPerBar");
   assertGenerationBudget(template.slots.length, "template slots");
   if (template.slots.length !== template.slotsPerBar) {
-    throw new RangeError("template slots length must equal slotsPerBar");
+    throw new InvalidInputError("template slots length must equal slotsPerBar");
   }
   if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
-    throw new Error(
+    throw new InvalidInputError(
       `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(ts)}`
     );
   }
   const barBeats = beatsPerBar(ts);
-  return events.map((event) => {
+  return dropSilentNotes(events).map((event) => {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -2014,7 +2179,7 @@ function applyGrooveTemplate(events, template, ts) {
       template.slotsPerBar
     );
     const slot = template.slots[slotIndex];
-    const startBeat = quantizedBeat + (slot?.timingOffset ?? 0);
+    const startBeat = Math.max(0, quantizedBeat + (slot?.timingOffset ?? 0));
     const velocity = slot && slot.velocity !== null && slot.velocity !== void 0 ? Math.round(slot.velocity) : event.velocity;
     return {
       pitch: event.pitch,
@@ -2026,15 +2191,20 @@ function applyGrooveTemplate(events, template, ts) {
 }
 
 // src/generate/harmonize/index.ts
-var FALLBACK = { rootPc: 0, quality: "maj", secondaryDominant: false, base: 0 };
+var FALLBACK = {
+  rootPc: 0,
+  quality: "maj",
+  secondaryDominant: false,
+  base: 0,
+  pcs: chordPitchClasses(makeChord(0, "maj"))
+};
+var DEFAULT_HARMONIC_RHYTHM = 2;
+var DEFAULT_PLACEMENT = { transposeSearch: false, octaveSearch: false };
 var DEFAULT_METER = { numerator: 4, denominator: 4 };
 var COMFORT_LOW = 55;
 var COMFORT_HIGH = 79;
 var TESSITURA_WEIGHT = 1e-3;
-var TIE_BREAK_JITTER = 1e-6;
-function pitchClass2(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
+var TIE_BREAK_JITTER2 = 1e-6;
 function inferKey(melody) {
   let best = majorKey(0);
   let bestScore = Number.NEGATIVE_INFINITY;
@@ -2043,13 +2213,13 @@ function inferKey(melody) {
     candidates.push(majorKey(tonic), minorKey(tonic));
   }
   for (const key of candidates) {
-    const tonic = pitchClass2(key.rootPc);
+    const tonic = pitchClassOf(key.rootPc);
     const isMinor = key.modeMask12 === NATURAL_MINOR_MASK;
     const leadingTone = (tonic + 11) % 12;
     let score = 0;
     for (const n of melody) {
       const w = Math.max(0.25, n.durationBeat);
-      const pc = pitchClass2(n.pitch);
+      const pc = pitchClassOf(n.pitch);
       if (isScaleTone(n.pitch, key) || isMinor && pc === leadingTone) {
         score += w;
       }
@@ -2066,22 +2236,28 @@ function inferKey(melody) {
 }
 function buildCandidates(key, reharmonize) {
   const tones = scaleTonesInDegreeOrder(key);
-  const candidates = tones.map((rootPc, degree) => ({
-    rootPc,
-    quality: diatonicTriad(degree, key).quality,
-    degree,
-    secondaryDominant: false,
-    base: 0
-  }));
+  const candidates = tones.map((rootPc, degree) => {
+    const quality = diatonicTriad(degree, key).quality;
+    return {
+      rootPc,
+      quality,
+      degree,
+      secondaryDominant: false,
+      base: 0,
+      pcs: chordPitchClasses(makeChord(rootPc, quality))
+    };
+  });
   if (reharmonize !== "diatonic") {
     for (const target of [1, 3, 4, 5]) {
       const targetRoot = tones[target] ?? 0;
+      const rootPc = (targetRoot + 7) % 12;
       candidates.push({
-        rootPc: (targetRoot + 7) % 12,
+        rootPc,
         quality: "dom7",
         secondaryDominant: true,
         targetDegree: target,
-        base: 1.5
+        base: 1.5,
+        pcs: chordPitchClasses(makeChord(rootPc, "dom7"))
       });
     }
   }
@@ -2095,7 +2271,8 @@ function buildCandidates(key, reharmonize) {
           rootPc: chord.rootPc,
           quality: chord.quality,
           secondaryDominant: false,
-          base: 1.25
+          base: 1.25,
+          pcs: chordPitchClasses(chord)
         });
       }
     }
@@ -2110,8 +2287,8 @@ function buildCandidates(key, reharmonize) {
     return true;
   });
 }
-function emissionCost(seg, cand, melody, key) {
-  const pcs = chordPitchClasses(makeChord(cand.rootPc, cand.quality));
+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];
@@ -2124,10 +2301,10 @@ function emissionCost(seg, cand, melody, key) {
       continue;
     }
     const w = Math.max(0.25, overlap);
-    if (pcs.includes(pitchClass2(note.pitch))) {
+    if (pcs.includes(pitchClassOf(note.pitch))) {
       continue;
     }
-    const strong = isStrongBeat(overlapStart, DEFAULT_METER);
+    const strong = isStrongBeat(overlapStart, ts);
     cost += (strong ? 10 : 2) * w;
     if (!isScaleTone(note.pitch, key)) {
       cost += w;
@@ -2161,13 +2338,13 @@ function transitionCost(prev, cur, tonicPc) {
   cost += dist * 0.3;
   return cost;
 }
-function harmonizeOnce(melody, key, candidates, segments, jitter) {
-  const tonicPc = pitchClass2(key.rootPc);
+function harmonizeOnce(melody, key, candidates, segments, jitter, ts) {
+  const tonicPc = pitchClassOf(key.rootPc);
   const n = candidates.length;
   const candAt = (i) => candidates[i] ?? FALLBACK;
   const seg0 = segments[0];
   let dp = candidates.map(
-    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key) : 0) + (jitter[ci] ?? 0)
+    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key, ts) : 0) + (jitter[ci] ?? 0)
   );
   const back = [];
   for (let s = 1; s < segments.length; s += 1) {
@@ -2187,7 +2364,7 @@ function harmonizeOnce(melody, key, candidates, segments, jitter) {
           bestPrev = p;
         }
       }
-      next[c] = best + emissionCost(seg, candAt(c), melody, key) + (jitter[c] ?? 0);
+      next[c] = best + emissionCost(seg, candAt(c), melody, key, ts) + (jitter[c] ?? 0);
       ptr[c] = bestPrev;
     }
     dp = next;
@@ -2212,32 +2389,47 @@ function harmonizeOnce(melody, key, candidates, segments, jitter) {
   return { cost: bestCost, path };
 }
 function harmonizeMelody(opts) {
-  const noteIndex = createNoteEventIndex(opts.melody);
-  const key = opts.key === "infer" ? inferKey(opts.melody) : opts.key;
-  const candidates = buildCandidates(key, opts.reharmonize);
+  assertNoteEvents(opts.melody, "harmonize melody", { allowNonPositiveDuration: true });
+  const soundingMelody = soundingNotesOnly(opts.melody);
+  const noteIndex = createNoteEventIndex(soundingMelody);
+  const ts = opts.ts ?? DEFAULT_METER;
+  assertTimeSignature(ts);
+  const requestedKey = opts.key ?? "infer";
+  const key = requestedKey === "infer" ? inferKey(soundingMelody) : requestedKey;
+  const placement = opts.placement ?? DEFAULT_PLACEMENT;
+  if (noteIndex.notes.length === 0) {
+    return { transposeSemitones: 0, key, chords: [], melodyRoles: [] };
+  }
+  const candidates = buildCandidates(key, opts.reharmonize ?? "diatonic");
   const candAt = (i) => candidates[i] ?? FALLBACK;
   const rng = createRng(opts.seed ?? 0);
-  const jitter = candidates.map(() => rng.next() * TIE_BREAK_JITTER);
-  const melodyEnd = noteIndex.notes.reduce((m, n) => Math.max(m, n.endBeat), 0);
-  const requestedHr = assertRange(
-    opts.harmonicRhythm,
+  const jitter = candidates.map(() => rng.next() * TIE_BREAK_JITTER2);
+  const melodyStart = noteIndex.notes.reduce(
+    (start, indexed) => Math.min(start, indexed.note.startBeat),
+    Number.POSITIVE_INFINITY
+  );
+  const melodyEnd = noteIndex.notes.reduce((end, indexed) => Math.max(end, indexed.endBeat), 0);
+  const hr = assertRange(
+    opts.harmonicRhythm ?? DEFAULT_HARMONIC_RHYTHM,
     Number.MIN_VALUE,
     Number.MAX_SAFE_INTEGER,
     "harmonic rhythm"
   );
-  const hr = Math.max(0.25, requestedHr);
-  const segCount = Math.max(1, Math.ceil(melodyEnd / hr));
+  const segmentStart = Math.floor(melodyStart / hr) * hr;
+  const segCount = Math.max(1, Math.ceil((melodyEnd - segmentStart) / hr));
   assertGenerationBudget(segCount, "harmonic segments");
-  assertGenerationBudget(segCount * candidates.length * candidates.length, "harmonization search");
   const segments = Array.from({ length: segCount }, (_, s) => ({
-    startBeat: s * hr,
-    endBeat: (s + 1) * hr,
+    startBeat: segmentStart + s * hr,
+    endBeat: segmentStart + (s + 1) * hr,
     noteIndices: []
   }));
   let memberships = 0;
   for (const indexed of noteIndex.notes) {
-    const first = Math.max(0, Math.floor(indexed.note.startBeat / hr));
-    const lastExclusive = Math.min(segCount, Math.ceil(indexed.endBeat / hr - Number.EPSILON));
+    const first = Math.max(0, Math.floor((indexed.note.startBeat - segmentStart) / hr));
+    const lastExclusive = Math.min(
+      segCount,
+      Math.ceil((indexed.endBeat - segmentStart) / hr - Number.EPSILON)
+    );
     memberships += Math.max(0, lastExclusive - first);
     assertGenerationBudget(memberships, "note-to-segment memberships");
     for (let segment = first; segment < lastExclusive; segment += 1) {
@@ -2245,31 +2437,35 @@ function harmonizeMelody(opts) {
     }
   }
   const transposes = [0];
-  if (opts.placement.transposeSearch) {
+  if (placement.transposeSearch) {
     for (let s = -6; s <= 6; s += 1) {
       if (s !== 0) {
         transposes.push(s);
       }
     }
   }
-  if (opts.placement.octaveSearch) {
+  if (placement.octaveSearch) {
     for (const o of [-12, 12]) {
       if (!transposes.includes(o)) {
         transposes.push(o);
       }
     }
   }
+  assertGenerationBudget(
+    transposes.length * segCount * candidates.length * candidates.length,
+    "harmonization placement search"
+  );
   let bestCost = Number.POSITIVE_INFINITY;
   let bestTs = 0;
   let bestPath = [];
   let bestMelody = opts.melody;
-  for (const ts of transposes) {
-    const shifted = opts.melody.map((n) => ({ ...n, pitch: n.pitch + ts }));
-    const { cost, path } = harmonizeOnce(shifted, key, candidates, segments, jitter);
+  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 = ts;
+      bestTs = shift;
       bestPath = path;
       bestMelody = shifted;
     }
@@ -2279,7 +2475,7 @@ function harmonizeMelody(opts) {
     const chord = {
       rootPc: cand.rootPc,
       quality: cand.quality,
-      startBeat: segments[s]?.startBeat ?? s * hr
+      startBeat: segments[s]?.startBeat ?? segmentStart + s * hr
     };
     if (cand.degree !== void 0) {
       chord.degree = cand.degree;
@@ -2299,10 +2495,13 @@ function harmonizeMelody(opts) {
 }
 
 // src/generate/motif/index.ts
-function pitchClass3(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
 var MIN_TILE_SPAN = 1 / 256;
+var DEFAULT_TS4 = { numerator: 4, denominator: 4 };
+var EPS3 = 1e-9;
+function isDownbeat(startBeat, barBeats) {
+  const bar = startBeat / barBeats;
+  return Math.abs(bar - Math.round(bar)) < EPS3;
+}
 function upScaleTone(pitch, key) {
   for (let d = 1; d <= 12; d += 1) {
     if (isScaleTone(pitch + d, key)) {
@@ -2330,10 +2529,10 @@ function stepDiatonic(pitch, degrees, key) {
 function nearestChordTone(pitch, chord) {
   const pcs = chordPitchClasses(chord);
   for (let d = 0; d <= 12; d += 1) {
-    if (pcs.includes(pitchClass3(pitch - d))) {
+    if (pcs.includes(pitchClassOf(pitch - d))) {
       return pitch - d;
     }
-    if (pcs.includes(pitchClass3(pitch + d))) {
+    if (pcs.includes(pitchClassOf(pitch + d))) {
       return pitch + d;
     }
   }
@@ -2387,14 +2586,15 @@ function contourOffsets(contour, count) {
 function generateMotif(opts) {
   const contour = opts.contour ?? "arch";
   const bars = assertPositiveInt(opts.bars, "motif bars");
-  const totalBeats = bars * 4;
+  const barBeats = beatsPerBar(opts.ts ?? DEFAULT_TS4);
+  const totalBeats = bars * barBeats;
   const noteCount = Math.max(3, bars * 2);
   assertGenerationBudget(noteCount, "motif notes");
   const beatsPerNote = totalBeats / noteCount;
   const rng = createRng(opts.seed ?? 0);
   const requestedJitter = assertFiniteNumber(opts.jitter ?? 0, "motif jitter");
   const jitterProb = Math.min(1, Math.max(0, requestedJitter));
-  const tonic = pitchClass3(opts.key.rootPc) + 60;
+  const tonic = pitchClassOf(opts.key.rootPc) + 60;
   const offsets = contourOffsets(contour, noteCount);
   const notes = [];
   for (let i = 0; i < noteCount; i += 1) {
@@ -2404,23 +2604,46 @@ function generateMotif(opts) {
     }
     let pitch = stepDiatonic(tonic, (offsets[i] ?? 0) + jitter, opts.key);
     const startBeat = i * beatsPerNote;
-    if (opts.chord && startBeat % 4 === 0) {
+    if (opts.chord && isDownbeat(startBeat, barBeats)) {
       pitch = nearestChordTone(pitch, opts.chord);
     }
-    notes.push({ pitch, startBeat, durationBeat: beatsPerNote });
+    notes.push({
+      pitch: clampToMidi(pitch, "generated motif pitch"),
+      startBeat,
+      durationBeat: beatsPerNote
+    });
   }
   return { notes };
 }
+function motifToNoteEvents(cell) {
+  return cell.notes.map((note) => ({ ...note }));
+}
 function transformMotif(cell, t, amount, key) {
+  return assertInRange(transformUnchecked(cell, t, amount, key));
+}
+function assertInRange(cell) {
+  for (const note of cell.notes) {
+    if (note.pitch < 0 || note.pitch > 127) {
+      throw new InvalidInputError(
+        `transformed motif pitch ${note.pitch} is outside the MIDI range 0..127`
+      );
+    }
+  }
+  return cell;
+}
+function transformUnchecked(cell, t, amount, key) {
   assertNoteEvents(cell.notes, "motif notes");
   if (amount !== void 0) {
     assertFiniteNumber(amount, "motif transform amount");
   }
-  if ((t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
-    assertInteger(amount, "diatonic transform amount");
+  if ((t === "transposeChromatic" || t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
+    assertInteger(
+      amount,
+      `${t === "transposeChromatic" ? "chromatic" : "diatonic"} transform amount`
+    );
   }
   if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
-    throw new RangeError("time transform amount must be positive");
+    throw new InvalidInputError("time transform amount must be positive");
   }
   const notes = cell.notes;
   switch (t) {
@@ -2480,11 +2703,11 @@ function scaleTime(cell, factor) {
     }))
   };
 }
-function developMotif(cell, timeline, key, bars) {
+function developMotif(cell, timeline, key, bars, ts = DEFAULT_TS4) {
   assertPositiveInt(bars, "development bars");
   assertNoteEvents(cell.notes, "motif notes");
   const span = cellSpan(cell);
-  const totalBeats = bars * 4;
+  const totalBeats = bars * beatsPerBar(ts);
   const origin = cellOrigin(cell.notes);
   const out = [];
   if (span <= 0) {
@@ -2503,7 +2726,7 @@ function developMotif(cell, timeline, key, bars) {
       const chord = timeline.at(startBeat);
       let pitch = n.pitch;
       if (chord) {
-        const isMember = chordPitchClasses(chord).includes(pitchClass3(pitch));
+        const isMember = chordPitchClasses(chord).includes(pitchClassOf(pitch));
         pitch = isMember ? pitch : nearestChordTone(pitch, chord);
       } else {
         pitch = nearestScaleTone(pitch, key);
@@ -2515,6 +2738,20 @@ function developMotif(cell, timeline, key, bars) {
 }
 
 // src/generate/progression/index.ts
+var BORROWED_DEGREES = Object.freeze({
+  /** 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",
@@ -2672,18 +2909,12 @@ var PRESETS = [
   }
 ];
 var BORROWED_OFFSET = {
-  8: 8,
-  // bVI
-  10: 10,
-  // bVII
-  11: 3,
-  // bIII
-  12: 5,
-  // iv
-  13: 1,
-  // bII
-  14: 6
-  // #IV
+  [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] }));
@@ -2699,8 +2930,12 @@ function degreeToRootPc(degree, key) {
   const offset = BORROWED_OFFSET[degree] ?? 0;
   return ((key.rootPc % 12 + offset) % 12 + 12) % 12;
 }
-function autoQuality(degree, key) {
+function autoQuality(degree, key, harmonicDominant) {
   if (degree >= 0 && degree <= 6) {
+    const isMinor = (key.modeMask12 >> 3 & 1) === 1 && (key.modeMask12 >> 4 & 1) === 0;
+    if (harmonicDominant && isMinor && degree === 4) {
+      return "maj";
+    }
     return diatonicTriad(degree, key).quality;
   }
   if (degree === 14) {
@@ -2711,40 +2946,99 @@ function autoQuality(degree, key) {
   }
   return "maj";
 }
+function resolveCycle(degrees, key, ext, harmonicDominant) {
+  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, harmonicDominant)
+    };
+    if (degree >= 0 && degree <= 6) {
+      step.degree = degree;
+    }
+    const previous = steps[steps.length - 1];
+    if (previous !== void 0 && previous.source !== step.source && sameStep(previous, step)) {
+      continue;
+    }
+    steps.push(step);
+  }
+  const first = steps[0];
+  const last = steps[steps.length - 1];
+  if (steps.length > 1 && first !== void 0 && last !== void 0 && first.source !== last.source && sameStep(first, last)) {
+    steps.pop();
+  }
+  return steps.length > 0 ? steps : [{ source: 0, degree: 0, rootPc: degreeToRootPc(0, key), quality: "maj" }];
+}
+function sameStep(a, b) {
+  return a.rootPc === b.rootPc && a.quality === b.quality;
+}
+function pickProgressionPreset(style, seed = 0) {
+  const pool = PRESETS.filter((preset) => preset.styles.includes(style));
+  if (pool.length === 0) {
+    throw new InvalidInputError(`Unknown progression style: ${style}`);
+  }
+  const rng = createRng(seed);
+  const index = Math.floor(rng.next() * pool.length) % pool.length;
+  return pool[index] ?? PRESETS[0];
+}
 function generateProgression(opts) {
   assertPositiveInt(opts.bars, "progression bars");
   assertGenerationBudget(opts.bars, "progression chords");
   const seed = opts.seed ?? 0;
   let preset;
-  if (opts.presetId !== void 0) {
+  if (opts.preset !== void 0) {
+    if (opts.preset.degrees.length === 0) {
+      throw new InvalidInputError("progression preset must name at least one degree");
+    }
+    preset = {
+      id: opts.preset.id ?? "custom",
+      name: opts.preset.name ?? "Custom",
+      degrees: opts.preset.degrees.map((degree, index) => {
+        assertDegree(degree, `progression preset degrees[${index}]`);
+        const supported = degree >= 0 && degree <= 6 || Object.values(BORROWED_DEGREES).includes(degree);
+        if (!supported) {
+          throw new InvalidInputError(
+            `progression preset degrees[${index}] is not a supported progression degree; received ${degree}`
+          );
+        }
+        return degree;
+      }),
+      functional: opts.preset.functional ?? "loop",
+      styles: opts.preset.styles ?? [opts.style]
+    };
+  }
+  if (preset === void 0 && opts.presetId !== void 0) {
     preset = PRESETS.find((p) => p.id === opts.presetId);
     if (preset === void 0) {
-      throw new Error(`Unknown progression preset: ${opts.presetId}`);
+      throw new InvalidInputError(`Unknown progression preset: ${opts.presetId}`);
     }
   }
-  if (preset === void 0) {
-    const pool = PRESETS.filter((p) => p.styles.includes(opts.style));
-    const candidates = pool.length > 0 ? pool : PRESETS;
-    const rng = createRng(seed);
-    const index = Math.floor(rng.next() * candidates.length) % candidates.length;
-    preset = candidates[index] ?? PRESETS[0];
-  }
-  const degrees = preset?.degrees ?? [0];
+  preset ??= pickProgressionPreset(opts.style, seed);
+  const ext = opts.ext === void 0 ? "auto" : assertOneOf(opts.ext, ["auto", ...chordQualities()], "progression extension");
+  const cycle = resolveCycle(
+    preset?.degrees ?? [0],
+    opts.key,
+    ext,
+    preset?.functional === "cadenceStrong"
+  );
   const chords = [];
   for (let bar = 0; bar < opts.bars; bar += 1) {
-    const degree = degrees[bar % degrees.length] ?? 0;
-    const quality = opts.ext !== void 0 && opts.ext !== "auto" ? opts.ext : autoQuality(degree, opts.key);
+    const step = cycle[bar % cycle.length];
     const chord = {
-      rootPc: degreeToRootPc(degree, opts.key),
-      quality,
-      startBeat: bar * 4,
-      degree: degree >= 0 && degree <= 6 ? degree : void 0
+      rootPc: step?.rootPc ?? 0,
+      quality: step?.quality ?? "maj",
+      startBeat: bar * 4
     };
+    if (step?.degree !== void 0) {
+      chord.degree = step.degree;
+    }
     chords.push(chord);
   }
   if (opts.reharmonize) {
     const tonicPc = (opts.key.rootPc % 12 + 12) % 12;
     const rrng = createRng((seed ^ 2654435769) >>> 0);
+    let tonicStatements = chords.filter((chord) => chord.rootPc === tonicPc).length;
     for (let i = 0; i < chords.length - 1; i += 1) {
       const cur = chords[i];
       const next = chords[i + 1];
@@ -2753,12 +3047,16 @@ function generateProgression(opts) {
       }
       const domRoot = (next.rootPc + 7) % 12;
       const targetsTonic = (next.rootPc - tonicPc + 12) % 12 === 0;
+      const isLastTonicStatement = cur.rootPc === tonicPc && tonicStatements <= 1;
       const alreadySecondary = cur.rootPc === domRoot && cur.quality === "dom7";
       const isResolutionTarget = chords[i - 1]?.secondaryDominant === true;
-      if (targetsTonic || alreadySecondary || isResolutionTarget) {
+      if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget) {
         continue;
       }
       if (rrng.next() < 0.5) {
+        if (cur.rootPc === tonicPc) {
+          tonicStatements -= 1;
+        }
         chords[i] = {
           rootPc: domRoot,
           quality: "dom7",
@@ -2772,6 +3070,17 @@ function generateProgression(opts) {
 }
 
 // src/generate/rhythm/index.ts
+var DEFAULT_RHYTHM_VELOCITY = 96;
+function rhythmToNoteEvents(events, pitch, velocity = DEFAULT_RHYTHM_VELOCITY) {
+  assertFiniteNumber(pitch, "pitch");
+  assertRange(velocity, 0, 127, "velocity");
+  return events.map((event) => ({
+    pitch,
+    startBeat: event.position,
+    durationBeat: event.duration,
+    velocity
+  }));
+}
 var DEFAULT_SUBDIVISION = 2;
 var DEFAULT_DENSITY = 0.5;
 var DEFAULT_BARS = 1;
@@ -2791,28 +3100,34 @@ function generateRhythm(ts, opts = {}) {
   const seed = opts.seed ?? 0;
   const bars = opts.bars ?? DEFAULT_BARS;
   const subdivision = opts.subdivision ?? DEFAULT_SUBDIVISION;
-  const requestedDensity = assertFiniteNumber(opts.density ?? DEFAULT_DENSITY, "rhythm density");
-  const density = Math.min(1, Math.max(0, requestedDensity));
+  const density = assertRange(opts.density ?? DEFAULT_DENSITY, 0, 1, "rhythm density");
   assertPositiveInt(bars, "rhythm bars");
   assertPositiveInt(subdivision, "rhythm subdivision");
   const barBeats = beatsPerBar(ts);
   const spanBeats = barBeats * bars;
   const step = 1 / subdivision;
-  const slotCount = Math.round(spanBeats * subdivision);
+  const slotsPerBar = Math.ceil(barBeats * subdivision);
+  const slotCount = slotsPerBar * bars;
   assertGenerationBudget(slotCount, "rhythm grid slots");
-  const slotsPerBar = Math.round(barBeats * subdivision);
   const rng = createRng(seed);
   const positions = [];
-  for (let i = 0; i < slotCount; i += 1) {
-    const position = i * step;
-    if (i % slotsPerBar === 0) {
-      positions.push(position);
-      continue;
-    }
-    const weight = metricWeight(position, ts);
-    const probability = onsetWeightCurve(weight) * density;
-    if (rng.prob(probability)) {
-      positions.push(position);
+  for (let bar = 0; bar < bars; bar += 1) {
+    const barStart = bar * barBeats;
+    const barEnd = barStart + barBeats;
+    for (let slot = 0; slot < slotsPerBar; slot += 1) {
+      const position = barStart + slot * step;
+      if (position >= barEnd - Number.EPSILON) {
+        break;
+      }
+      if (slot === 0) {
+        positions.push(position);
+        continue;
+      }
+      const weight = metricWeight(position, ts);
+      const probability = onsetWeightCurve(weight) * density;
+      if (rng.prob(probability)) {
+        positions.push(position);
+      }
     }
   }
   const events = [];
@@ -2834,21 +3149,28 @@ function rhythmDensity(events, ts) {
 }
 
 export {
+  BASS_STYLES,
   generateBassLine,
   generateCounterMelody,
+  DRUM_NOTES,
+  drumVoiceOf,
   generateDrums,
   humanize,
   extractGrooveTemplate,
   applyGrooveTemplate,
   harmonizeMelody,
   generateMotif,
+  motifToNoteEvents,
   transformMotif,
   developMotif,
+  BORROWED_DEGREES,
   progressions,
   progressionsByStyle,
+  pickProgressionPreset,
   generateProgression,
+  rhythmToNoteEvents,
   onsetWeightCurve,
   generateRhythm,
   rhythmDensity
 };
-//# sourceMappingURL=chunk-4MHA432G.js.map
+//# sourceMappingURL=chunk-AID75RN3.js.map