@libraz/libcantus 0.9.2 → 0.9.3

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

@@ -1,18 +1,24 @@
 import {
   createRng
-} from "./chunk-BHUT2S5G.js";
+} from "./chunk-62QZKCJQ.js";
 import {
   beatsPerBar,
+  createNoteEventIndex,
   formatTimeSignature,
   isStrongBeat,
   metricWeight
-} from "./chunk-MSWFZF7J.js";
+} from "./chunk-I5R7ZBJS.js";
+import {
+  isDiatonic,
+  parallelKey
+} from "./chunk-CHMXELDS.js";
 import {
   roleOf
-} from "./chunk-SDM3VJJ5.js";
+} from "./chunk-2ZWMSJH6.js";
 import {
-  enumerateSafePitches
-} from "./chunk-A4532ZFR.js";
+  enumerateSafePitches,
+  evaluateSafety
+} from "./chunk-EH6EM37U.js";
 import {
   NATURAL_MINOR_MASK,
   chordPitchClasses,
@@ -26,7 +32,16 @@ import {
   minorKey,
   nearestScaleTone,
   scaleTonesInDegreeOrder
-} from "./chunk-7Y7WF64D.js";
+} from "./chunk-MIWO425M.js";
+import {
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertInteger,
+  assertNoteEvents,
+  assertPositiveInt,
+  assertRange,
+  assertTimeSignature
+} from "./chunk-FBQK3ZQN.js";
 
 // src/generate/bass/index.ts
 var DEFAULT_TS = { numerator: 4, denominator: 4 };
@@ -157,13 +172,30 @@ function buildWalking(ctx, seg, next) {
   });
 }
 function generateBassLine(opts) {
+  assertGenerationBudget(opts.segments.length, "bass segments");
+  for (let index = 0; index < opts.segments.length; index += 1) {
+    const segment = opts.segments[index];
+    if (!segment) continue;
+    assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
+    assertRange(segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
+    if (segment.endBeat <= segment.startBeat) {
+      throw new RangeError(`segments[${index}] must have a positive duration`);
+    }
+  }
   const segments = [...opts.segments].sort((a, b) => a.startBeat - b.startBeat);
   if (segments.length === 0) {
     return [];
   }
   const ts = opts.ts ?? DEFAULT_TS;
+  assertTimeSignature(ts);
   const style = opts.style ?? DEFAULT_STYLE;
   const octave = opts.octave ?? DEFAULT_OCTAVE;
+  assertInteger(octave, "bass octave", -1, 9);
+  const estimatedNotes = segments.reduce(
+    (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
+    0
+  );
+  assertGenerationBudget(estimatedNotes, "bass notes");
   const low = octave * 12 + 12;
   const ctx = {
     ts,
@@ -235,21 +267,26 @@ function isWholeBeat(beat) {
   return Math.abs(beat - Math.round(beat)) < EPS2;
 }
 function melodyNoteAt(melody, beat) {
-  let found;
-  for (const note of melody) {
-    if (note.startBeat - EPS2 <= beat && beat < note.startBeat + note.durationBeat - EPS2) {
-      if (!found || note.startBeat > found.startBeat) {
-        found = note;
-      }
-    }
-  }
-  return found;
+  return melody.at(beat)?.note;
 }
 function melodyAttacksAt(melody, beat) {
-  return melody.some((note) => Math.abs(note.startBeat - beat) < EPS2);
+  return melody.attacksAt(beat);
+}
+function melodySnapshotAt(melody, beat) {
+  const current = melodyNoteAt(melody, beat);
+  if (current === void 0) {
+    return void 0;
+  }
+  const attacked = Math.abs(current.startBeat - beat) < EPS2;
+  const previous = attacked ? melodyNoteAt(melody, beat - EPS2 * 2) : current;
+  const snapshot = { pitch: current.pitch };
+  if (previous !== void 0) {
+    snapshot.prevPitch = previous.pitch;
+  }
+  return snapshot;
 }
 function followOnsets(melody) {
-  return [...new Set(melody.map((note) => note.startBeat))].sort((a, b) => a - b);
+  return [...new Set(melody.notes.map(({ note }) => note.startBeat))];
 }
 function complementOnsets(melody, ts, spanStart, spanEnd, rng) {
   const onsets = [];
@@ -312,54 +349,102 @@ function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center) {
   score -= Math.abs(pitch - center) * 0.02;
   return score;
 }
-function fallbackPitch(melPitch, prevPitch, center, register, low, high, key) {
-  let target = prevPitch ?? Math.round(center);
-  if (melPitch !== void 0) {
-    if (register === "below" && target >= melPitch) {
-      target = melPitch - 5;
-    } else if (register === "above" && target <= melPitch) {
-      target = melPitch + 5;
-    }
-  }
-  target = Math.min(Math.max(target, low), high);
-  let pitch = nearestScaleTone(target, key);
-  if (melPitch !== void 0) {
-    while (register === "below" && pitch >= melPitch && pitch - 12 >= low) {
-      pitch -= 12;
-    }
-    while (register === "above" && pitch <= melPitch && pitch + 12 <= high) {
-      pitch += 12;
+function heldNoteBoundaries(melody, startBeat, endBeat, chordChangeBeats) {
+  const boundaries = /* @__PURE__ */ new Set([startBeat]);
+  for (const onset of melody.onsetsBetween(startBeat, endBeat)) {
+    boundaries.add(onset);
+  }
+  for (const beat of chordChangeBeats) {
+    if (beat > startBeat + EPS2 && beat < endBeat - EPS2) {
+      boundaries.add(beat);
+    }
+  }
+  const firstGrid = Math.floor(startBeat / GRID_STEP + 1) * GRID_STEP;
+  for (let beat = firstGrid; beat < endBeat - EPS2; beat += GRID_STEP) {
+    boundaries.add(beat);
+  }
+  return [...boundaries].sort((a, b) => a - b);
+}
+function heldPitchSafety(pitch, startBeat, endBeat, prevPitch, melody, opts, profile, register, low, high, ts) {
+  let worst = 0 /* Safe */;
+  const boundaries = heldNoteBoundaries(melody, startBeat, endBeat, opts.chordChangeBeats ?? []);
+  for (const boundary of boundaries) {
+    const melodyVoice = melodySnapshotAt(melody, boundary);
+    if (melodyVoice !== void 0 && (register === "below" && pitch >= melodyVoice.pitch || register === "above" && pitch <= melodyVoice.pitch)) {
+      return null;
+    }
+    const atCounterOnset = Math.abs(boundary - startBeat) < 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
+    });
+    worst = Math.max(worst, result.safety);
+    if (worst === 2 /* Dissonant */) {
+      return worst;
     }
   }
-  return Math.min(Math.max(pitch, low), high);
+  return worst;
 }
 function generateCounterMelody(opts) {
-  const melody = [...opts.melody].sort((a, b) => a.startBeat - b.startBeat);
-  if (melody.length === 0) {
+  const melody = createNoteEventIndex(opts.melody);
+  if (melody.notes.length === 0) {
     return [];
   }
   const ts = opts.ts ?? DEFAULT_TS2;
+  assertTimeSignature(ts);
   const register = opts.register ?? "below";
   const rhythm = opts.rhythm ?? "complement";
   const profile = opts.profile ?? "pop";
   const rng = createRng(opts.seed ?? 0);
-  const spanStart = melody[0]?.startBeat ?? 0;
-  const spanEnd = melody.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), spanStart);
-  const meanPitch = melody.reduce((sum, n) => sum + n.pitch, 0) / melody.length;
+  const spanStart = melody.notes[0]?.note.startBeat ?? 0;
+  const spanEnd = melody.notes.reduce((end, n) => Math.max(end, n.endBeat), spanStart);
+  assertGenerationBudget(Math.ceil((spanEnd - spanStart) / GRID_STEP), "countermelody grid");
+  const meanPitch = melody.notes.reduce((sum, n) => sum + n.note.pitch, 0) / melody.notes.length;
   const defaultCenter = register === "below" ? meanPitch - REGISTER_OFFSET : meanPitch + REGISTER_OFFSET;
   const low = opts.pitchLow ?? Math.round(defaultCenter) - DEFAULT_HALF_RANGE;
   const high = opts.pitchHigh ?? Math.round(defaultCenter) + DEFAULT_HALF_RANGE;
+  assertInteger(low, "countermelody pitchLow");
+  assertInteger(high, "countermelody pitchHigh");
+  if (low > high) {
+    throw new RangeError(
+      `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
+    );
+  }
+  assertGenerationBudget(high - low + 1, "countermelody pitch candidates");
+  assertGenerationBudget(opts.chordChangeBeats?.length ?? 0, "chord change beats");
+  for (let index = 0; index < (opts.chordChangeBeats?.length ?? 0); index += 1) {
+    assertRange(
+      opts.chordChangeBeats?.[index] ?? Number.NaN,
+      0,
+      Number.MAX_SAFE_INTEGER,
+      `chordChangeBeats[${index}]`
+    );
+  }
   const center = (low + high) / 2;
   const onsets = rhythm === "follow" ? followOnsets(melody) : complementOnsets(melody, ts, spanStart, spanEnd, rng);
+  assertGenerationBudget(onsets.length * (high - low + 1), "countermelody search");
   const out = [];
   let prevPitch;
-  let prevOnset;
-  for (const beat of onsets) {
+  for (let onsetIndex = 0; onsetIndex < onsets.length; onsetIndex += 1) {
+    const beat = onsets[onsetIndex];
+    if (beat === void 0) {
+      continue;
+    }
+    const nextOnset = onsets[onsetIndex + 1];
+    const endBeat = nextOnset ?? Math.max(spanEnd, beat + GRID_STEP);
     const melNote = melodyNoteAt(melody, beat);
     const melPitch = melNote?.pitch;
-    const melPrev = prevOnset !== void 0 ? melodyNoteAt(melody, prevOnset)?.pitch : void 0;
+    const melodyVoice = melodySnapshotAt(melody, beat);
+    const melPrev = melodyVoice?.prevPitch;
     const chord = opts.chordAt(beat);
-    const otherVoices = melPitch !== void 0 ? [{ pitch: melPitch, prevPitch: melPrev }] : [];
+    const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
     const candidates = enumerateSafePitches(
       {
         profile,
@@ -375,15 +460,26 @@ function generateCounterMelody(opts) {
       high
     );
     let bestPitch;
+    let bestWorstSafety = 2 /* Dissonant */;
     let bestScore = Number.NEGATIVE_INFINITY;
     for (const candidate of candidates) {
+      const worstSafety = heldPitchSafety(
+        candidate,
+        beat,
+        endBeat,
+        prevPitch,
+        melody,
+        opts,
+        profile,
+        register,
+        low,
+        high,
+        ts
+      );
+      if (worstSafety === null || worstSafety === 2 /* Dissonant */) {
+        continue;
+      }
       if (melPitch !== void 0) {
-        if (register === "below" && candidate >= melPitch) {
-          continue;
-        }
-        if (register === "above" && candidate <= melPitch) {
-          continue;
-        }
         if (prevPitch !== void 0 && melPrev !== void 0 && // Parallel octaves are the perfect-class-zero case of this predicate,
         // so a single check covers both parallel fifths and octaves.
         createsParallelPerfect(prevPitch, candidate, melPrev, melPitch)) {
@@ -392,28 +488,23 @@ function generateCounterMelody(opts) {
       }
       const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center);
       const tie = Math.abs(score - bestScore) <= EPS2 && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
-      if (score > bestScore + EPS2 || tie) {
+      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS2 || tie)) {
+        bestWorstSafety = worstSafety;
         bestScore = score;
         bestPitch = candidate;
       }
     }
-    const pitch = bestPitch ?? fallbackPitch(melPitch, prevPitch, center, register, low, high, opts.key);
+    if (bestPitch === void 0) {
+      prevPitch = void 0;
+      continue;
+    }
+    const pitch = bestPitch;
     const velocity = Math.max(
       1,
       Math.min(127, Math.round((melNote?.velocity ?? DEFAULT_MELODY_VELOCITY) - VELOCITY_DROP))
     );
-    out.push({ pitch, startBeat: beat, durationBeat: GRID_STEP, velocity });
+    out.push({ pitch, startBeat: beat, durationBeat: endBeat - beat, velocity });
     prevPitch = pitch;
-    prevOnset = beat;
-  }
-  for (let i = 0; i < out.length; i += 1) {
-    const note = out[i];
-    if (!note) {
-      continue;
-    }
-    const next = out[i + 1];
-    const end = next ? next.startBeat : Math.max(spanEnd, note.startBeat + GRID_STEP);
-    note.durationBeat = end - note.startBeat;
   }
   return out;
 }
@@ -1133,9 +1224,10 @@ function generateHiHatForBeat(ctx, sec) {
 
 // src/generate/drums/euclid.ts
 function euclideanRhythm(pulses, steps, rotation = 0) {
-  if (steps < 1) {
-    return [];
-  }
+  assertPositiveInt(steps, "euclidean steps");
+  assertInteger(pulses, "euclidean pulses");
+  assertInteger(rotation, "euclidean rotation");
+  assertGenerationBudget(steps, "euclidean pattern steps");
   const p = Math.max(0, Math.min(pulses, steps));
   const base = bjorklund(p, steps);
   const shift = (rotation % steps + steps) % steps;
@@ -1144,18 +1236,6 @@ function euclideanRhythm(pulses, steps, rotation = 0) {
   }
   return base.map((_, i) => base[(i - shift + steps) % steps] ?? false);
 }
-function hasHit(mask, step) {
-  return (mask >> step & 1) === 1;
-}
-function patternToMask(pattern) {
-  let mask = 0;
-  for (let i = 0; i < pattern.length; i += 1) {
-    if (pattern[i]) {
-      mask |= 1 << i;
-    }
-  }
-  return mask;
-}
 function bjorklund(pulses, steps) {
   if (pulses === 0) {
     return Array.from({ length: steps }, () => false);
@@ -1487,19 +1567,6 @@ function isInPreChorusLift(section, bar, sectionBars, nextIsChorus) {
   }
   return bar >= sectionBars - 2;
 }
-function euclideanToKickPattern(mask) {
-  const slot = (step) => hasHit(mask, step) || hasHit(mask, (step + 15) % 16);
-  return {
-    beat1: slot(0),
-    beat1and: slot(2),
-    beat2: slot(4),
-    beat2and: slot(6),
-    beat3: slot(8),
-    beat3and: slot(10),
-    beat4: slot(12),
-    beat4and: slot(14)
-  };
-}
 function getKickPattern(section, style, bar, rng) {
   const p = { ...EMPTY };
   if (section === "outro") {
@@ -1621,7 +1688,7 @@ function getPercussionConfig(mood, section) {
   };
 }
 function generateAuxPercussionForBar(track, barStart, config, role, densityMult, rng, bpm) {
-  if (role === "minimal" || role === "fxOnly") {
+  if (role === "minimal") {
     return;
   }
   if (config.tambourine) {
@@ -1670,6 +1737,16 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
 
 // src/generate/drums/index.ts
 function generateDrums(opts) {
+  assertPositiveInt(opts.bars, "drum bars");
+  assertRange(opts.bpm, Number.MIN_VALUE, 1e3, "drum bpm");
+  assertRange(opts.density, 0, 1, "drum density");
+  assertGenerationBudget(opts.bars * 128, "drum hits");
+  if (opts.euclideanKick) {
+    const steps = opts.euclideanKick.steps ?? 16;
+    assertInteger(steps, "euclidean steps", 1, 16);
+    assertInteger(opts.euclideanKick.pulses, "euclidean pulses");
+    assertInteger(opts.euclideanKick.rotation ?? 0, "euclidean rotation");
+  }
   const track = new HitList();
   const rng = createRng(opts.seed ?? 0);
   const mapping = mapStyle(opts.style);
@@ -1706,15 +1783,8 @@ function generateDrums(opts) {
   const percMood = percMoodCategory(style);
   const nextSection = opts.nextSection ? mapSection(opts.nextSection) : section;
   const nextEnergy = sectionEnergy(nextSection);
-  const euclidKick = opts.euclideanKick ? euclideanToKickPattern(
-    patternToMask(
-      euclideanRhythm(
-        opts.euclideanKick.pulses,
-        opts.euclideanKick.steps ?? 16,
-        opts.euclideanKick.rotation ?? 0
-      )
-    )
-  ) : void 0;
+  const euclidSteps = opts.euclideanKick?.steps ?? 16;
+  const euclidKick = opts.euclideanKick ? euclideanRhythm(opts.euclideanKick.pulses, euclidSteps, opts.euclideanKick.rotation ?? 0) : void 0;
   const reuseSectionKick = (section === "b" || section === "chorus") && style !== "sparse";
   let sectionKick;
   for (let bar = 0; bar < opts.bars; bar += 1) {
@@ -1730,12 +1800,10 @@ function generateDrums(opts) {
       barHasOpenHh = !track.hasCrashNear(barStart + openHhBeatIndex);
     }
     let kick;
-    if (euclidKick) {
-      kick = euclidKick;
-    } else if (reuseSectionKick) {
+    if (!euclidKick && reuseSectionKick) {
       sectionKick ??= getKickPattern(section, style, 0, rng);
       kick = sectionKick;
-    } else {
+    } else if (!euclidKick) {
       kick = getKickPattern(section, style, bar, rng);
     }
     const inLift = isInPreChorusLift(section, bar, opts.bars, section === "b");
@@ -1776,7 +1844,23 @@ function generateDrums(opts) {
         if (inLift) {
           generatePreChorusBuildup(ctx, sec, isLastBar);
         }
-        generateKickForBeat(ctx, sec, kick);
+        if (euclidKick && !inLift) {
+          const stepLength = 4 / euclidSteps;
+          for (let step = 0; step < euclidKick.length; step += 1) {
+            const onset = step * stepLength;
+            if (euclidKick[step] && Math.floor(onset) === beat) {
+              const wholeBeat = Math.abs(onset - Math.round(onset)) < 1e-9;
+              track.add(
+                GM.BD,
+                barStart + onset,
+                Math.min(0.5, stepLength),
+                velocity * (wholeBeat ? 1 : 0.85)
+              );
+            }
+          }
+        } else if (kick) {
+          generateKickForBeat(ctx, sec, kick);
+        }
         generateSnareForBeat(ctx, sec, section === "intro" && bar === 0);
         if (sec.useGhostNotes && !inLift) {
           generateGhostNotesForBeat(ctx, sec);
@@ -1793,10 +1877,19 @@ function generateDrums(opts) {
         }
       }
     }
+    let percussionConfig = getPercussionConfig(percMood, section);
+    if (role === "fxOnly" && !percussionConfig.tambourine && !percussionConfig.shaker && !percussionConfig.handclap) {
+      percussionConfig = {
+        tambourine: false,
+        shaker: true,
+        handclap: false,
+        shaker16th: false
+      };
+    }
     generateAuxPercussionForBar(
       track,
       barStart,
-      getPercussionConfig(percMood, section),
+      percussionConfig,
       role,
       densityMult,
       rng,
@@ -1817,10 +1910,16 @@ var MIN_VELOCITY = 1;
 var MAX_VELOCITY = 127;
 function humanize(events, opts = {}) {
   const ts = opts.ts ?? DEFAULT_TS3;
+  assertTimeSignature(ts);
+  assertNoteEvents(events, "humanize events");
   const timing = opts.timing ?? DEFAULT_TIMING;
   const velocityJitter = opts.velocity ?? DEFAULT_VELOCITY_JITTER;
   const accent = opts.accent ?? DEFAULT_ACCENT;
   const baseVelocity = opts.baseVelocity ?? DEFAULT_BASE_VELOCITY;
+  assertRange(timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
+  assertRange(velocityJitter, 0, 127, "humanize velocity jitter");
+  assertRange(accent, 0, 127, "humanize accent");
+  assertRange(baseVelocity, 0, 127, "humanize base velocity");
   const rng = createRng(opts.seed ?? 0);
   return events.map((event) => {
     const timingOffset = rng.float(-timing, timing);
@@ -1853,8 +1952,12 @@ function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
   };
 }
 function extractGrooveTemplate(events, ts, subdivision) {
+  assertTimeSignature(ts);
+  assertNoteEvents(events, "groove source events");
+  assertPositiveInt(subdivision, "groove subdivision");
   const barBeats = beatsPerBar(ts);
   const slotsPerBar = Math.round(barBeats * subdivision);
+  assertGenerationBudget(slotsPerBar, "groove template slots");
   const offsetSums = new Array(slotsPerBar).fill(0);
   const velocitySums = new Array(slotsPerBar).fill(0);
   const counts = new Array(slotsPerBar).fill(0);
@@ -1889,6 +1992,14 @@ function extractGrooveTemplate(events, ts, subdivision) {
   return { subdivision, slotsPerBar, slots, ts };
 }
 function applyGrooveTemplate(events, template, ts) {
+  assertTimeSignature(ts);
+  assertNoteEvents(events, "groove target events");
+  assertPositiveInt(template.subdivision, "template subdivision");
+  assertPositiveInt(template.slotsPerBar, "template slotsPerBar");
+  assertGenerationBudget(template.slots.length, "template slots");
+  if (template.slots.length !== template.slotsPerBar) {
+    throw new RangeError("template slots length must equal slotsPerBar");
+  }
   if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
     throw new Error(
       `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(ts)}`
@@ -1924,16 +2035,6 @@ var TIE_BREAK_JITTER = 1e-6;
 function pitchClass2(pitch) {
   return (Math.trunc(pitch) % 12 + 12) % 12;
 }
-function mulberry32(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state + 1831565813 >>> 0;
-    let t = state;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
 function inferKey(melody) {
   let best = majorKey(0);
   let bestScore = Number.NEGATIVE_INFINITY;
@@ -1972,7 +2073,6 @@ function buildCandidates(key, reharmonize) {
     secondaryDominant: false,
     base: 0
   }));
-  const tonic = tones[0] ?? 0;
   if (reharmonize !== "diatonic") {
     for (const target of [1, 3, 4, 5]) {
       const targetRoot = tones[target] ?? 0;
@@ -1986,26 +2086,29 @@ function buildCandidates(key, reharmonize) {
     }
   }
   if (reharmonize === "borrowed") {
-    candidates.push({
-      rootPc: (tonic + 10) % 12,
-      quality: "maj",
-      secondaryDominant: false,
-      base: 2
-    });
-    candidates.push({
-      rootPc: (tonic + 8) % 12,
-      quality: "maj",
-      secondaryDominant: false,
-      base: 2
-    });
-    candidates.push({
-      rootPc: (tonic + 5) % 12,
-      quality: "min",
-      secondaryDominant: false,
-      base: 2
-    });
+    const parallel = parallelKey(key);
+    const parallelTones = scaleTonesInDegreeOrder(parallel);
+    for (let degree = 0; degree < parallelTones.length; degree += 1) {
+      const chord = diatonicTriad(degree, parallel);
+      if (!isDiatonic(chord, key)) {
+        candidates.push({
+          rootPc: chord.rootPc,
+          quality: chord.quality,
+          secondaryDominant: false,
+          base: 1.25
+        });
+      }
+    }
   }
-  return candidates;
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const id = `${candidate.rootPc}:${candidate.quality}`;
+    if (seen.has(id)) {
+      return false;
+    }
+    seen.add(id);
+    return true;
+  });
 }
 function emissionCost(seg, cand, melody, key) {
   const pcs = chordPitchClasses(makeChord(cand.rootPc, cand.quality));
@@ -2109,20 +2212,37 @@ 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);
   const candAt = (i) => candidates[i] ?? FALLBACK;
-  const rng = mulberry32(opts.seed ?? 0);
-  const jitter = candidates.map(() => rng() * TIE_BREAK_JITTER);
-  const melodyEnd = opts.melody.reduce((m, n) => Math.max(m, n.startBeat + n.durationBeat), 0);
-  const hr = Math.max(0.25, opts.harmonicRhythm);
+  const rng = createRng(opts.seed ?? 0);
+  const jitter = candidates.map(() => rng.next() * TIE_BREAK_JITTER);
+  const melodyEnd = noteIndex.notes.reduce((m, n) => Math.max(m, n.endBeat), 0);
+  const requestedHr = assertRange(
+    opts.harmonicRhythm,
+    Number.MIN_VALUE,
+    Number.MAX_SAFE_INTEGER,
+    "harmonic rhythm"
+  );
+  const hr = Math.max(0.25, requestedHr);
   const segCount = Math.max(1, Math.ceil(melodyEnd / hr));
-  const segments = [];
-  for (let s = 0; s < segCount; s += 1) {
-    const startBeat = s * hr;
-    const endBeat = startBeat + hr;
-    const noteIndices = opts.melody.map((n, i) => ({ n, i })).filter(({ n }) => n.startBeat < endBeat && n.startBeat + n.durationBeat > startBeat).map(({ i }) => i);
-    segments.push({ startBeat, endBeat, noteIndices });
+  assertGenerationBudget(segCount, "harmonic segments");
+  assertGenerationBudget(segCount * candidates.length * candidates.length, "harmonization search");
+  const segments = Array.from({ length: segCount }, (_, s) => ({
+    startBeat: s * hr,
+    endBeat: (s + 1) * hr,
+    noteIndices: []
+  }));
+  let memberships = 0;
+  for (const indexed of noteIndex.notes) {
+    const first = Math.max(0, Math.floor(indexed.note.startBeat / hr));
+    const lastExclusive = Math.min(segCount, Math.ceil(indexed.endBeat / hr - Number.EPSILON));
+    memberships += Math.max(0, lastExclusive - first);
+    assertGenerationBudget(memberships, "note-to-segment memberships");
+    for (let segment = first; segment < lastExclusive; segment += 1) {
+      segments[segment]?.noteIndices.push(indexed.originalIndex);
+    }
   }
   const transposes = [0];
   if (opts.placement.transposeSearch) {
@@ -2169,11 +2289,11 @@ function harmonizeMelody(opts) {
     }
     return chord;
   });
-  const melodyRoles = bestMelody.map((note, noteIndex) => {
+  const melodyRoles = bestMelody.map((note, noteIndex2) => {
     const segIdx = Math.min(segments.length - 1, Math.max(0, Math.floor(note.startBeat / hr)));
     const cand = candAt(bestPath[segIdx] ?? 0);
     const chord = makeChord(cand.rootPc, cand.quality);
-    return { noteIndex, role: roleOf(note.pitch, chord).role };
+    return { noteIndex: noteIndex2, role: roleOf(note.pitch, chord).role };
   });
   return { transposeSemitones: bestTs, key, chords, melodyRoles };
 }
@@ -2220,29 +2340,30 @@ function nearestChordTone(pitch, chord) {
   return pitch;
 }
 function cellOrigin(notes) {
-  return notes.length === 0 ? 0 : Math.min(...notes.map((n) => n.startBeat));
+  let origin = Number.POSITIVE_INFINITY;
+  for (const note of notes) {
+    origin = Math.min(origin, note.startBeat);
+  }
+  return Number.isFinite(origin) ? origin : 0;
+}
+function cellEnd(notes) {
+  let end = Number.NEGATIVE_INFINITY;
+  for (const note of notes) {
+    end = Math.max(end, note.startBeat + note.durationBeat);
+  }
+  return Number.isFinite(end) ? end : 0;
 }
 function cellSpan(cell) {
   if (cell.notes.length === 0) {
     return 0;
   }
   const start = cellOrigin(cell.notes);
-  const end = Math.max(...cell.notes.map((n) => n.startBeat + n.durationBeat));
+  const end = cellEnd(cell.notes);
   return end - start;
 }
 function clone(cell) {
   return { notes: cell.notes.map((n) => ({ ...n })) };
 }
-function mulberry322(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state + 1831565813 >>> 0;
-    let t = state;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
 function contourOffsets(contour, count) {
   const offsets = [];
   for (let i = 0; i < count; i += 1) {
@@ -2265,19 +2386,21 @@ function contourOffsets(contour, count) {
 }
 function generateMotif(opts) {
   const contour = opts.contour ?? "arch";
-  const bars = Math.max(1, Math.trunc(opts.bars));
+  const bars = assertPositiveInt(opts.bars, "motif bars");
   const totalBeats = bars * 4;
   const noteCount = Math.max(3, bars * 2);
+  assertGenerationBudget(noteCount, "motif notes");
   const beatsPerNote = totalBeats / noteCount;
-  const rng = mulberry322(opts.seed ?? 0);
-  const jitterProb = Math.min(1, Math.max(0, opts.jitter ?? 0));
+  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 offsets = contourOffsets(contour, noteCount);
   const notes = [];
   for (let i = 0; i < noteCount; i += 1) {
     let jitter = 0;
-    if (jitterProb > 0 && rng() < jitterProb) {
-      jitter = rng() < 0.5 ? 1 : -1;
+    if (jitterProb > 0 && rng.next() < jitterProb) {
+      jitter = rng.next() < 0.5 ? 1 : -1;
     }
     let pitch = stepDiatonic(tonic, (offsets[i] ?? 0) + jitter, opts.key);
     const startBeat = i * beatsPerNote;
@@ -2289,6 +2412,16 @@ function generateMotif(opts) {
   return { notes };
 }
 function transformMotif(cell, t, amount, key) {
+  assertNoteEvents(cell.notes, "motif notes");
+  if (amount !== void 0) {
+    assertFiniteNumber(amount, "motif transform amount");
+  }
+  if ((t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
+    assertInteger(amount, "diatonic transform amount");
+  }
+  if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
+    throw new RangeError("time transform amount must be positive");
+  }
   const notes = cell.notes;
   switch (t) {
     case "transposeChromatic": {
@@ -2315,7 +2448,7 @@ function transformMotif(cell, t, amount, key) {
         return { notes: [] };
       }
       const start = cellOrigin(notes);
-      const end = Math.max(...notes.map((n) => n.startBeat + n.durationBeat));
+      const end = cellEnd(notes);
       return {
         notes: notes.map((n) => ({
           pitch: n.pitch,
@@ -2348,8 +2481,10 @@ function scaleTime(cell, factor) {
   };
 }
 function developMotif(cell, timeline, key, bars) {
+  assertPositiveInt(bars, "development bars");
+  assertNoteEvents(cell.notes, "motif notes");
   const span = cellSpan(cell);
-  const totalBeats = Math.max(1, Math.trunc(bars)) * 4;
+  const totalBeats = bars * 4;
   const origin = cellOrigin(cell.notes);
   const out = [];
   if (span <= 0) {
@@ -2357,6 +2492,7 @@ function developMotif(cell, timeline, key, bars) {
   }
   const tileSpan = Math.max(span, MIN_TILE_SPAN);
   const tileCount = Math.ceil(totalBeats / tileSpan);
+  assertGenerationBudget(tileCount * cell.notes.length, "developed motif notes");
   for (let k = 0; k < tileCount; k += 1) {
     const offset = k * tileSpan;
     for (const n of cell.notes) {
@@ -2555,16 +2691,6 @@ function progressions() {
 function progressionsByStyle(style) {
   return progressions().filter((p) => p.styles.includes(style));
 }
-function mulberry323(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state + 1831565813 >>> 0;
-    let t = state;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
 function degreeToRootPc(degree, key) {
   if (degree >= 0 && degree <= 6) {
     const tones = scaleTonesInDegreeOrder(key);
@@ -2586,6 +2712,8 @@ function autoQuality(degree, key) {
   return "maj";
 }
 function generateProgression(opts) {
+  assertPositiveInt(opts.bars, "progression bars");
+  assertGenerationBudget(opts.bars, "progression chords");
   const seed = opts.seed ?? 0;
   let preset;
   if (opts.presetId !== void 0) {
@@ -2597,8 +2725,8 @@ function generateProgression(opts) {
   if (preset === void 0) {
     const pool = PRESETS.filter((p) => p.styles.includes(opts.style));
     const candidates = pool.length > 0 ? pool : PRESETS;
-    const rng = mulberry323(seed);
-    const index = Math.floor(rng() * candidates.length) % candidates.length;
+    const rng = createRng(seed);
+    const index = Math.floor(rng.next() * candidates.length) % candidates.length;
     preset = candidates[index] ?? PRESETS[0];
   }
   const degrees = preset?.degrees ?? [0];
@@ -2616,7 +2744,7 @@ function generateProgression(opts) {
   }
   if (opts.reharmonize) {
     const tonicPc = (opts.key.rootPc % 12 + 12) % 12;
-    const rrng = mulberry323((seed ^ 2654435769) >>> 0);
+    const rrng = createRng((seed ^ 2654435769) >>> 0);
     for (let i = 0; i < chords.length - 1; i += 1) {
       const cur = chords[i];
       const next = chords[i + 1];
@@ -2630,7 +2758,7 @@ function generateProgression(opts) {
       if (targetsTonic || alreadySecondary || isResolutionTarget) {
         continue;
       }
-      if (rrng() < 0.5) {
+      if (rrng.next() < 0.5) {
         chords[i] = {
           rootPc: domRoot,
           quality: "dom7",
@@ -2663,11 +2791,15 @@ function generateRhythm(ts, opts = {}) {
   const seed = opts.seed ?? 0;
   const bars = opts.bars ?? DEFAULT_BARS;
   const subdivision = opts.subdivision ?? DEFAULT_SUBDIVISION;
-  const density = Math.min(1, Math.max(0, opts.density ?? DEFAULT_DENSITY));
+  const requestedDensity = assertFiniteNumber(opts.density ?? DEFAULT_DENSITY, "rhythm density");
+  const density = Math.min(1, Math.max(0, requestedDensity));
+  assertPositiveInt(bars, "rhythm bars");
+  assertPositiveInt(subdivision, "rhythm subdivision");
   const barBeats = beatsPerBar(ts);
   const spanBeats = barBeats * bars;
   const step = 1 / subdivision;
   const slotCount = Math.round(spanBeats * subdivision);
+  assertGenerationBudget(slotCount, "rhythm grid slots");
   const slotsPerBar = Math.round(barBeats * subdivision);
   const rng = createRng(seed);
   const positions = [];
@@ -2719,4 +2851,4 @@ export {
   generateRhythm,
   rhythmDensity
 };
-//# sourceMappingURL=chunk-R3S2LUBH.js.map
+//# sourceMappingURL=chunk-4MHA432G.js.map