@libraz/libcantus 0.9.4 → 0.9.5

package/dist/{chunk-7NKDPF74.js → chunk-AID75RN3.js}

@@ -1,27 +1,29 @@
 import {
   createRng
-} from "./chunk-HKGYCQ34.js";
+} from "./chunk-ZGLJM4A4.js";
 import {
   beatsPerBar,
   createNoteEventIndex,
   formatTimeSignature,
   isStrongBeat,
-  metricWeight
-} from "./chunk-YLEMGEFH.js";
+  metricWeight,
+  pulseBeats
+} from "./chunk-2PTFGVD7.js";
 import {
   isDiatonic,
   parallelKey
-} from "./chunk-KMHOICIY.js";
+} from "./chunk-NNB67XA2.js";
 import {
   roleOf
-} from "./chunk-NKIBQ6PT.js";
+} from "./chunk-HN2OEUN2.js";
 import {
   enumerateSafePitches,
   evaluateSafety
-} from "./chunk-NYYWMV2C.js";
+} from "./chunk-DZMHIGI4.js";
 import {
   NATURAL_MINOR_MASK,
   chordPitchClasses,
+  chordQualities,
   chordToneRole,
   createsParallelPerfect,
   diatonicTriad,
@@ -32,9 +34,10 @@ import {
   minorKey,
   nearestScaleTone,
   scaleTonesInDegreeOrder
-} from "./chunk-D2FAJBYL.js";
+} from "./chunk-KBTTEX7Q.js";
 import {
   InvalidInputError,
+  assertDegree,
   assertFiniteNumber,
   assertGenerationBudget,
   assertInteger,
@@ -43,12 +46,20 @@ import {
   assertPositiveInt,
   assertRange,
   assertTimeSignature,
+  clampToMidi,
   dropSilentNotes,
-  pitchClassOf
-} from "./chunk-XEBG3G53.js";
+  pitchClassOf,
+  soundingNotesOnly
+} from "./chunk-R2VVFAIN.js";
 
 // src/generate/bass/index.ts
-var BASS_STYLES = ["root", "rootFifth", "pop", "walking", "arpeggio"];
+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;
@@ -90,10 +101,24 @@ function fifthPcOf(chord) {
 function bassPcOf(chord) {
   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);
@@ -101,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;
@@ -117,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) {
@@ -140,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);
@@ -168,7 +196,7 @@ function foldIntoBand(midi, low) {
 }
 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) {
@@ -197,6 +225,15 @@ function generateBassLine(opts) {
     }
   }
   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 [];
   }
@@ -204,7 +241,7 @@ function generateBassLine(opts) {
   assertTimeSignature(ts);
   const style = assertOneOf(opts.style ?? DEFAULT_STYLE, BASS_STYLES, "bass style");
   const octave = opts.octave ?? DEFAULT_OCTAVE;
-  assertInteger(octave, "bass octave", -1, 9);
+  assertInteger(octave, "bass octave", -1, 8);
   const estimatedNotes = segments.reduce(
     (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
     0
@@ -256,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
@@ -429,8 +466,8 @@ function generateCounterMelody(opts) {
   }
   const chordChangeBeats = timeline === void 0 ? opts.chordChangeBeats ?? [] : timeline.segments.flatMap((segment) => [segment.startBeat, segment.endBeat]);
   const register = opts.register ?? "below";
-  const melody = createNoteEventIndex(opts.melody, {
-    allowNonPositiveDuration: true,
+  assertNoteEvents(opts.melody, "countermelody melody", { allowNonPositiveDuration: true });
+  const melody = createNoteEventIndex(soundingNotesOnly(opts.melody), {
     tieBreak: register === "below" ? "highest" : "lowest"
   });
   const ts = opts.ts ?? DEFAULT_TS2;
@@ -438,13 +475,7 @@ function generateCounterMelody(opts) {
   const rhythm = assertOneOf(opts.rhythm ?? "complement", ["complement", "follow"], "rhythm");
   const profile = assertOneOf(opts.profile ?? "pop", ["strict", "pop"], "safety profile");
   const rng = createRng(opts.seed ?? 0);
-  if (opts.pitchLow !== void 0) {
-    assertInteger(opts.pitchLow, "countermelody pitchLow");
-  }
-  if (opts.pitchHigh !== void 0) {
-    assertInteger(opts.pitchHigh, "countermelody pitchHigh");
-  }
-  if (melody.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
+  if (melody.notes.length === 0) {
     return [];
   }
   const spanStart = melody.notes[0]?.note.startBeat ?? 0;
@@ -452,10 +483,14 @@ function generateCounterMelody(opts) {
   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 InvalidInputError(
       `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
@@ -547,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;
@@ -819,13 +859,10 @@ function getGhostProbabilityAtPosition(beat, sixteenthInBeat) {
   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"];
 }
 
@@ -841,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) {
@@ -1161,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);
@@ -1196,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);
@@ -1213,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,
@@ -1250,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;
       }
@@ -1261,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);
@@ -1276,11 +1319,11 @@ function generateHiHatForBeat(ctx, sec) {
     }
     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));
@@ -1335,7 +1378,7 @@ function getFillStartBeat(energy) {
       return 2;
     case "high":
     case "peak":
-      return 0;
+      return 2;
   }
 }
 function selectFillType(from, to, style, nextEnergy, rng) {
@@ -1600,7 +1643,7 @@ function generateFill(track, beatTick, beat, fillType, velocity) {
 }
 
 // src/generate/drums/hit.ts
-var DRUM_NOTES = {
+var DRUM_NOTES = Object.freeze({
   kick: GM.BD,
   snare: GM.SD,
   sideStick: GM.SIDESTICK,
@@ -1615,7 +1658,7 @@ var DRUM_NOTES = {
   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])
 );
@@ -1794,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)));
     }
@@ -1808,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))
           );
@@ -1821,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))
           );
@@ -1835,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)));
     }
@@ -1866,6 +1909,9 @@ function generateDrums(opts) {
   const style = mapping.style;
   const feel = opts.feel === void 0 ? mapping.feel : assertOneOf(opts.feel, DRUM_FEELS, "drum feel");
   const role = opts.role === void 0 ? "full" : assertOneOf(opts.role, DRUM_ROLES, "drum role");
+  const ts = opts.ts ?? { numerator: 4, denominator: 4 };
+  assertTimeSignature(ts, "drum time signature");
+  const barBeats = beatsPerBar(ts);
   const playMainVoices = role !== "fxOnly";
   const section = mapSection(publicSection);
   const backingDensity = mapDensity(opts.density);
@@ -1901,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);
@@ -1921,7 +1967,7 @@ function generateDrums(opts) {
     }
     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) {
@@ -1958,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)
               );
@@ -1982,7 +2028,7 @@ 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;
         if (!track.hasOnset(GM.FHH, fhhTick)) {
           track.add(GM.FHH, fhhTick, 0.5, footHiHatVelocity(rng));
@@ -2005,10 +2051,14 @@ function generateDrums(opts) {
       role,
       densityMult,
       rng,
-      opts.bpm
+      opts.bpm,
+      sec,
+      swingAmount,
+      barBeats
     );
   }
-  return [...track.hits].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
+  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
@@ -2070,7 +2120,8 @@ function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVIS
   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);
@@ -2128,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,
@@ -2338,41 +2389,47 @@ function harmonizeOnce(melody, key, candidates, segments, jitter, ts) {
   return { cost: bestCost, path };
 }
 function harmonizeMelody(opts) {
-  const noteIndex = createNoteEventIndex(opts.melody, { allowNonPositiveDuration: true });
+  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(opts.melody) : requestedKey;
+  const key = requestedKey === "infer" ? inferKey(soundingMelody) : requestedKey;
   const placement = opts.placement ?? DEFAULT_PLACEMENT;
-  if (noteIndex.notes.every((indexed) => indexed.note.durationBeat <= 0)) {
+  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_JITTER2);
-  const melodyEnd = noteIndex.notes.reduce((m, n) => Math.max(m, n.endBeat), 0);
+  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 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) {
-    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));
+    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) {
@@ -2394,6 +2451,10 @@ function harmonizeMelody(opts) {
       }
     }
   }
+  assertGenerationBudget(
+    transposes.length * segCount * candidates.length * candidates.length,
+    "harmonization placement search"
+  );
   let bestCost = Number.POSITIVE_INFINITY;
   let bestTs = 0;
   let bestPath = [];
@@ -2414,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;
@@ -2546,7 +2607,11 @@ function generateMotif(opts) {
     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 };
 }
@@ -2571,8 +2636,11 @@ function transformUnchecked(cell, t, amount, key) {
   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 InvalidInputError("time transform amount must be positive");
@@ -2670,7 +2738,7 @@ function developMotif(cell, timeline, key, bars, ts = DEFAULT_TS4) {
 }
 
 // src/generate/progression/index.ts
-var BORROWED_DEGREES = {
+var BORROWED_DEGREES = Object.freeze({
   /** Flat submediant: bVI. */
   bVI: 8,
   /** Flat subtonic: bVII. */
@@ -2683,7 +2751,7 @@ var BORROWED_DEGREES = {
   bII: 13,
   /** Sharp subdominant, the diminished #IV. */
   sharpIV: 14
-};
+});
 var PRESETS = [
   {
     id: "fourChordPop",
@@ -2862,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) {
@@ -2874,13 +2946,13 @@ function autoQuality(degree, key) {
   }
   return "maj";
 }
-function resolveCycle(degrees, key, ext) {
+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)
+      quality: ext !== void 0 && ext !== "auto" ? ext : autoQuality(degree, key, harmonicDominant)
     };
     if (degree >= 0 && degree <= 6) {
       step.degree = degree;
@@ -2922,7 +2994,16 @@ function generateProgression(opts) {
     preset = {
       id: opts.preset.id ?? "custom",
       name: opts.preset.name ?? "Custom",
-      degrees: opts.preset.degrees,
+      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]
     };
@@ -2934,7 +3015,13 @@ function generateProgression(opts) {
     }
   }
   preset ??= pickProgressionPreset(opts.style, seed);
-  const cycle = resolveCycle(preset?.degrees ?? [0], opts.key, opts.ext);
+  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 step = cycle[bar % cycle.length];
@@ -2951,6 +3038,7 @@ function generateProgression(opts) {
   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];
@@ -2959,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",
@@ -3014,21 +3106,28 @@ function generateRhythm(ts, opts = {}) {
   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 = [];
@@ -3074,4 +3173,4 @@ export {
   generateRhythm,
   rhythmDensity
 };
-//# sourceMappingURL=chunk-7NKDPF74.js.map
+//# sourceMappingURL=chunk-AID75RN3.js.map