@libraz/libcantus 1.0.1 → 1.1.0

package/dist/{chunk-VOHZB45S.js → chunk-R5VUXQMP.js}

@@ -1,13 +1,15 @@
 import {
+  HUMANIZE_ADJACENCY,
+  assertChordTimeline,
   borrowedSource,
   chordToRoman,
   detectChordBest,
   functionOf,
   isDiatonic,
+  isMinorKey,
   parallelKey
-} from "./chunk-H42UHPYW.js";
+} from "./chunk-VLE5R7PF.js";
 import {
-  ARTICULATIONS,
   LIMBS,
   canSound,
   createPositionalRng,
@@ -15,63 +17,143 @@ import {
   foldIntoRange,
   includeAt,
   instrumentRange,
-  resolveAlgorithmVersion
-} from "./chunk-FVSI36UV.js";
+  resolveAlgorithmVersion,
+  toStringedProfile
+} from "./chunk-X6RJAHII.js";
 import {
-  beatsPerBar,
-  createNoteEventIndex,
-  formatTimeSignature,
-  isStrongBeat,
-  metricWeight,
-  pulseBeats
-} from "./chunk-ELCTZUJJ.js";
+  createNoteEventIndex
+} from "./chunk-7GOKQJTQ.js";
 import {
+  chordScales,
   roleOf
-} from "./chunk-KNJEKLKV.js";
+} from "./chunk-H66ARFU5.js";
 import {
   chordPitchClasses,
   chordQualities,
   chordToneRole,
   createsParallelPerfect,
+  degreeOfInterval,
   diatonicTriad,
   enumerateSafePitches,
   evaluateSafety,
+  fifthPcOf,
+  heptatonicFrameOf,
   isForbiddenMelodicLeap,
   isScaleTone,
+  leadingTonePcOf,
   majorKey,
   makeChord,
   minorKey,
+  namedScaleMask,
   nearestScaleTone,
   profileWeights,
+  resolveKey,
   scaleLadderPitch,
   scaleLadderPosition,
+  scaleSystemOf,
   scaleTonesInDegreeOrder,
   shiftByScaleDegrees,
+  soundsDominantSeventh,
   spellPitchClass,
-  spellScale,
   toChordData,
-  toKeyScale
-} from "./chunk-INHVXP6Z.js";
+  toKeyScale,
+  tonicizableDegrees
+} from "./chunk-FPBZFNCD.js";
 import {
+  ARTICULATIONS,
+  BEAT_EPS,
   InvalidInputError,
+  assertArray,
   assertDegree,
   assertFiniteNumber,
+  assertFiniteSemitones,
+  assertFunction,
   assertGenerationBudget,
   assertInteger,
+  assertMidiPitch,
   assertNoteEvents,
   assertOneOf,
+  assertOptions,
   assertPositiveInt,
   assertRange,
+  assertRecord,
   assertTimeSignature,
+  beatsPerBar,
   clampToMidi,
+  describeRejected,
   dropSilentNotes,
-  midiToNote,
+  formatTimeSignature,
+  isCompound,
+  isStrongBeat,
+  meterAt,
+  metricWeight,
   noteToPitchClass,
   pitchClassOf,
+  pulseBeats,
+  resolveMeters,
   soundingNotesOnly,
+  toMeterData,
   toSpelledInterval,
   transposeNote
-} from "./chunk-VTI6FOLB.js";
+} from "./chunk-PQL7E5F6.js";
+
+// src/generate/context/draw.ts
+var DRAW_METHODS = ["at", "prob", "range", "float"];
+function assertDraw(draw, name = "draw") {
+  const sampler = assertRecord(draw, name);
+  for (const method of DRAW_METHODS) {
+    assertFunction(sampler[method], `${name}.${method}`);
+  }
+  return sampler;
+}
+function assertSeedPath(path, name = "draw path") {
+  const steps = assertArray(path, name);
+  for (let index = 0; index < steps.length; index += 1) {
+    const step = steps[index];
+    if (typeof step !== "string" && !Number.isFinite(step)) {
+      throw new InvalidInputError(
+        `${name}[${index}] must be a string or a finite number; received ${describeRejected(step)}`
+      );
+    }
+  }
+  return steps;
+}
+function drawFrom(rng, path) {
+  const draw = rng.at(...path);
+  if (!(draw >= 0 && draw < 1)) {
+    throw new InvalidInputError(`positional draw must be in [0, 1); received ${draw}`);
+  }
+  return draw;
+}
+function drawsFrom(rng, ...prefix) {
+  const at2 = (...path) => drawFrom(rng, [...prefix, ...path]);
+  return {
+    at: at2,
+    prob: (p, ...path) => includeAt(rng, p, ...prefix, ...path),
+    range: (lo, hi, ...path) => {
+      assertInteger(lo, "range lower bound");
+      assertInteger(hi, "range upper bound");
+      if (lo > hi) {
+        throw new InvalidInputError(
+          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      assertInteger(hi - lo, "range span", 0);
+      return lo + Math.floor(at2(...path) * (hi - lo + 1));
+    },
+    float: (lo, hi, ...path) => {
+      assertFiniteNumber(lo, "float lower bound");
+      assertFiniteNumber(hi, "float upper bound");
+      if (lo > hi) {
+        throw new InvalidInputError(
+          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      assertFiniteNumber(hi - lo, "float span");
+      return lo + at2(...path) * (hi - lo);
+    }
+  };
+}
 
 // src/generate/drums/internal.ts
 var GM = {
@@ -115,6 +197,16 @@ var PUBLIC_SECTIONS = [
   "bridge",
   "outro"
 ];
+function backbeatBeats(snareBeat3, barBeats = 4) {
+  if (snareBeat3) {
+    return barBeats > 2 ? [2] : [];
+  }
+  const beats = [];
+  for (let beat = 1; beat < barBeats; beat += 2) {
+    beats.push(beat);
+  }
+  return beats;
+}
 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 },
@@ -286,50 +378,59 @@ function sameTs(a, b) {
   return a.numerator === b.numerator && a.denominator === b.denominator;
 }
 function fitsQuery(entry, query) {
-  if (query.genre !== void 0 && entry.genre !== query.genre) {
+  const candidate = assertRecord(entry, "vocabulary entry");
+  const asked = assertRecord(query, "vocabulary query");
+  if (asked.genre !== void 0 && candidate.genre !== asked.genre) {
     return false;
   }
-  if (query.section !== void 0 && entry.sections && !entry.sections.includes(query.section)) {
+  if (asked.section !== void 0 && candidate.sections && !candidate.sections.includes(asked.section)) {
     return false;
   }
-  if (query.bpm !== void 0 && entry.tempoRange) {
-    const [low, high] = entry.tempoRange;
-    if (query.bpm < low || query.bpm > high) {
+  if (asked.bpm !== void 0 && candidate.tempoRange) {
+    const [low, high] = candidate.tempoRange;
+    if (asked.bpm < low || asked.bpm > high) {
       return false;
     }
   }
-  if (query.ts !== void 0 && entry.ts && !sameTs(entry.ts, query.ts)) {
+  if (asked.ts !== void 0 && candidate.ts && !sameTs(candidate.ts, meterAt(0, toMeterData(asked.ts, "ts")))) {
     return false;
   }
-  if (query.quality !== void 0 && entry.fitsOver && !entry.fitsOver.includes(query.quality)) {
+  if (asked.quality !== void 0 && candidate.fitsOver && !candidate.fitsOver.includes(asked.quality)) {
     return false;
   }
-  if (query.articulations !== void 0) {
-    const available = query.articulations;
-    if (entry.articulations.some((articulation) => !available.includes(articulation))) {
+  if (asked.articulations !== void 0) {
+    const available = asked.articulations;
+    if (candidate.articulations.some((articulation) => !available.includes(articulation))) {
       return false;
     }
   }
-  return query.difficulty === void 0 || entry.difficulty <= query.difficulty;
+  return asked.difficulty === void 0 || candidate.difficulty <= asked.difficulty;
 }
 function selectVocabulary(dictionary, query) {
-  return dictionary.filter((entry) => fitsQuery(entry, query));
+  return assertArray(dictionary, "dictionary").filter(
+    (entry) => fitsQuery(entry, query)
+  );
 }
 function pickVocabulary(dictionary, query, draw, ...path) {
+  const sampler = assertDraw(draw);
+  assertSeedPath(path);
   const candidates = selectVocabulary(dictionary, query);
   if (candidates.length === 0) {
     return void 0;
   }
-  return candidates[draw.range(0, candidates.length - 1, ...path)];
+  return candidates[sampler.range(0, candidates.length - 1, ...path)];
 }
 function mergeVocabulary(builtIn, supplied) {
-  if (!supplied || supplied.length === 0) {
-    return [...builtIn];
-  }
-  const byId = new Map(supplied.map((entry) => [entry.id, entry]));
-  const merged = builtIn.map((entry) => byId.get(entry.id) ?? entry);
-  const replaced = new Set(builtIn.map((entry) => entry.id));
-  for (const entry of supplied) {
+  const library = assertArray(builtIn, "builtIn");
+  const extra = supplied === void 0 || supplied === null ? [] : assertArray(supplied, "supplied");
+  if (extra.length === 0) {
+    return [...library];
+  }
+  const idOf = (entry, index, side) => assertRecord(entry, `${side}[${index}]`).id;
+  const byId = new Map(extra.map((entry, index) => [idOf(entry, index, "supplied"), entry]));
+  const merged = library.map((entry, index) => byId.get(idOf(entry, index, "builtIn")) ?? entry);
+  const replaced = new Set(library.map((entry, index) => idOf(entry, index, "builtIn")));
+  for (const entry of extra) {
     if (!replaced.has(entry.id)) {
       merged.push(entry);
     }
@@ -338,30 +439,49 @@ function mergeVocabulary(builtIn, supplied) {
 }
 function vocabularyOfKind(entries, isMaterial) {
   const out = [];
-  for (const entry of entries) {
-    if (isMaterial(entry.material)) {
+  const recognises = assertFunction(isMaterial, "isMaterial");
+  for (const entry of assertArray(entries, "entries")) {
+    if (recognises(assertRecord(entry, "entry").material)) {
       out.push(entry);
     }
   }
   return out;
 }
+function assertNames(values, allowed, label) {
+  if (!Array.isArray(values)) {
+    throw new InvalidInputError(
+      `${label} must be an array of names; received ${describeRejected(values)}`
+    );
+  }
+  values.forEach((value, index) => {
+    assertOneOf(value, allowed, `${label}[${index}]`);
+  });
+}
 function assertVocabulary(entry, label = "vocabulary entry") {
+  if (typeof entry !== "object" || entry === null) {
+    throw new InvalidInputError(
+      `${label} must be a dictionary entry; received ${describeRejected(entry)}`
+    );
+  }
   assertOneOf(entry.genre, GENRES, `${label} genre`);
   assertOneOf(entry.provenance?.basis, PROVENANCE_BASES, `${label} provenance basis`);
-  entry.articulations.forEach((articulation, index) => {
-    assertOneOf(articulation, ARTICULATIONS, `${label} articulations[${index}]`);
-  });
-  entry.sections?.forEach((section, index) => {
-    assertOneOf(section, PUBLIC_SECTIONS, `${label} sections[${index}]`);
-  });
-  entry.fitsOver?.forEach((quality, index) => {
-    assertOneOf(quality, chordQualities(), `${label} fitsOver[${index}]`);
-  });
+  assertNames(entry.articulations, ARTICULATIONS, `${label} articulations`);
+  if (entry.sections !== void 0) {
+    assertNames(entry.sections, PUBLIC_SECTIONS, `${label} sections`);
+  }
+  if (entry.fitsOver !== void 0) {
+    assertNames(entry.fitsOver, chordQualities(), `${label} fitsOver`);
+  }
   if (entry.ts !== void 0) {
     assertTimeSignature(entry.ts, `${label} ts`);
   }
   assertRange(entry.difficulty, 1, 5, `${label} difficulty`);
-  if (entry.tempoRange) {
+  if (entry.tempoRange !== void 0) {
+    if (!Array.isArray(entry.tempoRange) || entry.tempoRange.length !== 2) {
+      throw new InvalidInputError(
+        `${label} tempoRange must be a low and a high tempo; received ${describeRejected(entry.tempoRange)}`
+      );
+    }
     const [low, high] = entry.tempoRange;
     assertRange(low, Number.MIN_VALUE, 1e3, `${label} tempoRange low`);
     assertRange(high, low, 1e3, `${label} tempoRange high`);
@@ -389,60 +509,41 @@ function assertDifficulty(difficulty, label = "complexity difficulty") {
   return assertRange(difficulty, MIN_DIFFICULTY, MAX_DIFFICULTY, label);
 }
 function sustainsStrokes(stepBeats, bpm, difficulty) {
-  if (difficulty === void 0 || bpm === void 0 || stepBeats <= 0) {
+  if (difficulty === void 0 || bpm === void 0) {
+    return true;
+  }
+  assertDifficulty(difficulty);
+  assertFiniteNumber(bpm, "bpm");
+  if (assertFiniteNumber(stepBeats, "stepBeats") <= 0) {
     return true;
   }
   const rate = 1 / (stepBeats * secondsPerBeat(bpm));
   return rate <= atLevel(STROKES_PER_SECOND, difficulty);
 }
 function sustainsShift(semitones, stepBeats, bpm, difficulty) {
-  if (difficulty === void 0 || bpm === void 0 || stepBeats <= 0) {
+  if (difficulty === void 0 || bpm === void 0) {
+    return true;
+  }
+  assertDifficulty(difficulty);
+  assertFiniteNumber(bpm, "bpm");
+  assertFiniteSemitones(semitones);
+  if (assertFiniteNumber(stepBeats, "stepBeats") <= 0) {
     return true;
   }
   const seconds = stepBeats * secondsPerBeat(bpm);
   return Math.abs(semitones) / seconds <= atLevel(FRETS_PER_SECOND, difficulty);
 }
 
-// src/generate/context/draw.ts
-function drawFrom(rng, path) {
-  const draw = rng.at(...path);
-  if (!(draw >= 0 && draw < 1)) {
-    throw new InvalidInputError(`positional draw must be in [0, 1); received ${draw}`);
-  }
-  return draw;
-}
-function drawsFrom(rng, ...prefix) {
-  const at2 = (...path) => drawFrom(rng, [...prefix, ...path]);
-  return {
-    at: at2,
-    prob: (p, ...path) => includeAt(rng, p, ...prefix, ...path),
-    range: (lo, hi, ...path) => {
-      assertInteger(lo, "range lower bound");
-      assertInteger(hi, "range upper bound");
-      if (lo > hi) {
-        throw new InvalidInputError(
-          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
-        );
-      }
-      return lo + Math.floor(at2(...path) * (hi - lo + 1));
-    },
-    float: (lo, hi, ...path) => {
-      assertFiniteNumber(lo, "float lower bound");
-      assertFiniteNumber(hi, "float upper bound");
-      if (lo > hi) {
-        throw new InvalidInputError(
-          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
-        );
-      }
-      return lo + at2(...path) * (hi - lo);
-    }
-  };
-}
-
 // src/generate/context/index.ts
 var DEFAULT_SEED = 0;
 var VERSION_SEGMENT = "v";
 function resolveContext(input) {
+  if (input !== null && typeof input !== "number" && input !== void 0) {
+    assertRecord(input, "ctx");
+  }
+  if (input === null) {
+    throw new InvalidInputError("ctx must be a seed or a generation context; received null");
+  }
   const ctx = typeof input === "number" ? { seed: input } : input ?? { seed: DEFAULT_SEED };
   const seed = assertInteger(ctx.seed ?? DEFAULT_SEED, "seed", 0, 4294967295);
   const complexity = ctx.complexity ?? {};
@@ -472,24 +573,59 @@ function resolveContext(input) {
 }
 function resolveContextWith(input, sugar) {
   const base = resolveContext(input);
-  const ornament2 = base.ornament ?? (sugar.ornament === void 0 ? void 0 : assertRange(sugar.ornament, 0, 1, "complexity ornament"));
+  const supplied = sugar.ornament === void 0 ? void 0 : assertRange(sugar.ornament, 0, 1, "complexity ornament");
+  const ornament2 = base.ornament ?? supplied;
   return { ...base, ornament: ornament2 };
 }
 
 // src/generate/bass/internal.ts
 var STRONG_VELOCITY = 100;
 var WEAK_VELOCITY = 80;
-var EPS = 1e-9;
+var DEFAULT_TS = { numerator: 4, denominator: 4 };
+var DEFAULT_OCTAVE = 2;
 function placePc(pc, anchor, low) {
-  const high = low + 12;
-  let midi = pc + 12 * Math.round((anchor - pc) / 12);
-  while (midi < low) {
-    midi += 12;
+  return foldIntoBand(pc + 12 * Math.round((anchor - pc) / 12), low);
+}
+function placeAboveBass(pc, bassMidi) {
+  return foldIntoBand(pc + 12 * Math.round((bassMidi - pc) / 12), bassMidi);
+}
+function placeRoot(pc, low) {
+  return low + pitchClassOf(pc - low);
+}
+function barTiles(startBeat, endBeat, ts) {
+  const barBeats = beatsPerBar(ts);
+  const tiles = [];
+  for (let index = 0; ; index += 1) {
+    const tileStart = startBeat + index * barBeats;
+    if (tileStart >= endBeat - BEAT_EPS) {
+      break;
+    }
+    tiles.push({ startBeat: tileStart, endBeat: Math.min(tileStart + barBeats, endBeat) });
   }
-  while (midi > high) {
-    midi -= 12;
+  return tiles;
+}
+function midBarPulse(barStart, ts) {
+  const pulse2 = pulseBeats(ts);
+  return barStart + Math.floor((beatsPerBar(ts) / 2 + BEAT_EPS) / pulse2) * pulse2;
+}
+function assertBassSegments(segments) {
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (segment === void 0) {
+      continue;
+    }
+    assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
+    assertRange(segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
+    if (segment.endBeat <= segment.startBeat) {
+      throw new InvalidInputError(`segments[${index}] must have a positive duration`);
+    }
+    const previous = segments[index - 1];
+    if (previous !== void 0 && segment.startBeat < previous.endBeat - BEAT_EPS) {
+      throw new InvalidInputError(
+        `bass segments must not overlap: segments ${index - 1} and ${index} overlap`
+      );
+    }
   }
-  return midi;
 }
 function chordTonePcs(chord) {
   const seen = /* @__PURE__ */ new Set();
@@ -506,29 +642,33 @@ function chordTonePcs(chord) {
   }
   return pcs;
 }
-function fifthPcOf(chord) {
-  const fifths = new Set(chord.intervals.map((i) => pitchClassOf(i)));
-  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
-  return chosen === void 0 ? pitchClassOf(chord.rootPc) : pitchClassOf(chord.rootPc + chosen);
+function fifthPcOf2(chord) {
+  return fifthPcOf(chord) ?? pitchClassOf(chord.rootPc);
 }
 function bassPcOf(chord) {
   return pitchClassOf(chord.bassPc ?? chord.rootPc);
 }
+function bassToneCycle(chord) {
+  const bass = bassPcOf(chord);
+  const tones = chordTonePcs(chord);
+  const at2 = tones.indexOf(bass);
+  return at2 < 0 ? [bass, ...tones] : [...tones.slice(at2), ...tones.slice(0, at2)];
+}
 function beatPositions(start, end, ts) {
   const positions = [];
   const barBeats = beatsPerBar(ts);
   const pulse2 = pulseBeats(ts);
   const firstBar = Math.floor(start / barBeats);
-  const lastBar = Math.floor((end - EPS) / barBeats);
+  const lastBar = Math.floor((end - BEAT_EPS) / barBeats);
   for (let bar2 = firstBar; bar2 <= lastBar; bar2 += 1) {
     const barStart = bar2 * barBeats;
-    const firstPulse = Math.max(0, Math.ceil((start - barStart - EPS) / pulse2));
+    const firstPulse = Math.max(0, Math.ceil((start - barStart - BEAT_EPS) / pulse2));
     for (let index = firstPulse; ; index += 1) {
       const position = barStart + index * pulse2;
-      if (position >= barStart + barBeats - EPS || position >= end - EPS) {
+      if (position >= barStart + barBeats - BEAT_EPS || position >= end - BEAT_EPS) {
         break;
       }
-      if (position >= start - EPS) {
+      if (position >= start - BEAT_EPS) {
         positions.push(position);
       }
     }
@@ -539,70 +679,88 @@ function beatPositions(start, end, ts) {
   return positions;
 }
 function foldIntoBand(midi, low) {
-  let result = midi;
-  while (result < low) {
-    result += 12;
-  }
-  while (result > low + 12) {
-    result -= 12;
-  }
-  return result;
+  const raised = midi + 12 * Math.max(0, Math.ceil((low - midi) / 12));
+  return raised - 12 * Math.max(0, Math.ceil((raised - low - 12) / 12));
 }
 function bandFloor(low, instrument) {
   if (!instrument) {
     return low;
   }
   const range = instrumentRange(instrument);
-  let floor = low;
-  while (floor + 12 > range.high) {
-    floor -= 12;
-  }
-  while (floor < range.low) {
-    floor += 12;
-  }
-  return floor;
+  const dropped = low - 12 * Math.max(0, Math.ceil((low + 12 - range.high) / 12));
+  return dropped + 12 * Math.max(0, Math.ceil((range.low - dropped) / 12));
 }
-function approachNote(target, from, low, key, chromatic) {
+function approachNote(target, from, key, chromatic) {
   const dir = from <= target ? -1 : 1;
+  const near = neighborOnSide(target, dir, key, chromatic);
+  const far = neighborOnSide(target, -dir, key, chromatic);
+  const playable = (midi) => midi >= 0 && midi <= 127;
+  if (playable(near) && near !== from) {
+    return near;
+  }
+  return playable(far) ? far : near;
+}
+function neighborOnSide(target, dir, key, chromatic) {
   const semitone = target + dir;
   if (chromatic) {
-    return foldIntoBand(semitone, low);
+    return semitone;
   }
   const cand = nearestScaleTone(target + dir * 2, key);
   const step = Math.abs(cand - target);
-  return foldIntoBand(step >= 1 && step <= 2 ? cand : semitone, low);
+  return step >= 1 && step <= 2 ? cand : semitone;
+}
+function bassRegister(named, given, octave) {
+  const instrument = given === void 0 ? named !== void 0 && named.kind === "stringed" ? named : void 0 : toStringedProfile(given, "instrument");
+  return { instrument, low: bandFloor(octave * 12 + 12, instrument) };
 }
 
 // src/generate/vocabulary/transform.ts
 var BAR_STEPS = 16;
 var BEAT_STEPS = 4;
 var STEP_BEATS = 1 / BEAT_STEPS;
+function assertGridEvents(events) {
+  assertArray(events, "figure events");
+  events.forEach((event, index) => {
+    assertRecord(event, `figure events[${index}]`);
+    assertFiniteNumber(event.step, `figure events[${index}].step`);
+  });
+  return events;
+}
+function assertSpanSteps(spanSteps) {
+  return assertPositiveInt(spanSteps, "figure span steps");
+}
 function streamOf(event) {
   return event.limb ?? event.voice ?? "";
 }
-function gridMetricWeight(step) {
-  const inBar = (step % BAR_STEPS + BAR_STEPS) % BAR_STEPS;
-  if (inBar === 0) {
-    return 4;
-  }
-  if (inBar % 8 === 0) {
-    return 3;
-  }
-  if (inBar % 4 === 0) {
-    return 2;
-  }
-  if (inBar % 2 === 0) {
-    return 1;
+var FIGURE_TS = { numerator: 4, denominator: 4 };
+function subdivisionBeats(ts) {
+  const pulse2 = pulseBeats(ts);
+  return isCompound(ts) ? pulse2 / 3 : pulse2 / 2;
+}
+function gridMetricWeight(step, ts) {
+  assertFiniteNumber(step, "step");
+  return stepWeight(step, meterAt(0, toMeterData(ts, "ts")));
+}
+function stepWeight(step, ts) {
+  const beats = step * STEP_BEATS;
+  const weight = metricWeight(beats, ts);
+  if (weight > 0) {
+    return weight + 1;
   }
-  return 0;
+  const subdivision = subdivisionBeats(ts);
+  const divisions = beats / subdivision;
+  return Math.abs(divisions - Math.round(divisions)) < 1e-9 ? 1 : 0;
 }
-function thin(events, amount) {
+function thin(events, amount, ts) {
+  const figure = assertGridEvents(events);
   assertRange(amount, 0, 1, "thin amount");
+  const signature = meterAt(0, toMeterData(ts, "ts"));
   const floor = Math.min(4, Math.floor(amount * 5));
-  return events.filter((event) => gridMetricWeight(event.step) >= floor);
+  return figure.filter((event) => stepWeight(event.step, signature) >= floor);
 }
 function double(events, spanSteps = BAR_STEPS) {
-  const sorted = [...events].sort((a, b) => a.step - b.step);
+  assertSpanSteps(spanSteps);
+  const sorted = [...assertGridEvents(events)].sort((a, b) => a.step - b.step);
   const out = [];
   for (let i = 0; i < sorted.length; i += 1) {
     const event = sorted[i];
@@ -620,30 +778,46 @@ function double(events, spanSteps = BAR_STEPS) {
 }
 var ADDED_NOTE_VELOCITY = 0.75;
 function halfTime(events, spanSteps = BAR_STEPS) {
-  return events.map((event) => ({ ...event, step: event.step * 2 })).filter((event) => event.step < spanSteps);
+  assertSpanSteps(spanSteps);
+  return assertGridEvents(events).map((event) => ({ ...event, step: event.step * 2 })).filter((event) => event.step < spanSteps);
 }
 function doubleTime(events, spanSteps = BAR_STEPS) {
-  const out = [];
+  assertSpanSteps(spanSteps);
+  assertGridEvents(events);
+  const merged = /* @__PURE__ */ new Map();
+  const place = (event, step, velocity) => {
+    const key = `${streamOf(event)}@${step}`;
+    const held = merged.get(key);
+    if (held === void 0 || velocity > held.velocity) {
+      merged.set(key, { ...event, step, velocity });
+    }
+  };
   for (const event of events) {
     const step = Math.round(event.step / 2);
-    out.push({ ...event, step });
+    place(event, step, event.velocity);
     const repeated = step + spanSteps / 2;
     if (repeated < spanSteps) {
-      out.push({ ...event, step: repeated, velocity: event.velocity * ADDED_NOTE_VELOCITY });
+      place(event, repeated, event.velocity * ADDED_NOTE_VELOCITY);
     }
   }
-  return out.sort((a, b) => a.step - b.step);
+  return [...merged.values()].sort((a, b) => a.step - b.step);
 }
 function syncopate(events, amount, draw, ...path) {
-  assertRange(amount, 0, 1, "syncopate amount");
-  const occupied = new Set(events.map((event) => `${streamOf(event)}@${event.step}`));
-  const out = [...events];
-  for (const event of events) {
+  const figure = assertGridEvents(events);
+  const sampler = assertDraw(draw);
+  assertSeedPath(path);
+  const asked = typeof amount === "number" ? void 0 : assertRecord(amount, "amount");
+  const dial = asked === void 0 ? amount : asked.amount;
+  const signature = meterAt(0, toMeterData(asked?.ts ?? FIGURE_TS, "ts"));
+  assertRange(dial, 0, 1, "syncopate amount");
+  const occupied = new Set(figure.map((event) => `${streamOf(event)}@${event.step}`));
+  const out = [...figure];
+  for (const event of figure) {
     const anticipated = event.step - 1;
-    if (gridMetricWeight(event.step) < 2 || anticipated < 1 || occupied.has(`${streamOf(event)}@${anticipated}`)) {
+    if (stepWeight(event.step, signature) < 2 || anticipated < 1 || occupied.has(`${streamOf(event)}@${anticipated}`)) {
       continue;
     }
-    if (!draw.prob(amount, ...path, "syncopate", event.step)) {
+    if (!sampler.prob(dial, ...path, "syncopate", event.step)) {
       continue;
     }
     out.push({ ...event, step: anticipated, velocity: event.velocity * ADDED_NOTE_VELOCITY });
@@ -651,35 +825,55 @@ function syncopate(events, amount, draw, ...path) {
   return out.sort((a, b) => a.step - b.step);
 }
 function ornamentBy(events, isOrnament, amount, draw, ...path) {
+  const figure = assertGridEvents(events);
+  const marks = assertFunction(isOrnament, "isOrnament");
+  const sampler = assertDraw(draw);
+  assertSeedPath(path);
   assertRange(amount, 0, 1, "ornament amount");
-  return events.filter(
-    (event) => !isOrnament(event) || draw.prob(amount, ...path, "ornament", event.step)
+  return figure.filter(
+    (event) => !marks(event) || sampler.prob(amount, ...path, "ornament", event.step)
   );
 }
 var NEUTRAL_RHYTHMIC = 0.5;
 function deform(events, opts, draw, ...path) {
-  const spanSteps = opts.spanSteps ?? BAR_STEPS;
-  let out = opts.rate === "half" ? halfTime(events, spanSteps) : opts.rate === "double" ? doubleTime(events, spanSteps) : [...events];
-  if (opts.rhythmic !== void 0) {
-    const rhythmic = assertRange(opts.rhythmic, 0, 1, "complexity rhythmic");
+  const figure = assertGridEvents(events);
+  const asked = assertRecord(opts, "opts");
+  assertDraw(draw);
+  assertSeedPath(path);
+  const spanSteps = assertSpanSteps(asked.spanSteps === void 0 ? BAR_STEPS : asked.spanSteps);
+  const ts = asked.ts ?? FIGURE_TS;
+  let out = asked.rate === "half" ? halfTime(figure, spanSteps) : asked.rate === "double" ? doubleTime(figure, spanSteps) : [...figure];
+  if (asked.rhythmic !== void 0) {
+    const rhythmic = assertRange(asked.rhythmic, 0, 1, "complexity rhythmic");
     if (rhythmic < NEUTRAL_RHYTHMIC) {
-      out = thin(out, (NEUTRAL_RHYTHMIC - rhythmic) / NEUTRAL_RHYTHMIC);
+      out = thin(out, (NEUTRAL_RHYTHMIC - rhythmic) / NEUTRAL_RHYTHMIC, ts);
     } else if (rhythmic > NEUTRAL_RHYTHMIC) {
-      out = syncopate(out, (rhythmic - NEUTRAL_RHYTHMIC) / NEUTRAL_RHYTHMIC, draw, ...path);
+      out = syncopate(
+        out,
+        { amount: (rhythmic - NEUTRAL_RHYTHMIC) / NEUTRAL_RHYTHMIC, ts },
+        draw,
+        ...path
+      );
     }
   }
-  if (opts.ornament !== void 0 && opts.isOrnament) {
-    const isOrnament = opts.isOrnament;
-    out = ornamentBy(out, (event) => isOrnament(event), opts.ornament, draw, ...path);
+  if (asked.ornament !== void 0 && asked.isOrnament) {
+    const isOrnament = assertFunction(asked.isOrnament, "opts.isOrnament");
+    out = ornamentBy(out, (event) => isOrnament(event), asked.ornament, draw, ...path);
   }
   return out.sort((a, b) => a.step - b.step);
 }
 function withinCeiling(events, bpm, difficulty) {
-  if (difficulty === void 0 || bpm === void 0 || events.length < 2) {
+  const figure = assertGridEvents(events);
+  if (difficulty === void 0 || bpm === void 0) {
+    return true;
+  }
+  assertFiniteNumber(bpm, "bpm");
+  assertDifficulty(difficulty);
+  if (figure.length < 2) {
     return true;
   }
   const byStream = /* @__PURE__ */ new Map();
-  for (const event of events) {
+  for (const event of figure) {
     const stream = streamOf(event);
     const steps = byStream.get(stream);
     if (steps) {
@@ -704,7 +898,79 @@ function withinCeiling(events, bpm, difficulty) {
   return sustainsStrokes(closest * STEP_BEATS, bpm, difficulty);
 }
 
-// src/generate/bass/licks.ts
+// src/generate/bass/degrees.ts
+var MAJOR_DEGREE_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
+var HEPTATONIC_SIZE = 7;
+function impliedScaleTones(chord) {
+  if (chordDegreeSemitone(7, chord) === void 0) {
+    return void 0;
+  }
+  for (const match of chordScales(chord)) {
+    const mask = namedScaleMask(match.name);
+    if (mask === void 0) {
+      continue;
+    }
+    const tones = [];
+    for (let offset = 0; offset < 12; offset += 1) {
+      if ((mask >> offset & 1) === 1) {
+        tones.push(offset);
+      }
+    }
+    if (tones.length === HEPTATONIC_SIZE) {
+      return tones;
+    }
+  }
+  return void 0;
+}
+function replacedDegreeSemitone(degree, chord) {
+  if (degree !== 3) {
+    return void 0;
+  }
+  const sounds = (semitones) => chord.intervals.some((interval) => pitchClassOf(interval) === semitones);
+  if (sounds(3) || sounds(4)) {
+    return void 0;
+  }
+  return sounds(5) ? 5 : sounds(2) ? 2 : void 0;
+}
+function degreeSemitone(degree, alter, chord, key, implied) {
+  const octaves = Math.floor((degree - 1) / 7);
+  const within = (degree - 1) % 7 + 1;
+  const template = MAJOR_DEGREE_SEMITONES[within - 1] ?? 0;
+  const semitone = alter !== 0 ? template : chordDegreeSemitone(within, chord) ?? replacedDegreeSemitone(within, chord) ?? implied?.[within - 1] ?? // A degree neither the chord nor its quality settles is a passing tone,
+  // so the key decides it.
+  nearestScaleTone(chord.rootPc + template, key) - chord.rootPc;
+  return pitchClassOf(semitone) + 12 * octaves + alter;
+}
+function chordDegreeSemitone(degree, chord) {
+  for (const interval of chord.intervals) {
+    if (degreeOfInterval(interval, chord) === degree) {
+      return interval;
+    }
+  }
+  return void 0;
+}
+
+// src/generate/vocabulary/freeze.ts
+function freezeReachable(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return;
+  }
+  const object = value;
+  if (seen.has(object)) {
+    return;
+  }
+  seen.add(object);
+  Object.freeze(object);
+  for (const child of Object.values(object)) {
+    freezeReachable(child, seen);
+  }
+}
+function deepFreeze(value) {
+  freezeReachable(value, /* @__PURE__ */ new WeakSet());
+  return value;
+}
+
+// src/generate/bass/licks-data.ts
 function isLickMaterial(material) {
   const candidate = material;
   return typeof candidate === "object" && candidate !== null && typeof candidate.lengthSteps === "number" && Array.isArray(candidate.notes);
@@ -714,7 +980,7 @@ function note(degree, step, velocity, extra) {
 }
 var BAR = 4 * BEAT_STEPS;
 var FOUR_FOUR = { numerator: 4, denominator: 4 };
-var BASS_LICKS = Object.freeze([
+var BASS_LICKS = deepFreeze([
   {
     id: "motownWalkDown",
     genre: "motown",
@@ -759,7 +1025,7 @@ var BASS_LICKS = Object.freeze([
     id: "funkSixteenthPop",
     genre: "funk",
     difficulty: 4,
-    articulations: ["mute", "slide"],
+    articulations: ["mute"],
     ts: FOUR_FOUR,
     tempoRange: [84, 124],
     material: {
@@ -842,7 +1108,7 @@ var BASS_LICKS = Object.freeze([
     id: "gospelPassing",
     genre: "gospel",
     difficulty: 4,
-    articulations: ["slide"],
+    articulations: [],
     ts: FOUR_FOUR,
     tempoRange: [60, 108],
     material: {
@@ -883,7 +1149,7 @@ var BASS_LICKS = Object.freeze([
     id: "reggaeOffbeatDrop",
     genre: "reggae",
     difficulty: 3,
-    articulations: ["mute"],
+    articulations: [],
     ts: FOUR_FOUR,
     tempoRange: [64, 104],
     material: {
@@ -902,103 +1168,61 @@ var BASS_LICKS = Object.freeze([
     }
   }
 ]);
-var MAJOR_DEGREE_SEMITONES = [0, 2, 4, 5, 7, 9, 11];
-function degreeSemitone(degree, alter, chord, key) {
-  const octaves = Math.floor((degree - 1) / 7);
-  const within = (degree - 1) % 7 + 1;
-  const fromChord = chordDegreeSemitone(within, chord);
-  const template = MAJOR_DEGREE_SEMITONES[within - 1] ?? 0;
-  const semitone = fromChord ?? // A degree the chord does not name is a passing tone, so the key decides it.
-  nearestScaleTone(chord.rootPc + template, key) - chord.rootPc;
-  return pitchClassOf(semitone) + 12 * octaves + alter;
-}
-function chordDegreeSemitone(degree, chord) {
-  for (const interval of chord.intervals) {
-    if (degreeOfInterval(interval) === degree) {
-      return interval;
-    }
-  }
-  return void 0;
-}
-function degreeOfInterval(interval) {
-  const within = (interval % 12 + 12) % 12;
-  if (within === 0) {
-    return 1;
-  }
-  if (within === 1 || within === 2) {
-    return 2;
-  }
-  if (within === 3 || within === 4) {
-    return 3;
-  }
-  if (within === 5) {
-    return 4;
-  }
-  if (within === 6 || within === 7 || within === 8) {
-    return 5;
-  }
-  if (within === 9) {
-    return 6;
-  }
-  return 7;
-}
-var DEFAULT_TS = FOUR_FOUR;
-var DEFAULT_OCTAVE = 2;
+
+// src/generate/bass/licks.ts
 var DEFAULT_BPM = 120;
 var DEFAULT_LICK_DENSITY = 0.6;
-var EPS2 = 1e-9;
 function placeLicks(timeline, key, opts) {
-  assertGenerationBudget(timeline.length, "lick segments", opts.budget);
-  const genre = assertOneOf(opts.genre, GENRES, "lick genre");
-  const ts = opts.ts ?? DEFAULT_TS;
-  assertTimeSignature(ts, "lick time signature");
-  const octave = opts.octave ?? DEFAULT_OCTAVE;
+  const asked = assertRecord(opts, "opts");
+  const placement = assertArray(
+    timeline,
+    "timeline"
+  );
+  assertGenerationBudget(placement.length, "lick segments", asked.budget);
+  const genre = assertOneOf(asked.genre, GENRES, "lick genre");
+  const ts = meterAt(0, toMeterData(asked.ts ?? DEFAULT_TS, "ts"));
+  const octave = asked.octave ?? DEFAULT_OCTAVE;
   assertInteger(octave, "lick octave", -1, 8);
   const scale = toKeyScale(key);
-  const segments = timeline.map((segment) => ({ ...segment, chord: toChordData(segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
-  for (const segment of segments) {
-    assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, "lick segment startBeat");
-    if (segment.endBeat <= segment.startBeat) {
-      throw new InvalidInputError(
-        `lick segment at beat ${segment.startBeat} must have a positive duration`
-      );
-    }
-  }
+  const segments = placement.map((segment) => ({ ...segment, chord: toChordData(segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
+  assertBassSegments(segments);
   if (segments.length === 0) {
     return [];
   }
-  const resolved = resolveContext(opts.ctx);
+  const barBeats = beatsPerBar(ts);
+  const estimatedBars = segments.reduce(
+    (count, segment) => count + Math.max(1, Math.ceil((segment.endBeat - segment.startBeat) / barBeats)),
+    0
+  );
+  assertGenerationBudget(estimatedBars, "lick bars", asked.budget);
+  const resolved = resolveContext(asked.ctx);
   const draw = resolved.part("bass");
   const bpm = resolved.bpm ?? DEFAULT_BPM;
   const density = resolved.rhythmic ?? DEFAULT_LICK_DENSITY;
-  const difficulty = resolved.difficulty ?? (opts.difficulty === void 0 ? void 0 : assertDifficulty(opts.difficulty, "lick difficulty"));
-  const named = resolved.instrument("bass");
-  const instrument = opts.instrument ?? (named !== void 0 && named.kind === "stringed" ? named : void 0);
-  const low = bandFloor(octave * 12 + 12, instrument);
+  const supplied = asked.difficulty === void 0 ? void 0 : assertDifficulty(asked.difficulty, "lick difficulty");
+  const difficulty = resolved.difficulty ?? supplied;
+  const { instrument, low } = bassRegister(resolved.instrument("bass"), asked.instrument, octave);
   const dictionary = mergeVocabulary(
     BASS_LICKS,
     vocabularyOfKind(resolved.vocabulary, isLickMaterial)
   );
   const playable = instrument === void 0 ? {} : { articulations: instrument.articulations };
-  const barBeats = beatsPerBar(ts);
   const raw = [];
-  let anchor = low;
-  let rootAnchor = low;
   for (let index = 0; index < segments.length; index += 1) {
     const segment = segments[index];
     if (!segment) {
       continue;
     }
     const rootPc = bassPcOf(segment.chord);
-    const onsets = [];
+    const rootMidi = placeRoot(rootPc, low);
+    const implied = impliedScaleTones(segment.chord);
     let lastTilePlayed = false;
+    let playedTile;
     let firstOnset = segment.startBeat;
-    for (let tile = 0; ; tile += 1) {
-      const tileStart = segment.startBeat + tile * barBeats;
+    const tiles = barTiles(segment.startBeat, segment.endBeat, ts);
+    for (let tile = 0; tile < tiles.length; tile += 1) {
+      const tileStart = tiles[tile]?.startBeat ?? segment.startBeat;
       const remaining = segment.endBeat - tileStart;
-      if (remaining <= EPS2) {
-        break;
-      }
       const entry = pickVocabulary(
         dictionary,
         { genre, bpm, ts, difficulty, quality: segment.chord.quality, ...playable },
@@ -1016,28 +1240,34 @@ function placeLicks(timeline, key, opts) {
         draw,
         [index, tile],
         bpm,
-        difficulty
+        difficulty,
+        ts
       ) : void 0;
       lastTilePlayed = notes !== void 0;
+      if (notes !== void 0 && entry !== void 0) {
+        playedTile = { material: entry.material, tileStart };
+      }
       const rootStep = entry === void 0 ? 0 : anchorStepOf(entry.material, remaining);
       const rootAt = tileStart + rootStep * STEP_BEATS;
       if (tile === 0) {
         firstOnset = rootAt;
       }
-      onsets.push(rootAt);
-      rootAnchor = placePc(rootPc, rootAnchor, low);
-      anchor = rootAnchor;
-      raw.push({ startBeat: rootAt, pitch: rootAnchor, velocity: STRONG_VELOCITY });
+      raw.push({ startBeat: rootAt, pitch: rootMidi, velocity: STRONG_VELOCITY });
       if (notes) {
-        const figureRoot = placePc(pitchClassOf(segment.chord.rootPc), rootAnchor, low);
+        const figureRoot = segment.chord.bassPc === void 0 ? placePc(pitchClassOf(segment.chord.rootPc), rootMidi, low) : placeAboveBass(pitchClassOf(segment.chord.rootPc), rootMidi);
         for (const lickNote of notes) {
           const at2 = tileStart + lickNote.step * STEP_BEATS;
-          const offset = degreeSemitone(lickNote.degree, lickNote.alter ?? 0, segment.chord, scale);
-          anchor = figureRoot + offset;
-          onsets.push(at2);
+          const offset = degreeSemitone(
+            lickNote.degree,
+            lickNote.alter ?? 0,
+            segment.chord,
+            scale,
+            implied
+          );
+          const pitch = Math.abs(at2 - rootAt) < BEAT_EPS && lickNote.degree === 1 && (lickNote.alter ?? 0) === 0 ? rootMidi : figureRoot + offset;
           raw.push({
             startBeat: at2,
-            pitch: anchor,
+            pitch,
             velocity: Math.round(
               (isStrongBeat(at2, ts) ? STRONG_VELOCITY : WEAK_VELOCITY) * lickNote.velocity
             ),
@@ -1048,19 +1278,21 @@ function placeLicks(timeline, key, opts) {
     }
     const next = segments[index + 1];
     if (next && lastTilePlayed) {
-      const approachAt = next.startBeat - STEP_BEATS * BEAT_STEPS;
-      const alreadySounds = onsets.some((onset) => Math.abs(onset - approachAt) < EPS2);
-      if (approachAt > firstOnset + EPS2 && !alreadySounds) {
-        const nextRoot = placePc(bassPcOf(next.chord), rootAnchor, low);
-        const midi = approachNote(
-          nextRoot,
-          anchor,
-          low,
-          scale,
-          draw.prob(0.5, "lickApproach", index)
-        );
-        anchor = midi;
-        raw.push({ startBeat: approachAt, pitch: midi, velocity: WEAK_VELOCITY });
+      const lastBeat = next.startBeat - STEP_BEATS * BEAT_STEPS;
+      const approachAt = materialOnsetIn(playedTile, lastBeat, next.startBeat) ?? lastBeat;
+      if (approachAt > firstOnset + BEAT_EPS) {
+        const nextRoot = placeRoot(bassPcOf(next.chord), low);
+        const occupied = soundingAt(raw, approachAt);
+        const distance = occupied === void 0 ? 0 : Math.abs(occupied.pitch - nextRoot);
+        if (occupied === void 0 || distance < 1 || distance > 2) {
+          const from = lastPitchBefore(raw, approachAt, rootMidi);
+          const midi = approachNote(nextRoot, from, scale, draw.prob(0.5, "lickApproach", index));
+          if (occupied === void 0) {
+            raw.push({ startBeat: approachAt, pitch: midi, velocity: WEAK_VELOCITY });
+          } else {
+            occupied.pitch = midi;
+          }
+        }
       }
     }
   }
@@ -1078,7 +1310,7 @@ function placeLicks(timeline, key, opts) {
       nextStart - item.startBeat,
       written === void 0 ? Number.POSITIVE_INFINITY : written * STEP_BEATS
     );
-    if (durationBeat <= EPS2) {
+    if (durationBeat <= BEAT_EPS) {
       continue;
     }
     const placed = instrument ? foldIntoRange(item.pitch, instrument) : item.pitch;
@@ -1095,6 +1327,38 @@ function placeLicks(timeline, key, opts) {
   }
   return out;
 }
+function soundingAt(raw, at2) {
+  for (let index = raw.length - 1; index >= 0; index -= 1) {
+    const item = raw[index];
+    if (item !== void 0 && Math.abs(item.startBeat - at2) < BEAT_EPS) {
+      return item;
+    }
+  }
+  return void 0;
+}
+function materialOnsetIn(played, from, to) {
+  if (played === void 0) {
+    return void 0;
+  }
+  let last;
+  for (const note2 of played.material.notes) {
+    const at2 = played.tileStart + note2.step * STEP_BEATS;
+    if (at2 < from - BEAT_EPS || at2 > to - BEAT_EPS) {
+      continue;
+    }
+    last = last === void 0 ? at2 : Math.max(last, at2);
+  }
+  return last;
+}
+function lastPitchBefore(raw, at2, fallback) {
+  for (let index = raw.length - 1; index >= 0; index -= 1) {
+    const item = raw[index];
+    if (item !== void 0 && item.startBeat < at2 - BEAT_EPS) {
+      return item.pitch;
+    }
+  }
+  return fallback;
+}
 function anchorStepOf(material, spanBeats) {
   let first;
   for (const note2 of material.notes) {
@@ -1102,15 +1366,19 @@ function anchorStepOf(material, spanBeats) {
       first = note2.step;
     }
   }
-  if (first === void 0 || first < 0 || first * STEP_BEATS >= spanBeats - EPS2) {
+  if (first === void 0 || first < 0 || first * STEP_BEATS >= spanBeats - BEAT_EPS) {
     return 0;
   }
   return first;
 }
-function fitToSegment(material, spanBeats, density, resolved, draw, path, bpm, difficulty) {
+function fitToSegment(material, spanBeats, density, resolved, draw, path, bpm, difficulty, ts) {
   const deformed = deform(
     material.notes,
     {
+      // The figure is thinned against the bar it is played in, not against a
+      // four-four ladder: a downbeat of the meter in force must outrank an
+      // offbeat of some other meter.
+      ts,
       // The one density the whole generator reads, defaults included: passing
       // the documented default explicitly and leaving it out have to be the
       // same request, and they were not while the figure was deformed by the
@@ -1125,7 +1393,7 @@ function fitToSegment(material, spanBeats, density, resolved, draw, path, bpm, d
     ...path
   );
   const spanSteps = spanBeats / STEP_BEATS;
-  const inside = deformed.filter((lickNote) => lickNote.step < spanSteps - EPS2);
+  const inside = deformed.filter((lickNote) => lickNote.step < spanSteps - BEAT_EPS);
   if (inside.length === 0 || !withinCeiling(inside, bpm, difficulty)) {
     return void 0;
   }
@@ -1140,28 +1408,32 @@ var BASS_STYLES = Object.freeze([
   "walking",
   "arpeggio"
 ]);
-var DEFAULT_TS2 = { numerator: 4, denominator: 4 };
 var DEFAULT_STYLE = "root";
-var DEFAULT_OCTAVE2 = 2;
 var DEFAULT_PICKUP_DENSITY = 0.35;
+function sounding(ctx, placed) {
+  return ctx.instrument ? foldIntoRange(placed, ctx.instrument) : placed;
+}
+function placeTone(ctx, pc) {
+  return ctx.overBass ? placeAboveBass(pc, ctx.rootMidi) : placePc(pc, ctx.rootMidi, ctx.low);
+}
 function emit(ctx, pos, pc, midiOverride) {
-  const placed = clampToMidi(
-    midiOverride ?? placePc(pc, ctx.prevMidi, ctx.low),
-    "generated bass pitch"
-  );
-  const midi = ctx.instrument ? foldIntoRange(placed, ctx.instrument) : placed;
+  const placed = clampToMidi(midiOverride ?? placeTone(ctx, pc), "generated bass pitch");
+  const midi = sounding(ctx, placed);
   const velocity = isStrongBeat(pos, ctx.ts) ? STRONG_VELOCITY : WEAK_VELOCITY;
   ctx.notes.push({ startBeat: pos, pitch: midi, velocity });
+  ctx.prevMidi = midi;
   return midi;
 }
 function buildRoot(ctx, seg) {
-  ctx.prevMidi = emit(ctx, seg.startBeat, bassPcOf(seg.chord));
+  emit(ctx, seg.startBeat, bassPcOf(seg.chord));
 }
 function buildRootFifth(ctx, seg) {
-  ctx.prevMidi = emit(ctx, seg.startBeat, bassPcOf(seg.chord));
-  const mid = (seg.startBeat + seg.endBeat) / 2;
-  if (mid > seg.startBeat + EPS && mid < seg.endBeat - EPS) {
-    ctx.prevMidi = emit(ctx, mid, fifthPcOf(seg.chord));
+  for (const tile of barTiles(seg.startBeat, seg.endBeat, ctx.ts)) {
+    emit(ctx, tile.startBeat, bassPcOf(seg.chord));
+    const answer = midBarPulse(tile.startBeat, ctx.ts);
+    if (answer > tile.startBeat + BEAT_EPS && answer < tile.endBeat - BEAT_EPS) {
+      emit(ctx, answer, fifthPcOf2(seg.chord));
+    }
   }
 }
 function buildPop(ctx, seg, index) {
@@ -1170,21 +1442,37 @@ function buildPop(ctx, seg, index) {
   let emitted = false;
   for (const pos of positions) {
     if (isStrongBeat(pos, ctx.ts)) {
-      ctx.prevMidi = emit(ctx, pos, rootPc);
+      emit(ctx, pos, rootPc);
       emitted = true;
     } else if (ctx.draw.prob(ctx.pickupDensity, "pickup", index, pos)) {
-      if (ctx.draw.prob(0.5, "pickupKind", index, pos) && reachableLeap(ctx, pos, 12)) {
-        const base = placePc(rootPc, ctx.prevMidi, ctx.low);
-        const dropped = base - 12;
-        emit(ctx, pos, rootPc, dropped >= 0 ? dropped : base);
-      } else {
-        ctx.prevMidi = emit(ctx, pos, fifthPcOf(seg.chord));
-      }
+      emitted = pickup(ctx, seg, pos, index) || emitted;
     }
   }
   if (!emitted) {
-    ctx.prevMidi = emit(ctx, seg.startBeat, rootPc);
+    emit(ctx, seg.startBeat, rootPc);
+  }
+}
+function pickup(ctx, seg, pos, index) {
+  const octave = octavePickup(ctx);
+  if (ctx.draw.prob(0.5, "pickupKind", index, pos) && octave !== void 0 && reachableLeap(ctx, pos, Math.abs(sounding(ctx, octave) - ctx.prevMidi))) {
+    emit(ctx, pos, bassPcOf(seg.chord), octave);
+    return true;
+  }
+  const fifthPc = fifthPcOf2(seg.chord);
+  if (sounding(ctx, placeTone(ctx, fifthPc)) === sounding(ctx, ctx.rootMidi)) {
+    return false;
+  }
+  emit(ctx, pos, fifthPc);
+  return true;
+}
+function octavePickup(ctx) {
+  const root = sounding(ctx, ctx.rootMidi);
+  for (const candidate of [ctx.rootMidi - 12, ctx.rootMidi + 12]) {
+    if (candidate >= 0 && candidate <= 127 && sounding(ctx, candidate) !== root) {
+      return candidate;
+    }
   }
+  return void 0;
 }
 function reachableLeap(ctx, pos, semitones) {
   const previous = ctx.notes[ctx.notes.length - 1];
@@ -1192,63 +1480,47 @@ function reachableLeap(ctx, pos, semitones) {
   return sustainsShift(semitones, available, ctx.bpm, ctx.difficulty);
 }
 function buildArpeggio(ctx, seg) {
-  const tones = chordTonePcs(seg.chord);
+  const tones = bassToneCycle(seg.chord);
   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);
+    emit(ctx, pos, pc);
   });
 }
 function approachNote2(ctx, target, from, index) {
-  return approachNote(target, from, ctx.low, ctx.key, ctx.draw.prob(0.5, "approach", index));
+  return approachNote(target, from, ctx.key, ctx.draw.prob(0.5, "approach", index));
 }
 function buildWalking(ctx, seg, next, index) {
-  const tones = chordTonePcs(seg.chord);
+  const tones = bassToneCycle(seg.chord);
   const positions = beatPositions(seg.startBeat, seg.endBeat, ctx.ts);
   const count = positions.length;
   positions.forEach((pos, i) => {
     if (i === 0) {
-      ctx.prevMidi = emit(ctx, pos, bassPcOf(seg.chord));
+      emit(ctx, pos, bassPcOf(seg.chord));
       return;
     }
     if (next && count > 1 && i === count - 1) {
-      const nextBass = placePc(bassPcOf(next.chord), ctx.prevMidi, ctx.low);
+      const nextBass = placeRoot(bassPcOf(next.chord), ctx.low);
       const midi = approachNote2(ctx, nextBass, ctx.prevMidi, index);
-      ctx.prevMidi = emit(ctx, pos, pitchClassOf(midi), midi);
+      emit(ctx, pos, pitchClassOf(midi), midi);
       return;
     }
     const pc = tones[i % tones.length] ?? bassPcOf(seg.chord);
-    ctx.prevMidi = emit(ctx, pos, pc);
+    emit(ctx, pos, pc);
   });
 }
 function generateBassLine(opts) {
+  assertRecord(opts, "bass line options");
+  assertArray(opts.segments, "bass segments");
   assertGenerationBudget(opts.segments.length, "bass segments", opts.budget);
-  for (let index = 0; index < opts.segments.length; index += 1) {
-    const segment = opts.segments[index];
-    if (!segment) continue;
-    assertRange(segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
-    assertRange(segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
-    if (segment.endBeat <= segment.startBeat) {
-      throw new InvalidInputError(`segments[${index}] must have a positive duration`);
-    }
-  }
   const segments = opts.segments.map((segment) => ({ ...segment, chord: toChordData(segment.chord) })).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`
-      );
-    }
-  }
+  assertBassSegments(segments);
   if (segments.length === 0) {
     return [];
   }
-  const ts = opts.ts ?? DEFAULT_TS2;
-  assertTimeSignature(ts);
+  const ts = meterAt(0, toMeterData(opts.ts ?? DEFAULT_TS, "ts"));
   const style = assertOneOf(opts.style ?? DEFAULT_STYLE, BASS_STYLES, "bass style");
-  const octave = opts.octave ?? DEFAULT_OCTAVE2;
+  const octave = opts.octave ?? DEFAULT_OCTAVE;
   assertInteger(octave, "bass octave", -1, 8);
   const estimatedNotes = segments.reduce(
     (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
@@ -1256,15 +1528,15 @@ function generateBassLine(opts) {
   );
   assertGenerationBudget(estimatedNotes, "bass notes", opts.budget);
   const resolved = resolveContext(opts.ctx);
-  const named = resolved.instrument("bass");
-  const instrument = opts.instrument ?? (named !== void 0 && named.kind === "stringed" ? named : void 0);
-  const low = bandFloor(octave * 12 + 12, instrument);
+  const { instrument, low } = bassRegister(resolved.instrument("bass"), opts.instrument, octave);
   const ctx = {
     ts,
     low,
     key: toKeyScale(opts.key),
     draw: resolved.part("bass"),
     notes: [],
+    rootMidi: low,
+    overBass: false,
     prevMidi: low,
     instrument,
     pickupDensity: resolved.rhythmic ?? DEFAULT_PICKUP_DENSITY,
@@ -1276,6 +1548,8 @@ function generateBassLine(opts) {
     if (!seg) {
       continue;
     }
+    ctx.rootMidi = placeRoot(bassPcOf(seg.chord), ctx.low);
+    ctx.overBass = seg.chord.bassPc !== void 0;
     switch (style) {
       case "rootFifth":
         buildRootFifth(ctx, seg);
@@ -1304,7 +1578,7 @@ function generateBassLine(opts) {
     }
     const nextStart = ctx.notes[i + 1]?.startBeat ?? lastEnd;
     const durationBeat = nextStart - note2.startBeat;
-    if (durationBeat <= EPS) {
+    if (durationBeat <= BEAT_EPS) {
       continue;
     }
     out.push({
@@ -1331,6 +1605,7 @@ function assertPlayable(pitch) {
 }
 function imitate(lead, opts) {
   assertNoteEvents(lead, "imitate lead", { allowNonPositiveDuration: true });
+  assertRecord(opts, "opts");
   assertFiniteNumber(opts.atBeat, "atBeat");
   const interval = toSpelledInterval(opts.interval);
   const key = toKeyScale(opts.key);
@@ -1371,9 +1646,9 @@ function imitate(lead, opts) {
     }
     pitch = tonal ? shiftByScaleDegrees(pitch, degrees, key) + offset : pitch + Math.round(interval.semitones);
     const answer = {
+      ...note2,
       pitch: assertPlayable(pitch),
-      startBeat: note2.startBeat + shift,
-      durationBeat: note2.durationBeat
+      startBeat: note2.startBeat + shift
     };
     if (note2.velocity !== void 0) {
       answer.velocity = Math.max(1, Math.min(127, Math.round(note2.velocity * velocityScale)));
@@ -1383,8 +1658,6 @@ function imitate(lead, opts) {
 }
 
 // src/generate/countermelody/index.ts
-var DEFAULT_TS3 = { numerator: 4, denominator: 4 };
-var EPS3 = 1e-9;
 var GRID_STEP = 0.5;
 var MIN_ONSET_GAP = 1;
 var REGISTER_OFFSET = 12;
@@ -1396,7 +1669,7 @@ 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)) < EPS3;
+  return Math.abs(beat - Math.round(beat)) < BEAT_EPS;
 }
 function melodyNoteAt(melody, beat) {
   return melody.at(beat)?.note;
@@ -1409,8 +1682,8 @@ function melodySnapshotAt(melody, beat) {
   if (current === void 0) {
     return void 0;
   }
-  const attacked = Math.abs(current.startBeat - beat) < EPS3;
-  const previous = attacked ? melodyNoteAt(melody, beat - EPS3 * 2) : current;
+  const attacked = Math.abs(current.startBeat - beat) < BEAT_EPS;
+  const previous = attacked ? melodyNoteAt(melody, beat - BEAT_EPS * 2) : current;
   const snapshot = { pitch: current.pitch };
   if (previous !== void 0) {
     snapshot.prevPitch = previous.pitch;
@@ -1420,22 +1693,24 @@ function melodySnapshotAt(melody, beat) {
 function followOnsets(melody) {
   return [...new Set(melody.notes.map(({ note: note2 }) => note2.startBeat))];
 }
+var DEFAULT_TS2 = { numerator: 4, denominator: 4 };
+var SCORE_EPS = 1e-9;
 function complementOnsets(melody, ts, spanStart, spanEnd, draw) {
   const onsets = [];
   const gridStart = Math.floor(spanStart / GRID_STEP) * GRID_STEP;
   let last = Number.NEGATIVE_INFINITY;
-  for (let beat = gridStart; beat < spanEnd - EPS3; beat += GRID_STEP) {
+  for (let beat = gridStart; beat < spanEnd - BEAT_EPS; beat += GRID_STEP) {
     const attacked = melodyAttacksAt(melody, beat);
-    const sounding = melodyNoteAt(melody, beat) !== void 0;
+    const sounding2 = melodyNoteAt(melody, beat) !== void 0;
     let place = false;
-    if (!attacked && !sounding) {
+    if (!attacked && !sounding2) {
       place = isWholeBeat(beat);
     } else if (!attacked) {
       place = draw.prob(isWholeBeat(beat) ? HOLD_ON_BEAT_PROB : HOLD_OFF_BEAT_PROB, "hold", beat);
     } else if (isStrongBeat(beat, ts)) {
       place = draw.prob(REINFORCE_PROB, "reinforce", beat);
     }
-    if (place && beat - last >= MIN_ONSET_GAP - EPS3) {
+    if (place && beat - last >= MIN_ONSET_GAP - BEAT_EPS) {
       onsets.push(beat);
       last = beat;
     }
@@ -1451,6 +1726,19 @@ function keepsImperfectInterval(before, now) {
   }
   return before <= 4 === now <= 4;
 }
+function assertWeightOverrides(overrides) {
+  if (overrides === void 0) {
+    return;
+  }
+  if (typeof overrides !== "object" || overrides === null) {
+    throw new InvalidInputError(
+      `countermelody weights must be an object of weight overrides; received ${describeRejected(overrides)}`
+    );
+  }
+  for (const [field, value] of Object.entries(overrides)) {
+    assertFiniteNumber(value, `countermelody weights.${field}`);
+  }
+}
 function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weights) {
   let score = 0;
   const ic = melPitch === void 0 ? void 0 : Math.abs(pitch - melPitch) % 12;
@@ -1498,12 +1786,12 @@ function heldNoteBoundaries(melody, startBeat, endBeat, chordChangeBeats) {
     boundaries.add(onset);
   }
   for (const beat of chordChangeBeats) {
-    if (beat > startBeat + EPS3 && beat < endBeat - EPS3) {
+    if (beat > startBeat + BEAT_EPS && beat < endBeat - BEAT_EPS) {
       boundaries.add(beat);
     }
   }
   const firstGrid = Math.floor(startBeat / GRID_STEP + 1) * GRID_STEP;
-  for (let beat = firstGrid; beat < endBeat - EPS3; beat += GRID_STEP) {
+  for (let beat = firstGrid; beat < endBeat - BEAT_EPS; beat += GRID_STEP) {
     boundaries.add(beat);
   }
   return [...boundaries].sort((a, b) => a - b);
@@ -1517,7 +1805,7 @@ function boundaryContexts(melody, harmony, startBeat, endBeat, ts) {
       otherVoices: melodyVoice === void 0 ? [] : [melodyVoice],
       chord: harmony.chordAt(boundary),
       strongBeat: isStrongBeat(boundary, ts),
-      atCounterOnset: Math.abs(boundary - startBeat) < EPS3
+      atCounterOnset: Math.abs(boundary - startBeat) < BEAT_EPS
     };
   });
 }
@@ -1550,6 +1838,7 @@ function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low
   return worst;
 }
 function generateCounterMelody(opts) {
+  assertRecord(opts, "countermelody options");
   const timeline = opts.timeline;
   const chordAt = timeline === void 0 ? opts.chordAt : (beat) => timeline.at(beat);
   if (chordAt === void 0) {
@@ -1561,10 +1850,11 @@ function generateCounterMelody(opts) {
   const melody = createNoteEventIndex(soundingNotesOnly(opts.melody), {
     tieBreak: register === "below" ? "highest" : "lowest"
   });
-  const ts = opts.ts ?? DEFAULT_TS3;
+  const ts = meterAt(0, toMeterData(opts.ts ?? DEFAULT_TS2, "ts"));
   assertTimeSignature(ts);
   const rhythm = assertOneOf(opts.rhythm ?? "complement", ["complement", "follow"], "rhythm");
   const profile = assertOneOf(opts.profile ?? "pop", ["strict", "pop"], "safety profile");
+  assertWeightOverrides(opts.weights);
   const weights = profileWeights(profile, opts.weights);
   const key = toKeyScale(opts.key);
   const draw = resolveContext(opts.ctx).part("countermelody");
@@ -1662,8 +1952,8 @@ function generateCounterMelody(opts) {
         }
       }
       const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center, weights) + (jitter[candidate - low] ?? 0);
-      const tie = Math.abs(score - bestScore) <= EPS3 && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
-      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS3 || tie)) {
+      const tie = Math.abs(score - bestScore) <= SCORE_EPS && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
+      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + SCORE_EPS || tie)) {
         bestWorstSafety = worstSafety;
         bestScore = score;
         bestPitch = candidate;
@@ -1742,8 +2032,8 @@ function getGhostVelocity(section, beatPosition) {
   }
   return Math.max(0.25, Math.min(0.65, base));
 }
-function getGhostProbabilityAtPosition(beat, sixteenthInBeat) {
-  const leadsIntoBackbeat = (beat === 0 || beat === 2) && sixteenthInBeat === 3;
+function getGhostProbabilityAtPosition(beat, sixteenthInBeat, leadIns) {
+  const leadsIntoBackbeat = leadIns.includes(beat) && sixteenthInBeat === 3;
   return leadsIntoBackbeat ? 0.6 : 0.25;
 }
 function selectGhostPositions(mood) {
@@ -1973,6 +2263,12 @@ function shouldAddOpenHHAccent(section, beat, bar2, draw) {
 function footHiHatVelocity(draw, bar2, beat) {
   return draw.range(FHH_VEL_MIN, FHH_VEL_MAX, "fhhVelocity", bar2, beat);
 }
+function usesOffbeatOpenHiHat(style) {
+  return style === "fourOnFloor";
+}
+function offbeatOpenHiHatChance(bpm) {
+  return Math.max(0.15, Math.min(0.8, 45 / bpm));
+}
 function shouldUseRideForSection(section, style) {
   if (style === "rock" && section === "chorus") {
     return true;
@@ -1982,9 +2278,6 @@ function shouldUseRideForSection(section, style) {
   }
   return section === "bridge";
 }
-function shouldUseBridgeCrossStick(section, beat) {
-  return section === "bridge" && (beat === 1 || beat === 3);
-}
 
 // src/generate/drums/swing.ts
 var SIXTEENTH2 = 0.25;
@@ -2072,36 +2365,50 @@ function generateKickForBeat(ctx, sec, kick) {
     ctx.track.add(GM.BD, tick, offBeat ? SIXTEENTH : EIGHTH, ctx.velocity * 0.85);
   }
 }
-function generateSnareForBeat(ctx, sec, isIntroFirst) {
-  if (ctx.inPrechorusLift) {
-    return;
+function roleBackbeatWeight(role) {
+  if (role === "minimal") {
+    return 0.65;
   }
-  const snareOn = sec.snareBeat3 ? ctx.beat === 2 : ctx.beat === 1 || ctx.beat === 3;
-  if (!snareOn || isIntroFirst) {
-    return;
+  return role === "ambient" ? 0.8 : 1;
+}
+function backbeatVoice(sec) {
+  if (sec.role === "fxOnly") {
+    return void 0;
   }
-  if (sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat)) {
-    return;
+  const sideStick = sec.style === "latin" || sec.role === "ambient" || sec.role === "minimal";
+  return sideStick ? GM.SIDESTICK : GM.SD;
+}
+function writesSnareGhosts(sec) {
+  return backbeatVoice(sec) === GM.SD && sec.style !== "sparse";
+}
+function backbeatStroke(sec, velocity) {
+  const pitch = backbeatVoice(sec);
+  if (pitch === void 0) {
+    return void 0;
   }
-  const backbeatVel = Math.min(127, ctx.velocity + BACKBEAT_LIFT);
-  const promoteSparseChorus = sec.style === "sparse" && ctx.section === "chorus" && sec.role === "full";
-  if (sec.role === "fxOnly") {
+  return pitch === GM.SD ? { pitch, velocity: Math.min(127, velocity + BACKBEAT_LIFT) } : { pitch, velocity: velocity * roleBackbeatWeight(sec.role) };
+}
+var FOUR_FOUR_BEATS = 4;
+function generateSnareForBeat(ctx, sec, isIntroFirst) {
+  if (ctx.inPrechorusLift) {
     return;
   }
-  if (sec.role === "minimal") {
-    ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.65);
+  if (!backbeatBeats(sec.snareBeat3).includes(ctx.beat) || isIntroFirst) {
     return;
   }
-  if (promoteSparseChorus) {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  } else if (sec.style === "sparse" || sec.role === "ambient") {
-    ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.8);
-  } else {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
+  const stroke = backbeatStroke(sec, ctx.velocity);
+  if (!stroke) {
+    return;
   }
+  ctx.track.add(stroke.pitch, ctx.beatTick, EIGHTH, stroke.velocity);
 }
 function generateGhostNotesForBeat(ctx, sec) {
-  if (ctx.beat !== 0 && ctx.beat !== 2) {
+  if (!writesSnareGhosts(sec)) {
+    return;
+  }
+  const backbeats = backbeatBeats(sec.snareBeat3);
+  const leadIns = backbeats.map((beat) => (beat - 1 + FOUR_FOUR_BEATS) % FOUR_FOUR_BEATS);
+  if (!leadIns.includes(ctx.beat)) {
     return;
   }
   if (!sustainsStrokes(SIXTEENTH, ctx.bpm, sec.difficulty)) {
@@ -2114,7 +2421,7 @@ function generateGhostNotesForBeat(ctx, sec) {
   }
   for (const pos of positions) {
     const sixteenthInBeat = pos === "e" ? 1 : 3;
-    const posProb = getGhostProbabilityAtPosition(ctx.beat, sixteenthInBeat);
+    const posProb = getGhostProbabilityAtPosition(ctx.beat, sixteenthInBeat, leadIns);
     if (!ctx.draw.prob(ghostProb * posProb, "ghost", ctx.bar, ctx.beat, pos)) {
       continue;
     }
@@ -2154,40 +2461,47 @@ function generatePreChorusBuildup(ctx, sec, isSectionLastBar) {
     );
   }
   if (isSectionLastBar && ctx.beat === 3) {
-    ctx.track.add(GM.CRASH, ctx.beatTick + EIGHTH + SIXTEENTH, SIXTEENTH, ctx.velocity * 1.1);
+    ctx.track.add(
+      GM.CRASH,
+      swing16(ctx.beatTick + EIGHTH + SIXTEENTH, sec, ctx.swingAmount),
+      SIXTEENTH,
+      ctx.velocity * 1.1
+    );
   }
 }
+function opensOnDownbeat(ctx, sec) {
+  if (usesOffbeatOpenHiHat(sec.style)) {
+    return false;
+  }
+  return shouldAddOpenHHAccent(ctx.section, ctx.beat, ctx.bar, ctx.draw);
+}
+function opensOffbeat(ctx, sec) {
+  if (!usesOffbeatOpenHiHat(sec.style) || ctx.beat !== 1 && ctx.beat !== 3) {
+    return false;
+  }
+  return ctx.draw.prob(offbeatOpenHiHatChance(ctx.bpm), "openHat", ctx.bar, ctx.beat, 1);
+}
 function generateHiHatForBeat(ctx, sec) {
   if (!shouldPlayHiHat(sec.role)) {
     return;
   }
-  const crossStick = sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat);
-  const hhInstrument = crossStick ? GM.SIDESTICK : roleHiHatInstrument(sec.role, sec.useRide);
+  const hhInstrument = roleHiHatInstrument(sec.role, sec.useRide);
   const hhType = sectionHiHatType(ctx.section, sec.role);
   const typeMult = hiHatTypeVelocityMultiplier(hhType);
-  const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat;
   const allowsOpenHiHat = sec.role !== "ambient" && sec.role !== "minimal";
+  const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat && !usesOffbeatOpenHiHat(sec.style);
   const dm = sec.densityMult;
   if (ctx.hhLevel === "quarter") {
-    const introRest = ctx.section === "intro" && ctx.beat !== 0;
-    if (!introRest) {
-      if (isDynamicOpen && allowsOpenHiHat) {
-        ctx.track.add(
-          GM.OHH,
-          ctx.beatTick,
-          EIGHTH,
-          ctx.velocity * dm * 0.75 * typeMult + OHH_VEL_BOOST
-        );
-      } else {
-        ctx.track.add(
-          hhInstrument,
-          ctx.beatTick,
-          EIGHTH,
-          Math.max(20, ctx.velocity * dm * 0.75 * typeMult)
-        );
-      }
-    } else if (sec.useFootHh) {
-      ctx.track.add(GM.FHH, ctx.beatTick, EIGHTH, footHiHatVelocity(ctx.draw, ctx.bar, ctx.beat));
+    if (ctx.section === "intro" && ctx.beat !== 0) {
+      return;
+    }
+    const hhVel = Math.max(20, ctx.velocity * dm * 0.75 * typeMult);
+    if (allowsOpenHiHat && isDynamicOpen) {
+      ctx.track.add(GM.OHH, ctx.beatTick, EIGHTH, hhVel + OHH_VEL_BOOST);
+    } else if (allowsOpenHiHat && opensOnDownbeat(ctx, sec)) {
+      ctx.track.add(hiHatNote("open"), ctx.beatTick, EIGHTH, Math.max(20, hhVel * 1.1));
+    } else {
+      ctx.track.add(hhInstrument, ctx.beatTick, EIGHTH, hhVel);
     }
     return;
   }
@@ -2208,13 +2522,7 @@ function generateHiHatForBeat(ctx, sec) {
         ctx.track.add(GM.OHH, hhTick, EIGHTH, hhVel + OHH_VEL_BOOST);
         continue;
       }
-      let useOpen = false;
-      if (sec.style === "fourOnFloor" && eighth === 1) {
-        const openProb = Math.max(0.15, Math.min(0.8, 45 / ctx.bpm));
-        useOpen = (ctx.beat === 1 || ctx.beat === 3) && ctx.draw.prob(openProb, "openHat", ctx.bar, ctx.beat, eighth);
-      } else if (eighth === 0) {
-        useOpen = shouldAddOpenHHAccent(ctx.section, ctx.beat, ctx.bar, ctx.draw);
-      }
+      const useOpen = eighth === 0 ? opensOnDownbeat(ctx, sec) : opensOffbeat(ctx, sec);
       if (useOpen && allowsOpenHiHat) {
         ctx.track.add(hiHatNote("open"), hhTick, EIGHTH, Math.max(20, hhVel * 1.1));
       } else {
@@ -2237,6 +2545,14 @@ function generateHiHatForBeat(ctx, sec) {
       ctx.track.add(GM.OHH, hhTick, SIXTEENTH, hhVel + OHH_VEL_BOOST);
       continue;
     }
+    if (allowsOpenHiHat && sixteenth === 0 && opensOnDownbeat(ctx, sec)) {
+      ctx.track.add(hiHatNote("open"), hhTick, SIXTEENTH, Math.max(20, hhVel * 1.1));
+      continue;
+    }
+    if (allowsOpenHiHat && sixteenth === 2 && opensOffbeat(ctx, sec)) {
+      ctx.track.add(hiHatNote("open"), hhTick, SIXTEENTH, Math.max(20, hhVel * 1.1));
+      continue;
+    }
     if (allowsOpenHiHat && ctx.beat === 3 && sixteenth === 3) {
       const openProb = Math.max(0.1, Math.min(0.4, 30 / ctx.bpm));
       if (ctx.draw.prob(openProb, "openHat", ctx.bar, ctx.beat, sixteenth)) {
@@ -2329,7 +2645,7 @@ function archetype(beat2, beat3, boundToBar) {
     ...boundToBar ? { boundToBar } : {}
   };
 }
-var FILL_ARCHETYPES = Object.freeze({
+var FILL_ARCHETYPES = deepFreeze({
   // One crescendo of seven strokes across the two beats, not two of four and
   // three: the roll is a single gesture and its second half continues where its
   // first half left off.
@@ -2432,8 +2748,9 @@ function getFillStartBeat(energy) {
     case "medium":
       return 2;
     case "high":
+      return 1;
     case "peak":
-      return 2;
+      return 0;
   }
 }
 var SPARSE_FILLS = ["simpleCrash", "breakdownFill"];
@@ -2543,7 +2860,7 @@ function fillWithinCeiling(shape, fromBeat, barBeats, bpm, difficulty) {
   }
   return true;
 }
-function generateFill(track, beatTick, beat, fillType, velocity) {
+function generateFill(track, beatTick, beat, fillType, velocity, place = (tick) => tick) {
   const shape = typeof fillType === "string" ? FILL_ARCHETYPES[fillType] : fillType;
   if (!shape) {
     return;
@@ -2556,7 +2873,7 @@ function generateFill(track, beatTick, beat, fillType, velocity) {
     const scaled = stroke.velocity.scale === void 0 ? base : base * stroke.velocity.scale;
     track.add(
       stroke.voice,
-      beatTick + stroke.offset,
+      place(beatTick + stroke.offset),
       stroke.duration,
       scaled + (stroke.velocity.offset ?? 0),
       stroke.articulation
@@ -2584,17 +2901,30 @@ var DRUM_NOTES = Object.freeze({
 var VOICE_BY_NOTE = new Map(
   Object.entries(DRUM_NOTES).map(([voice, note2]) => [note2, voice])
 );
+function drumNoteOf(voice) {
+  return Object.hasOwn(DRUM_NOTES, voice) ? DRUM_NOTES[voice] : void 0;
+}
 function drumVoiceOf(pitch) {
-  return VOICE_BY_NOTE.get(pitch);
+  return VOICE_BY_NOTE.get(assertMidiPitch(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. */
+  /** Voices already struck at each quantized beat. */
+  #onsets = /* @__PURE__ */ new Map();
+  /**
+   * Append a hit, clamping velocity and dropping non-positive positions.
+   *
+   * A voice already struck at this instant is left as it stands: one drum
+   * sounds once however many voices ask for it, and a second entry at the same
+   * pitch and position is a note-on a reader answers with no note-off, heard as
+   * a hung or cut stroke rather than as a louder one.
+   */
   add(pitch, startBeat, durationBeat, velocity, articulation) {
     const beat = Math.max(0, startBeat);
+    if (this.hasOnset(pitch, beat)) {
+      return;
+    }
     const hit2 = {
       pitch,
       startBeat: beat,
@@ -2605,23 +2935,34 @@ var HitList = class {
       hit2.articulation = articulation;
     }
     this.hits.push(hit2);
-    this.#onsets.add(onsetKey(pitch, beat));
+    const struck = this.#onsets.get(beatSlot(beat));
+    if (struck) {
+      struck.add(pitch);
+    } else {
+      this.#onsets.set(beatSlot(beat), /* @__PURE__ */ new Set([pitch]));
+    }
   }
   /** Whether a hit of this pitch already starts exactly at `startBeat`. */
   hasOnset(pitch, startBeat) {
-    return this.#onsets.has(onsetKey(pitch, startBeat));
+    return this.#onsets.get(beatSlot(startBeat))?.has(pitch) ?? false;
   }
-  /** True when a crash already sits within a 16th of `startBeat`. */
+  /**
+   * True when a crash already sits less than a 16th from `startBeat`, on either
+   * side of it.
+   */
   hasCrashNear(startBeat) {
     const steps = Math.round(0.25 * ONSET_KEY_SCALE);
-    for (let step = 0; step < steps; step += 1) {
-      if (this.#onsets.has(onsetKey(GM.CRASH, startBeat + step / ONSET_KEY_SCALE))) {
+    for (let step = -steps + 1; step < steps; step += 1) {
+      if (this.hasOnset(GM.CRASH, startBeat + step / ONSET_KEY_SCALE)) {
         return true;
       }
     }
     return false;
   }
 };
+function beatSlot(startBeat) {
+  return Math.round(startBeat * ONSET_KEY_SCALE);
+}
 function onsetKey(pitch, startBeat) {
   return `${pitch}:${Math.round(startBeat * ONSET_KEY_SCALE)}`;
 }
@@ -2637,7 +2978,13 @@ var BEAT_3 = beatStep(2);
 var BEAT_4 = beatStep(3);
 var AND_2 = beatStep(1) + 2;
 var AND_4 = beatStep(3) + 2;
+var A_OF_3 = beatStep(2) + 3;
 var OUTRO_FIGURE = [{ step: BEAT_1 }, { step: BEAT_3 }];
+function statedSlots(figure) {
+  return figure.filter(
+    (slot) => slot.probability === void 0 && slot.sections === void 0 && slot.barParity === void 0
+  );
+}
 var DEFAULT_FIGURE = [
   { step: BEAT_1 },
   { step: BEAT_3 },
@@ -2645,7 +2992,7 @@ var DEFAULT_FIGURE = [
   { step: AND_2, probability: 0.55, slot: "beat2and", sections: ["chorus"] },
   { step: AND_4, probability: 0.35, slot: "beat4and", sections: ["chorus"] }
 ];
-var KICK_FIGURES = Object.freeze({
+var KICK_FIGURES = deepFreeze({
   sparse: [{ step: BEAT_1 }, { step: BEAT_3, sections: ["chorus"], barParity: 1 }],
   fourOnFloor: [
     { step: BEAT_1 },
@@ -2663,9 +3010,13 @@ var KICK_FIGURES = Object.freeze({
   rock: [
     { step: BEAT_1 },
     { step: BEAT_3 },
-    { step: AND_2, probability: 0.65, slot: "beat2and", sections: ["chorus"] },
-    { step: AND_4, probability: 0.4, slot: "beat4and", sections: ["chorus"] },
-    { step: AND_2, probability: 0.3, slot: "beat2and", sections: ["prechorus"] }
+    // The broken beat: the "and" of two answers the snare and the "a" of three
+    // pushes into the fourth, in every section. That displacement is the figure
+    // rather than a slot a dial may or may not fill in a chorus, which is what
+    // separates it from the plain pop pulse wherever it is played.
+    { step: AND_2 },
+    { step: A_OF_3 },
+    { step: AND_4, probability: 0.4, slot: "beat4and", sections: ["chorus"] }
   ],
   synth: [
     { step: BEAT_1 },
@@ -2719,7 +3070,8 @@ function realiseKickFigure(figure, section, bar2, draw, rhythmic) {
   return pattern;
 }
 function getKickPattern(section, style, bar2, draw, rhythmic) {
-  const figure = section === "outro" ? OUTRO_FIGURE : KICK_FIGURES[style] ?? DEFAULT_FIGURE;
+  const own = KICK_FIGURES[style] ?? DEFAULT_FIGURE;
+  const figure = section === "outro" ? [...OUTRO_FIGURE, ...statedSlots(own)] : own;
   return realiseKickFigure(figure, section, bar2, draw, rhythmic);
 }
 
@@ -2771,8 +3123,9 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
   if (role === "minimal") {
     return;
   }
+  const backbeats = backbeatBeats(sec.snareBeat3, barBeats);
   if (config.tambourine) {
-    for (let beat = 1; beat < barBeats; beat += 2) {
+    for (const beat of backbeats) {
       const raw = 70 * densityMult * draw.float(0.9, 1.1, "tambourine", barStart, beat);
       track.add(GM.TAMBOURINE, barStart + beat, EIGHTH, Math.max(40, Math.min(90, raw)));
     }
@@ -2811,7 +3164,7 @@ function generateAuxPercussionForBar(track, barStart, config, role, densityMult,
     }
   }
   if (config.handclap) {
-    for (let beat = 1; beat < barBeats; beat += 2) {
+    for (const beat of backbeats) {
       const raw = 85 * densityMult * draw.float(0.9, 1.1, "handclap", barStart, beat);
       track.add(GM.HANDCLAP, barStart + beat, EIGHTH, Math.max(50, Math.min(100, raw)));
     }
@@ -2837,6 +3190,11 @@ var REACH_BY_VOICE = {
   lowTom: ["rightHand", "leftHand"],
   shaker: ["rightHand", "leftHand"]
 };
+var OVERDUB_VOICES = Object.freeze([
+  "handClap",
+  "tambourine",
+  "shaker"
+]);
 function reachByNote() {
   const reach = {};
   for (const [voice, limbs] of Object.entries(REACH_BY_VOICE)) {
@@ -2859,9 +3217,11 @@ var DRUM_KIT = Object.freeze({
   kind: "percussion",
   name: "drum kit",
   limbs: LIMBS,
-  reach: Object.freeze(reachByNote()),
+  reach: deepFreeze(reachByNote()),
+  overdub: deepFreeze(OVERDUB_VOICES.map((voice) => DRUM_NOTES[voice])),
   articulations: KIT_ARTICULATIONS,
-  polyphony: 4
+  // One stroke per limb, and one more per voice dubbed over them.
+  polyphony: LIMBS.length + OVERDUB_VOICES.length
 });
 
 // src/generate/drums/vocabulary.ts
@@ -2869,6 +3229,15 @@ function isDrumPattern(material) {
   const candidate = material;
   return typeof candidate === "object" && candidate !== null && typeof candidate.steps === "number" && Array.isArray(candidate.strokes);
 }
+function assertDrumPattern(material, label) {
+  material.strokes.forEach((stroke, index) => {
+    if (typeof stroke !== "object" || stroke === null || typeof stroke.voice !== "string" || drumNoteOf(stroke.voice) === void 0) {
+      throw new InvalidInputError(
+        `${label} strokes[${index}].voice must name a drum voice; received ${describeRejected(stroke?.voice)}`
+      );
+    }
+  });
+}
 function hit(voice, step, velocity, extra) {
   return { voice, step, velocity, ...extra };
 }
@@ -2886,7 +3255,7 @@ function bar(strokes) {
   return { steps: BAR_STEPS, strokes };
 }
 var FOUR_FOUR2 = { numerator: 4, denominator: 4 };
-var DRUM_PATTERNS = Object.freeze([
+var DRUM_PATTERNS = deepFreeze([
   {
     id: "motownBackbeat",
     genre: "motown",
@@ -3056,12 +3425,12 @@ var DEFAULT_VELOCITY = 100;
 var DEFAULT_BPM2 = 120;
 var MAX_STROKES_PER_BAR = 64;
 function placeDrumPattern(opts) {
+  assertRecord(opts, "drum pattern options");
   assertPositiveInt(opts.bars, "drum pattern bars");
   assertGenerationBudget(opts.bars * MAX_STROKES_PER_BAR, "drum pattern hits", opts.budget);
   const genre = assertOneOf(opts.genre, GENRES, "drum pattern genre");
   const section = opts.section === void 0 ? void 0 : assertOneOf(opts.section, PUBLIC_SECTIONS, "drum pattern section");
-  const ts = opts.ts ?? FOUR_FOUR2;
-  assertTimeSignature(ts, "drum pattern time signature");
+  const ts = meterAt(0, toMeterData(opts.ts ?? FOUR_FOUR2, "ts"));
   if (opts.velocity !== void 0) {
     assertRange(opts.velocity, 1, 127, "drum pattern velocity");
   }
@@ -3073,10 +3442,16 @@ function placeDrumPattern(opts) {
   const barBeats = beatsPerBar(ts);
   const kit = resolved.instrument("drums");
   const swing = effectiveSwing(feel, feelSwingAmount(feel));
-  const dictionary = mergeVocabulary(
-    DRUM_PATTERNS,
-    vocabularyOfKind(resolved.vocabulary, isDrumPattern)
-  );
+  const supplied = vocabularyOfKind(resolved.vocabulary, isDrumPattern);
+  supplied.forEach((entry, index) => {
+    assertDrumPattern(entry.material, `drum pattern vocabulary[${index}]`);
+  });
+  const dictionary = mergeVocabulary(DRUM_PATTERNS, supplied);
+  if (selectVocabulary(dictionary, { ts }).length === 0) {
+    throw new InvalidInputError(
+      `drum pattern ts names a meter no figure is written in: ${formatTimeSignature(ts)}. The built-in figures are written in 4/4; supply vocabulary in another meter through the context.`
+    );
+  }
   const track = new HitList();
   for (let bar2 = 0; bar2 < opts.bars; bar2 += 1) {
     const entry = pickVocabulary(
@@ -3106,7 +3481,10 @@ function placeDrumPattern(opts) {
         ...resolved.ornament === void 0 ? {} : { ornament: resolved.ornament },
         isOrnament: (stroke) => stroke.articulation === "ghost",
         rate: opts.rate ?? "straight",
-        spanSteps: entry.material.steps
+        spanSteps: entry.material.steps,
+        // The dials rank the figure's positions against the bar it is written
+        // in, which is the bar this call is placing it in.
+        ts
       },
       draw,
       "pattern",
@@ -3117,13 +3495,18 @@ function placeDrumPattern(opts) {
     }
     const barStart = bar2 * barBeats;
     for (const stroke of strokes) {
-      const pitch = DRUM_NOTES[stroke.voice];
+      const pitch = drumNoteOf(stroke.voice);
       if (pitch === void 0) {
         continue;
       }
       track.add(
         pitch,
-        quantizeSwing(barStart + stroke.step * STEP_BEATS, swing, "sixteenth"),
+        // The bar's own grid is what is swung, and the bar start is added
+        // back after. Swinging the absolute beat takes the offset inside a
+        // quarter note, which is the same thing only while a bar is a whole
+        // number of them: in 7/8 every other bar begins half a beat into one,
+        // so the downbeat was warped and the offbeats came out straight.
+        barStart + quantizeSwing(stroke.step * STEP_BEATS, swing, "sixteenth"),
         stroke.duration ?? STEP_BEATS,
         baseVelocity * stroke.velocity,
         stroke.articulation
@@ -3138,6 +3521,7 @@ function placeDrumPattern(opts) {
 var MAX_HITS_PER_BAR = 128;
 var DEFAULT_BPM3 = 120;
 function generateDrums(opts) {
+  assertRecord(opts, "drum options");
   assertPositiveInt(opts.bars, "drum bars");
   assertGenerationBudget(opts.bars * MAX_HITS_PER_BAR, "drum hits", opts.budget);
   if (opts.euclideanKick) {
@@ -3162,13 +3546,15 @@ 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");
-  if (ts.numerator !== 4 || ts.denominator !== 4) {
-    throw new InvalidInputError(
-      `drum time signature must be 4/4; received ${ts.numerator}/${ts.denominator}`
-    );
+  const meters = resolveMeters({ ts: opts.ts }, "ts");
+  for (const change of meters) {
+    if (change.ts.numerator !== 4 || change.ts.denominator !== 4) {
+      throw new InvalidInputError(
+        `drum time signature must be 4/4 throughout; received ${change.ts.numerator}/${change.ts.denominator} at beat ${change.startBeat}`
+      );
+    }
   }
+  const ts = meterAt(0, meters);
   const barBeats = beatsPerBar(ts);
   const playMainVoices = role !== "fxOnly";
   const section = mapSection(publicSection);
@@ -3182,7 +3568,6 @@ function generateDrums(opts) {
     rhythmic,
     ornament: ornamentDial,
     difficulty,
-    useGhostNotes: (section === "b" || section === "chorus" || section === "bridge") && style !== "sparse",
     ghostBoost: mapping.ghostBoost,
     useRide: shouldUseRideForSection(section, style),
     useFootHh: shouldUseFootHiHat(section, role),
@@ -3253,7 +3638,14 @@ function generateDrums(opts) {
         if (playMainVoices) {
           const before = track.hits.length;
           if (currentFill) {
-            generateFill(track, beatTick, beat, currentFill, fillVelocity);
+            generateFill(
+              track,
+              beatTick,
+              beat,
+              currentFill,
+              fillVelocity,
+              (tick) => swing16(tick, sec, swingAmount)
+            );
           }
           if (track.hits.length > before) {
             continue;
@@ -3297,7 +3689,7 @@ function generateDrums(opts) {
           generateKickForBeat(ctx, sec, kick);
         }
         generateSnareForBeat(ctx, sec, section === "intro" && bar2 === 0);
-        if (sec.useGhostNotes && !inLift) {
+        if (!inLift) {
           generateGhostNotesForBeat(ctx, sec);
         }
       }
@@ -3360,7 +3752,7 @@ function playableOn(kit, pitch) {
 }
 
 // src/generate/groove/index.ts
-var DEFAULT_TS4 = { numerator: 4, denominator: 4 };
+var DEFAULT_TS3 = { numerator: 4, denominator: 4 };
 var DEFAULT_PART = "humanize";
 var DEFAULT_GROOVE_SUBDIVISION = 4;
 var DEFAULT_TIMING = 0.02;
@@ -3371,21 +3763,21 @@ var MAX_METRIC_WEIGHT = 3;
 var MIN_VELOCITY = 1;
 var MAX_VELOCITY = 127;
 function humanize(events, opts = {}) {
-  const ts = opts.ts ?? DEFAULT_TS4;
-  assertTimeSignature(ts);
+  const asked = assertOptions(opts, "opts");
+  const ts = meterAt(0, toMeterData(asked.ts ?? DEFAULT_TS3, "ts"));
   assertNoteEvents(events, "humanize events", { allowNonPositiveDuration: true });
-  const sounding = dropSilentNotes(events);
-  const timing = opts.timing ?? DEFAULT_TIMING;
-  const velocityJitter = opts.velocity ?? DEFAULT_VELOCITY_JITTER;
-  const accent2 = opts.accent ?? DEFAULT_ACCENT;
-  const baseVelocity = opts.baseVelocity ?? DEFAULT_BASE_VELOCITY;
+  const sounding2 = dropSilentNotes(events);
+  const timing = asked.timing ?? DEFAULT_TIMING;
+  const velocityJitter = asked.velocity ?? DEFAULT_VELOCITY_JITTER;
+  const accent2 = asked.accent ?? DEFAULT_ACCENT;
+  const baseVelocity = asked.baseVelocity ?? DEFAULT_BASE_VELOCITY;
   assertRange(timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
   assertRange(velocityJitter, 0, 127, "humanize velocity jitter");
   assertRange(accent2, 0, 127, "humanize accent");
   assertRange(baseVelocity, 0, 127, "humanize base velocity");
-  const ctx = resolveContext(opts.ctx);
-  const draw = ctx.part(opts.part ?? DEFAULT_PART);
-  return sounding.map((event) => {
+  const ctx = resolveContext(asked.ctx);
+  const draw = ctx.part(asked.part ?? DEFAULT_PART);
+  return sounding2.map((event) => {
     const timingOffset = draw.float(-timing, timing, "timing", event.startBeat, event.pitch);
     const startBeat = event.startBeat + timingOffset;
     const weight = metricWeight(event.startBeat, ts);
@@ -3399,12 +3791,7 @@ function humanize(events, opts = {}) {
     );
     const rawVelocity = (event.velocity ?? baseVelocity) + accentBoost + velocityOffset;
     const velocity = Math.min(MAX_VELOCITY, Math.max(MIN_VELOCITY, Math.round(rawVelocity)));
-    return {
-      pitch: event.pitch,
-      startBeat,
-      durationBeat: event.durationBeat,
-      velocity
-    };
+    return { ...event, startBeat, velocity };
   });
 }
 function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
@@ -3422,10 +3809,10 @@ function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
   };
 }
 function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVISION) {
-  assertTimeSignature(ts);
+  const meter = meterAt(0, toMeterData(ts, "ts"));
   assertNoteEvents(events, "groove source events", { allowNonPositiveDuration: true });
   assertPositiveInt(subdivision, "groove subdivision");
-  const barBeats = beatsPerBar(ts);
+  const barBeats = beatsPerBar(meter);
   const slotsPerBar = Math.ceil(barBeats * subdivision);
   assertPositiveInt(slotsPerBar, "groove template slots");
   assertGenerationBudget(slotsPerBar, "groove template slots");
@@ -3460,10 +3847,10 @@ function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVIS
       velocity: velocityCount > 0 ? (velocitySums[i] ?? 0) / velocityCount : null
     });
   }
-  return { subdivision, slotsPerBar, slots, ts };
+  return { subdivision, slotsPerBar, slots, ts: meter };
 }
 function applyGrooveTemplate(events, template, ts) {
-  assertTimeSignature(ts);
+  const meter = meterAt(0, toMeterData(ts, "ts"));
   assertNoteEvents(events, "groove target events", { allowNonPositiveDuration: true });
   assertPositiveInt(template.subdivision, "template subdivision");
   assertPositiveInt(template.slotsPerBar, "template slotsPerBar");
@@ -3471,12 +3858,28 @@ function applyGrooveTemplate(events, template, ts) {
   if (template.slots.length !== template.slotsPerBar) {
     throw new InvalidInputError("template slots length must equal slotsPerBar");
   }
-  if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
+  if (template.ts && (template.ts.numerator !== meter.numerator || template.ts.denominator !== meter.denominator)) {
     throw new InvalidInputError(
-      `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(ts)}`
+      `Groove template meter ${formatTimeSignature(template.ts)} does not match apply-time meter ${formatTimeSignature(meter)}`
     );
   }
-  const barBeats = beatsPerBar(ts);
+  const barBeats = beatsPerBar(meter);
+  const expectedSlots = Math.ceil(barBeats * template.subdivision);
+  if (template.slotsPerBar !== expectedSlots) {
+    throw new InvalidInputError(
+      `Groove template slotsPerBar ${template.slotsPerBar} does not match ${expectedSlots} slots per bar of ${formatTimeSignature(meter)} at subdivision ${template.subdivision}`
+    );
+  }
+  for (let index = 0; index < template.slots.length; index += 1) {
+    const slot = template.slots[index];
+    if (slot === void 0) {
+      continue;
+    }
+    assertFiniteNumber(slot.timingOffset, `template slots[${index}].timingOffset`);
+    if (slot.velocity !== null && slot.velocity !== void 0) {
+      assertRange(slot.velocity, 0, 127, `template slots[${index}].velocity`);
+    }
+  }
   return dropSilentNotes(events).map((event) => {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
@@ -3487,20 +3890,14 @@ function applyGrooveTemplate(events, template, ts) {
     const slot = template.slots[slotIndex];
     const startBeat = quantizedBeat + (slot?.timingOffset ?? 0);
     const velocity = slot && slot.velocity !== null && slot.velocity !== void 0 ? Math.round(slot.velocity) : event.velocity;
-    return {
-      pitch: event.pitch,
-      startBeat,
-      durationBeat: event.durationBeat,
-      velocity
-    };
+    return { ...event, startBeat, velocity };
   });
 }
 
 // src/generate/harmonize/nct.ts
-var ADJACENCY_TOLERANCE = 0.05;
 function snapToPulse(beat, pulse2) {
   const snapped = Math.round(beat / pulse2) * pulse2;
-  return Math.abs(snapped - beat) <= ADJACENCY_TOLERANCE ? snapped : beat;
+  return Math.abs(snapped - beat) <= HUMANIZE_ADJACENCY ? snapped : beat;
 }
 var STEP_SEMITONES = 2;
 function isStep(a, b) {
@@ -3514,11 +3911,11 @@ function sameDirection(prev, note2, next) {
   return prev !== note2 && next !== note2 && note2 - prev > 0 === next - note2 > 0;
 }
 function classifyMelodyTones(melody, ts) {
+  const meter = meterAt(0, toMeterData(ts, "ts"));
   assertNoteEvents(melody, "melody notes", { allowNonPositiveDuration: true });
-  assertTimeSignature(ts);
-  const pulse2 = pulseBeats(ts);
+  const pulse2 = pulseBeats(meter);
   return melody.map((_, index) => {
-    const role = roleOfNote(melody, index, ts, pulse2);
+    const role = roleOfNote(melody, index, meter, pulse2);
     return { noteIndex: index, role, ornamental: role !== "structural" };
   });
 }
@@ -3531,7 +3928,7 @@ function roleOfNote(melody, index, ts, pulse2) {
   }
   const intoNote = Math.abs(prev.startBeat + prev.durationBeat - note2.startBeat);
   const outOfNote = Math.abs(note2.startBeat + note2.durationBeat - next.startBeat);
-  if (intoNote > ADJACENCY_TOLERANCE || outOfNote > ADJACENCY_TOLERANCE) {
+  if (intoNote > HUMANIZE_ADJACENCY || outOfNote > HUMANIZE_ADJACENCY) {
     return "structural";
   }
   const weight = metricWeight(snapToPulse(note2.startBeat, pulse2), ts);
@@ -3562,7 +3959,7 @@ function roleOfNote(melody, index, ts, pulse2) {
   return "structural";
 }
 
-// src/generate/harmonize/index.ts
+// src/generate/harmonize/internal.ts
 var FALLBACK = {
   rootPc: 0,
   quality: "maj",
@@ -3575,36 +3972,17 @@ function defaultHarmonicRhythm(ts) {
   const half = bar2 / 2;
   return half % pulseBeats(ts) === 0 ? half : bar2;
 }
-var DEFAULT_PLACEMENT = { transposeSearch: false, octaveSearch: false };
+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 NON_CHORD_TONE_STRONG = 4;
-var NON_CHORD_TONE_WEAK = 1;
-var NON_SCALE_TONE = 0.5;
-var DEGREE_BASE = [0, 0.3, 0.45, 0.15, 0.1, 0.3, 0.9];
-var SECONDARY_DOMINANT_BASE = 0.5;
-var BORROWED_BASE = 0.5;
-var CHORD_CHANGE = 0.8;
-var DESCENDING_FIFTH = -0.4;
-var ASCENDING_FIFTH = 0;
-var DOMINANT_TO_TONIC = -0.3;
-var SECONDARY_UNRESOLVED = 1;
-var SECONDARY_AFTER_TARGET = 0.8;
-var ROOT_MOTION_COST = [0, 0.15, 0.15, 0.2, 0.2, 0, 0.4];
-var PHRASE_TONIC = -7;
-var PHRASE_AUTHENTIC = -0.5;
-var OUT_OF_KEY_PER_BEAT = 3;
 var TIE_BREAK_JITTER2 = 1e-6;
-function isMinorKey(key) {
-  return (key.modeMask12 >> 3 & 1) === 1 && (key.modeMask12 >> 4 & 1) === 0;
-}
-function leadingTonePc(key) {
-  return (pitchClassOf(key.rootPc) + 11) % 12;
+function cadencesThroughRaisedSeventh(key) {
+  return isMinorKey(key) && scaleSystemOf(key) === "common-practice";
 }
 function isKeyTone(pitch, key) {
-  return isScaleTone(pitch, key) || isMinorKey(key) && pitchClassOf(pitch) === leadingTonePc(key);
+  return isScaleTone(pitch, key) || cadencesThroughRaisedSeventh(key) && pitchClassOf(pitch) === leadingTonePcOf(key);
 }
 function inferKey(melody) {
   let best = majorKey(0);
@@ -3633,93 +4011,21 @@ function inferKey(melody) {
   }
   return best;
 }
-var SECONDARY_DOMINANT_TARGETS = [2, 4, 5, 6];
-var SECONDARY_DOMINANT_ENTRY_ORDER = [5, 6, 2, 4];
-var SECONDARY_DOMINANT_BAND = 0.5;
-var REHARMONIZE_DIAL = {
-  diatonic: 0,
-  secondaryDominant: SECONDARY_DOMINANT_BAND,
-  borrowed: 1
-};
-function admittedCount(fraction, size) {
-  return Math.max(0, Math.min(size, Math.ceil(fraction * size)));
-}
-function buildCandidates(key, harmonic) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const candidates = tones.map((rootPc, index) => {
-    const degree = index + 1;
-    const quality = diatonicTriad(degree, key).quality;
-    return {
-      rootPc,
-      quality,
-      degree,
-      secondaryDominant: false,
-      base: DEGREE_BASE[index] ?? 0.6,
-      pcs: chordPitchClasses(makeChord(rootPc, quality))
-    };
-  });
-  if (isMinorKey(key)) {
-    const rootPc = (pitchClassOf(key.rootPc) + 7) % 12;
-    candidates.push({
-      rootPc,
-      quality: "maj",
-      degree: 5,
-      secondaryDominant: false,
-      base: DEGREE_BASE[4] ?? 0.6,
-      pcs: chordPitchClasses(makeChord(rootPc, "maj"))
-    });
-  }
-  const secondaryOpen = admittedCount(
-    harmonic / SECONDARY_DOMINANT_BAND,
-    SECONDARY_DOMINANT_TARGETS.length
-  );
-  for (const target of SECONDARY_DOMINANT_TARGETS) {
-    if (SECONDARY_DOMINANT_ENTRY_ORDER.indexOf(target) >= secondaryOpen) {
-      continue;
-    }
-    const targetRoot = tones[target - 1] ?? 0;
-    const rootPc = (targetRoot + 7) % 12;
-    candidates.push({
-      rootPc,
-      quality: "dom7",
-      secondaryDominant: true,
-      targetDegree: target,
-      base: SECONDARY_DOMINANT_BASE,
-      pcs: chordPitchClasses(makeChord(rootPc, "dom7"))
-    });
-  }
-  const parallel = parallelKey(key);
-  const parallelTones = scaleTonesInDegreeOrder(parallel);
-  const borrowed = [];
-  for (let degree = 1; degree <= parallelTones.length; degree += 1) {
-    const chord = diatonicTriad(degree, parallel);
-    if (!isDiatonic(chord, key)) {
-      borrowed.push(chord);
-    }
-  }
-  const borrowedOpen = admittedCount(
-    (harmonic - SECONDARY_DOMINANT_BAND) / (1 - SECONDARY_DOMINANT_BAND),
-    borrowed.length
-  );
-  for (const chord of borrowed.slice(0, borrowedOpen)) {
-    candidates.push({
-      rootPc: chord.rootPc,
-      quality: chord.quality,
-      secondaryDominant: false,
-      base: BORROWED_BASE,
-      pcs: chordPitchClasses(chord)
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return candidates.filter((candidate) => {
-    const id = `${candidate.rootPc}:${candidate.quality}`;
-    if (seen.has(id)) {
-      return false;
-    }
-    seen.add(id);
-    return true;
-  });
-}
+
+// src/generate/harmonize/cost.ts
+var NON_CHORD_TONE_STRONG = 4;
+var NON_CHORD_TONE_WEAK = 1;
+var NON_SCALE_TONE = 0.5;
+var CHORD_CHANGE = 0.8;
+var DESCENDING_FIFTH = -0.4;
+var ASCENDING_FIFTH = 0;
+var DOMINANT_TO_TONIC = -0.3;
+var SECONDARY_UNRESOLVED = 1;
+var SECONDARY_AFTER_TARGET = 0.8;
+var ROOT_MOTION_COST = [0, 0.15, 0.15, 0.2, 0.2, 0, 0.4];
+var PHRASE_TONIC = -7;
+var PHRASE_AUTHENTIC = -0.5;
+var OUT_OF_KEY_PER_BEAT = 3;
 function emissionCost(seg, cand, melody, key) {
   const pcs = cand.pcs;
   let cost = cand.base * seg.weight;
@@ -3735,40 +4041,9 @@ function emissionCost(seg, cand, melody, key) {
   }
   return cost;
 }
-function tessituraCost(melody) {
-  let cost = 0;
-  for (const n of melody) {
-    if (n.pitch < COMFORT_LOW) {
-      cost += (COMFORT_LOW - n.pitch) * TESSITURA_WEIGHT;
-    } else if (n.pitch > COMFORT_HIGH) {
-      cost += (n.pitch - COMFORT_HIGH) * TESSITURA_WEIGHT;
-    }
-  }
-  return cost;
-}
 function isDominantOf(cand, tonicPc) {
   return cand.rootPc === (tonicPc + 7) % 12 && (cand.quality === "maj" || cand.quality === "dom7");
 }
-function keyFitCost(melody, key) {
-  let cost = 0;
-  for (const n of melody) {
-    if (!isKeyTone(n.pitch, key)) {
-      cost += Math.max(0.25, n.durationBeat) * OUT_OF_KEY_PER_BEAT;
-    }
-  }
-  return cost;
-}
-function mergeRepeats(spans) {
-  const merged = [];
-  for (const span of spans) {
-    const prev = merged.at(-1);
-    if (prev && prev.rootPc === span.rootPc && prev.quality === span.quality && prev.degree === span.degree && prev.secondaryDominant === span.secondaryDominant) {
-      continue;
-    }
-    merged.push(span);
-  }
-  return merged;
-}
 function transitionCost(prev, cur, tonicPc) {
   let cost = prev.rootPc === cur.rootPc && prev.quality === cur.quality ? 0 : CHORD_CHANGE;
   const down = (prev.rootPc - cur.rootPc + 12) % 12;
@@ -3801,7 +4076,92 @@ function phraseEndBonus(prev, cur, tonicPc, seg, melody) {
   const weight = Math.max(seg.weight, seg.beats);
   return (PHRASE_TONIC + (prev !== null && isDominantOf(prev, tonicPc) ? PHRASE_AUTHENTIC : 0)) * weight;
 }
-var BEAT_EPS = 1e-9;
+
+// src/generate/harmonize/key-fit.ts
+var COMFORT_LOW = 55;
+var COMFORT_HIGH = 79;
+var TESSITURA_WEIGHT = 1e-3;
+function tessituraCost(melody) {
+  let cost = 0;
+  for (const n of melody) {
+    if (n.pitch < COMFORT_LOW) {
+      cost += (COMFORT_LOW - n.pitch) * TESSITURA_WEIGHT;
+    } else if (n.pitch > COMFORT_HIGH) {
+      cost += (n.pitch - COMFORT_HIGH) * TESSITURA_WEIGHT;
+    }
+  }
+  return cost;
+}
+function keyFitCost(melody, key) {
+  let cost = 0;
+  for (const n of melody) {
+    if (!isKeyTone(n.pitch, key)) {
+      cost += Math.max(0.25, n.durationBeat) * OUT_OF_KEY_PER_BEAT;
+    }
+  }
+  return cost;
+}
+
+// src/generate/harmonize/search.ts
+function sameHarmony(a, b) {
+  return a.rootPc === b.rootPc && a.quality === b.quality;
+}
+function harmonizeOnce(melody, key, candidates, segments, jitter, phraseEnds, articulated) {
+  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) + (seg0 && phraseEnds.has(0) ? phraseEndBonus(null, c, tonicPc, seg0, melody) : 0) + (jitter[ci] ?? 0)
+  );
+  const back = [];
+  for (let s = 1; s < segments.length; s += 1) {
+    const seg = segments[s];
+    if (!seg) {
+      continue;
+    }
+    const closes = phraseEnds.has(s);
+    const articulates = articulated.has(s);
+    const next = [];
+    const ptr = [];
+    for (let c = 0; c < n; c += 1) {
+      let best = Number.POSITIVE_INFINITY;
+      let bestPrev = 0;
+      for (let p = 0; p < n; p += 1) {
+        if (articulates && sameHarmony(candAt(p), candAt(c))) {
+          continue;
+        }
+        const cost = (dp[p] ?? Number.POSITIVE_INFINITY) + transitionCost(candAt(p), candAt(c), tonicPc) * seg.beats + (closes ? phraseEndBonus(candAt(p), candAt(c), tonicPc, seg, melody) : 0);
+        if (cost < best) {
+          best = cost;
+          bestPrev = p;
+        }
+      }
+      next[c] = best + emissionCost(seg, candAt(c), melody, key) + (jitter[c] ?? 0);
+      ptr[c] = bestPrev;
+    }
+    dp = next;
+    back.push(ptr);
+  }
+  let bestCost = Number.POSITIVE_INFINITY;
+  let bestEnd = 0;
+  for (let c = 0; c < n; c += 1) {
+    const total = dp[c] ?? Number.POSITIVE_INFINITY;
+    if (total < bestCost) {
+      bestCost = total;
+      bestEnd = c;
+    }
+  }
+  const path = new Array(segments.length).fill(bestEnd);
+  for (let s = segments.length - 2; s >= 0; s -= 1) {
+    const ptr = back[s];
+    const nextIdx = path[s + 1] ?? bestEnd;
+    path[s] = ptr ? ptr[nextIdx] ?? bestEnd : bestEnd;
+  }
+  return { cost: bestCost, path };
+}
+
+// src/generate/harmonize/segments.ts
 function gridBounds(segmentStart, hr, gridCount, ends) {
   const bounds = [];
   for (let s = 0; s <= gridCount; s += 1) {
@@ -3850,8 +4210,16 @@ function segmentIndexAt(bounds, beat) {
   }
   return found;
 }
-function sameHarmony(a, b) {
-  return a.rootPc === b.rootPc && a.quality === b.quality;
+function mergeRepeats(spans) {
+  const merged = [];
+  for (const span of spans) {
+    const prev = merged.at(-1);
+    if (prev && prev.rootPc === span.rootPc && prev.quality === span.quality && prev.degree === span.degree && prev.secondaryDominant === span.secondaryDominant) {
+      continue;
+    }
+    merged.push(span);
+  }
+  return merged;
 }
 function phraseEndSegments(segments, ends) {
   const closing = new Set(segments.length > 0 ? [segments.length - 1] : []);
@@ -3870,103 +4238,19 @@ function phraseEndSegments(segments, ends) {
   }
   return { closing, named };
 }
-function harmonizeOnce(melody, key, candidates, segments, jitter, phraseEnds, articulated) {
-  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) + (seg0 && phraseEnds.has(0) ? phraseEndBonus(null, c, tonicPc, seg0, melody) : 0) + (jitter[ci] ?? 0)
-  );
-  const back = [];
-  for (let s = 1; s < segments.length; s += 1) {
-    const seg = segments[s];
-    if (!seg) {
-      continue;
-    }
-    const closes = phraseEnds.has(s);
-    const articulates = articulated.has(s);
-    const next = [];
-    const ptr = [];
-    for (let c = 0; c < n; c += 1) {
-      let best = Number.POSITIVE_INFINITY;
-      let bestPrev = 0;
-      for (let p = 0; p < n; p += 1) {
-        if (articulates && sameHarmony(candAt(p), candAt(c))) {
-          continue;
-        }
-        const cost = (dp[p] ?? Number.POSITIVE_INFINITY) + transitionCost(candAt(p), candAt(c), tonicPc) * seg.beats + (closes ? phraseEndBonus(candAt(p), candAt(c), tonicPc, seg, melody) : 0);
-        if (cost < best) {
-          best = cost;
-          bestPrev = p;
-        }
-      }
-      next[c] = best + emissionCost(seg, candAt(c), melody, key) + (jitter[c] ?? 0);
-      ptr[c] = bestPrev;
-    }
-    dp = next;
-    back.push(ptr);
-  }
-  let bestCost = Number.POSITIVE_INFINITY;
-  let bestEnd = 0;
-  for (let c = 0; c < n; c += 1) {
-    const total = dp[c] ?? Number.POSITIVE_INFINITY;
-    if (total < bestCost) {
-      bestCost = total;
-      bestEnd = c;
-    }
-  }
-  const path = new Array(segments.length).fill(bestEnd);
-  for (let s = segments.length - 2; s >= 0; s -= 1) {
-    const ptr = back[s];
-    const nextIdx = path[s + 1] ?? bestEnd;
-    path[s] = ptr ? ptr[nextIdx] ?? bestEnd : bestEnd;
-  }
-  return { cost: bestCost, path };
-}
-function harmonizeMelody(opts) {
-  assertNoteEvents(opts.melody, "harmonize melody", { allowNonPositiveDuration: true });
-  const phraseEnds = opts.phraseEnds ?? [];
-  for (const end of phraseEnds) {
-    assertFiniteNumber(end, "harmonize phrase end");
-  }
-  const soundingMelody = soundingNotesOnly(opts.melody);
-  const ts = opts.ts ?? DEFAULT_METER;
-  assertTimeSignature(ts);
-  const requestedKey = opts.key ?? "infer";
-  const key = requestedKey === "infer" ? inferKey(soundingMelody) : toKeyScale(requestedKey);
-  const placement = opts.placement ?? DEFAULT_PLACEMENT;
-  const ctx = resolveContext(opts.ctx);
-  const harmonic = ctx.harmonic ?? REHARMONIZE_DIAL[opts.reharmonize ?? "diatonic"];
-  if (soundingMelody.length === 0) {
-    return { transposeSemitones: 0, key, chords: [], melodyRoles: [] };
-  }
-  const candidates = buildCandidates(key, harmonic);
-  const candAt = (i) => candidates[i] ?? FALLBACK;
-  const draw = ctx.part("harmony");
-  const jitter = candidates.map((_, index) => draw.at("jitter", index) * TIE_BREAK_JITTER2);
-  const pulse2 = pulseBeats(ts);
-  const spans = soundingMelody.map((note2) => ({
-    startBeat: snapToPulse(note2.startBeat, pulse2),
-    endBeat: snapToPulse(note2.startBeat + note2.durationBeat, pulse2)
-  }));
-  const melodyStart = spans.reduce(
-    (start, span) => Math.min(start, span.startBeat),
-    Number.POSITIVE_INFINITY
-  );
-  const melodyEnd = spans.reduce((end, span) => Math.max(end, span.endBeat), 0);
-  const hr = assertRange(
-    opts.harmonicRhythm ?? defaultHarmonicRhythm(ts),
-    Number.MIN_VALUE,
-    Number.MAX_SAFE_INTEGER,
-    "harmonic rhythm"
-  );
+function buildSegments(spans, melody, ts, grid, phraseEnds, budget) {
+  const melodyStart = grid.start;
+  const melodyEnd = grid.end;
+  const hr = grid.harmonicRhythm;
   const segmentStart = Math.floor(melodyStart / hr) * hr;
   const gridCount = Math.max(1, Math.ceil((melodyEnd - segmentStart) / hr));
-  assertGenerationBudget(gridCount, "harmonic segments");
-  const bounds = gridBounds(segmentStart, hr, gridCount, phraseEnds);
+  assertGenerationBudget(gridCount, "harmonic segments", budget);
+  const innerEnds = phraseEnds.filter(
+    (end) => end > segmentStart + BEAT_EPS && end < melodyEnd - BEAT_EPS
+  );
+  const bounds = gridBounds(segmentStart, hr, gridCount, innerEnds);
   const segCount = bounds.length - 1;
-  assertGenerationBudget(segCount, "harmonic segments");
+  assertGenerationBudget(segCount, "harmonic segments", budget);
   const segments = Array.from({ length: segCount }, (_, s) => {
     const startBeat = bounds[s] ?? segmentStart;
     const endBeat = bounds[s + 1] ?? startBeat + hr;
@@ -3987,13 +4271,13 @@ function harmonizeMelody(opts) {
       lastExclusive += 1;
     }
     memberships += Math.max(0, lastExclusive - first);
-    assertGenerationBudget(memberships, "note-to-segment memberships");
+    assertGenerationBudget(memberships, "note-to-segment memberships", budget);
     for (let segment = first; segment < lastExclusive; segment += 1) {
       segments[segment]?.noteIndices.push(index);
     }
   }
-  const tones = classifyMelodyTones(soundingMelody, ts);
-  const phraseClosingNotes = closingNoteIndices(spans, phraseEnds);
+  const tones = classifyMelodyTones(melody, ts);
+  const phraseClosingNotes = closingNoteIndices(spans, innerEnds);
   for (const segment of segments) {
     const structural = segment.noteIndices.filter(
       (idx) => tones[idx]?.ornamental !== true || phraseClosingNotes.has(idx)
@@ -4019,9 +4303,200 @@ function harmonizeMelody(opts) {
       }
     }
   }
+  return { segments, innerEnds, bounds, segmentStart };
+}
+
+// src/generate/harmonize/candidates.ts
+var ROOT_WEIGHT_BY_SEMITONE = [0, 0.9, 0.3, 0.45, 0.45, 0.15, 0.9, 0.1, 0.3, 0.3, 0.3, 0.9];
+var UNSTABLE_TRIAD = 0.9;
+var UNSTABLE_QUALITIES = /* @__PURE__ */ new Set([
+  "dim",
+  "aug",
+  "dim7",
+  "m7b5",
+  "aug7"
+]);
+function vocabularyBase(rootPc, quality, tonicPc) {
+  const above = (pitchClassOf(rootPc) - tonicPc + 12) % 12;
+  const root = ROOT_WEIGHT_BY_SEMITONE[above] ?? UNSTABLE_TRIAD;
+  return UNSTABLE_QUALITIES.has(quality) ? Math.max(root, UNSTABLE_TRIAD) : root;
+}
+var SECONDARY_DOMINANT_BASE = 0.5;
+var BORROWED_BASE = 0.5;
+var SECONDARY_DOMINANT_TARGETS = [2, 4, 5, 6];
+function secondaryDominantTargets(key) {
+  const tonicizable = new Map(
+    tonicizableDegrees(key).map((degree) => [degree.degreeNumber, degree])
+  );
+  return SECONDARY_DOMINANT_TARGETS.map((degree) => tonicizable.get(degree)).filter(
+    (degree) => degree !== void 0
+  );
+}
+var SECONDARY_DOMINANT_ENTRY_ORDER = [5, 6, 2, 4];
+var BORROWED_ENTRY_ORDER = [5, 10, 8, 3, 7, 2, 0];
+var SECONDARY_DOMINANT_BAND = 0.5;
+var REHARMONIZE_STRENGTHS = ["diatonic", "secondaryDominant", "borrowed"];
+var REHARMONIZE_DIAL = {
+  diatonic: 0,
+  secondaryDominant: SECONDARY_DOMINANT_BAND,
+  borrowed: 1
+};
+function admittedCount(fraction, size) {
+  return Math.max(0, Math.min(size, Math.ceil(fraction * size)));
+}
+function buildCandidates(key, harmonic) {
+  const tonicPc = pitchClassOf(key.rootPc);
+  const frame = heptatonicFrameOf(key);
+  const tones = scaleTonesInDegreeOrder(frame);
+  const candidates = tones.map((rootPc, index) => {
+    const degree = index + 1;
+    const quality = diatonicTriad(degree, frame).quality;
+    return {
+      rootPc,
+      quality,
+      degree,
+      secondaryDominant: false,
+      base: vocabularyBase(rootPc, quality, tonicPc),
+      pcs: chordPitchClasses(makeChord(rootPc, quality))
+    };
+  });
+  if (cadencesThroughRaisedSeventh(key)) {
+    const rootPc = (tonicPc + 7) % 12;
+    candidates.push({
+      rootPc,
+      quality: "maj",
+      degree: 5,
+      secondaryDominant: false,
+      base: vocabularyBase(rootPc, "maj", tonicPc),
+      pcs: chordPitchClasses(makeChord(rootPc, "maj"))
+    });
+  }
+  const targets = secondaryDominantTargets(key);
+  const entryOrder = SECONDARY_DOMINANT_ENTRY_ORDER.filter(
+    (degree) => targets.some((target) => target.degreeNumber === degree)
+  );
+  const secondaryOpen = admittedCount(harmonic / SECONDARY_DOMINANT_BAND, targets.length);
+  for (const target of targets) {
+    if (entryOrder.indexOf(target.degreeNumber) >= secondaryOpen) {
+      continue;
+    }
+    const rootPc = (target.rootPc + 7) % 12;
+    candidates.push({
+      rootPc,
+      quality: "dom7",
+      secondaryDominant: true,
+      targetDegree: target.degreeNumber,
+      base: SECONDARY_DOMINANT_BASE,
+      pcs: chordPitchClasses(makeChord(rootPc, "dom7"))
+    });
+  }
+  const parallel = parallelKey(key);
+  const parallelTones = scaleTonesInDegreeOrder(parallel);
+  const borrowed = [];
+  for (let degree = 1; degree <= parallelTones.length; degree += 1) {
+    const chord = diatonicTriad(degree, parallel);
+    if (!isDiatonic(chord, key)) {
+      borrowed.push(chord);
+    }
+  }
+  const borrowedRank = (chord) => {
+    const offset = BORROWED_ENTRY_ORDER.indexOf(pitchClassOf(chord.rootPc - tonicPc));
+    return offset < 0 ? BORROWED_ENTRY_ORDER.length : offset;
+  };
+  borrowed.sort((a, b) => borrowedRank(a) - borrowedRank(b));
+  const borrowedOpen = admittedCount(
+    (harmonic - SECONDARY_DOMINANT_BAND) / (1 - SECONDARY_DOMINANT_BAND),
+    borrowed.length
+  );
+  for (const chord of borrowed.slice(0, borrowedOpen)) {
+    candidates.push({
+      rootPc: chord.rootPc,
+      quality: chord.quality,
+      secondaryDominant: false,
+      // A diminished or augmented triad is charged for what it is wherever it
+      // comes from: priced at the flat borrowing rate, the ii dim borrowed from
+      // the parallel minor came out cheaper than the key's own vii dim, and
+      // which of the two a phrase took was decided by the tie-break jitter
+      // rather than by the melody.
+      base: UNSTABLE_QUALITIES.has(chord.quality) ? Math.max(BORROWED_BASE, UNSTABLE_TRIAD) : BORROWED_BASE,
+      pcs: chordPitchClasses(chord)
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const id = `${candidate.rootPc}:${candidate.quality}`;
+    if (seen.has(id)) {
+      return false;
+    }
+    seen.add(id);
+    return true;
+  });
+}
+
+// src/generate/harmonize/index.ts
+function harmonizeMelody(opts) {
+  assertRecord(opts, "harmonize options");
+  assertNoteEvents(opts.melody, "harmonize melody", {
+    allowNonPositiveDuration: true,
+    budget: opts.budget
+  });
+  const phraseEnds = opts.phraseEnds ?? [];
+  for (const end of phraseEnds) {
+    assertFiniteNumber(end, "harmonize phrase end");
+  }
+  const soundingMelody = soundingNotesOnly(opts.melody);
+  const ts = meterAt(0, toMeterData(opts.ts ?? DEFAULT_METER, "ts"));
+  assertTimeSignature(ts);
+  const requestedKey = opts.key ?? "infer";
+  const resolvedKey = resolveKey(
+    requestedKey === "infer" ? inferKey(soundingMelody) : requestedKey
+  );
+  const key = resolvedKey.scale;
+  const placement = opts.placement ?? DEFAULT_PLACEMENT;
+  const ctx = resolveContext(opts.ctx);
+  const reharmonize = assertOneOf(
+    opts.reharmonize ?? "diatonic",
+    REHARMONIZE_STRENGTHS,
+    "reharmonize"
+  );
+  const harmonic = ctx.harmonic ?? REHARMONIZE_DIAL[reharmonize];
+  if (soundingMelody.length === 0) {
+    return { transposeSemitones: 0, key: resolvedKey, chords: [], melodyRoles: [] };
+  }
+  const candidates = buildCandidates(key, harmonic);
+  const candAt = (i) => candidates[i] ?? FALLBACK;
+  const draw = ctx.part("harmony");
+  const jitter = candidates.map((_, index) => draw.at("jitter", index) * TIE_BREAK_JITTER2);
+  const pulse2 = pulseBeats(ts);
+  const spans = soundingMelody.map((note2) => ({
+    startBeat: snapToPulse(note2.startBeat, pulse2),
+    endBeat: snapToPulse(note2.startBeat + note2.durationBeat, pulse2)
+  }));
+  const melodyStart = spans.reduce(
+    (start, span) => Math.min(start, span.startBeat),
+    Number.POSITIVE_INFINITY
+  );
+  const melodyEnd = spans.reduce(
+    (end, span) => Math.max(end, span.endBeat),
+    Number.NEGATIVE_INFINITY
+  );
+  const hr = assertRange(
+    opts.harmonicRhythm ?? defaultHarmonicRhythm(ts),
+    Number.MIN_VALUE,
+    Number.MAX_SAFE_INTEGER,
+    "harmonic rhythm"
+  );
+  const { segments, innerEnds, bounds, segmentStart } = buildSegments(
+    spans,
+    soundingMelody,
+    ts,
+    { start: melodyStart, end: melodyEnd, harmonicRhythm: hr },
+    phraseEnds,
+    opts.budget
+  );
   const { closing: closingSegments, named: namedEndSegments } = phraseEndSegments(
     segments,
-    phraseEnds
+    innerEnds
   );
   const articulatedSegments = new Set(candidates.map((c) => `${c.rootPc}:${c.quality}`)).size > 1 ? namedEndSegments : /* @__PURE__ */ new Set();
   const semitoneShifts = [0];
@@ -4035,8 +4510,9 @@ function harmonizeMelody(opts) {
   const octaveShifts = placement.octaveSearch ? [0, -12, 12] : [0];
   const transposes = semitoneShifts.flatMap((s) => octaveShifts.map((o) => s + o));
   assertGenerationBudget(
-    transposes.length * segCount * candidates.length * candidates.length,
-    "harmonization placement search"
+    transposes.length * segments.length * candidates.length * candidates.length,
+    "harmonization placement search",
+    opts.budget
   );
   let bestCost = Number.POSITIVE_INFINITY;
   let bestTs = 0;
@@ -4077,21 +4553,29 @@ function harmonizeMelody(opts) {
     })
   );
   const melodyRoles = opts.melody.map((note2, noteIndex) => {
-    const segIdx = segmentIndexAt(bounds, note2.startBeat);
+    const segIdx = segmentIndexAt(bounds, snapToPulse(note2.startBeat, pulse2));
     const cand = candAt(bestPath[segIdx] ?? 0);
     const chord = makeChord(cand.rootPc, cand.quality);
     return { noteIndex, role: roleOf(note2.pitch + bestTs, chord).role };
   });
-  return { transposeSemitones: bestTs, key, chords, melodyRoles };
+  return { transposeSemitones: bestTs, key: resolvedKey, chords, melodyRoles };
 }
 
 // src/generate/motif/index.ts
+var MOTIF_TRANSFORMS = Object.freeze([
+  "transposeDiatonic",
+  "transposeChromatic",
+  "invert",
+  "retrograde",
+  "augment",
+  "diminish",
+  "sequence"
+]);
 var MIN_TILE_SPAN = 1 / 256;
-var DEFAULT_TS5 = { numerator: 4, denominator: 4 };
-var EPS4 = 1e-9;
+var DEFAULT_TS4 = { numerator: 4, denominator: 4 };
 function isDownbeat(startBeat, barBeats) {
   const bar2 = startBeat / barBeats;
-  return Math.abs(bar2 - Math.round(bar2)) < EPS4;
+  return Math.abs(bar2 - Math.round(bar2)) < BEAT_EPS;
 }
 function nearestChordTone(pitch, chord) {
   const pcs = chordPitchClasses(chord);
@@ -4146,6 +4630,18 @@ function cellSpan(cell) {
 function clone(cell) {
   return { notes: cell.notes.map((n) => ({ ...n })) };
 }
+function inTimeOrder(cell) {
+  return { notes: [...cell.notes].sort((a, b) => a.startBeat - b.startBeat) };
+}
+function pivotPitch(notes) {
+  let pivot;
+  for (const note2 of notes) {
+    if (pivot === void 0 || note2.startBeat < pivot.startBeat) {
+      pivot = note2;
+    }
+  }
+  return pivot?.pitch ?? 0;
+}
 function contourOffsets(contour, count) {
   const offsets = [];
   for (let i = 0; i < count; i += 1) {
@@ -4167,9 +4663,10 @@ function contourOffsets(contour, count) {
   return offsets;
 }
 function generateMotif(opts) {
+  assertRecord(opts, "motif options");
   const contour = opts.contour ?? "arch";
   const bars = assertPositiveInt(opts.bars, "motif bars");
-  const barBeats = beatsPerBar(opts.ts ?? DEFAULT_TS5);
+  const barBeats = beatsPerBar(meterAt(0, toMeterData(opts.ts ?? DEFAULT_TS4, "ts")));
   const totalBeats = bars * barBeats;
   const noteCount = Math.max(3, bars * 2);
   assertGenerationBudget(noteCount, "motif notes");
@@ -4201,13 +4698,18 @@ function generateMotif(opts) {
   return { notes };
 }
 function motifToNoteEvents(cell) {
-  return cell.notes.map((note2) => ({ ...note2 }));
+  return assertCellNotes(cell, "motif cell notes").map((note2) => ({ ...note2 }));
+}
+function assertCellNotes(cell, name) {
+  const read = assertRecord(cell, "motif cell");
+  assertNoteEvents(read.notes, name);
+  return read.notes;
 }
 function transformMotif(cell, t, amount, key) {
   return transformCell(cell, t, amount, key === void 0 ? void 0 : toKeyScale(key));
 }
 function transformCell(cell, t, amount, key) {
-  return assertInRange(transformUnchecked(cell, t, amount, key));
+  return assertInRange(inTimeOrder(transformUnchecked(cell, t, amount, key)));
 }
 function assertInRange(cell) {
   for (const note2 of cell.notes) {
@@ -4220,7 +4722,8 @@ function assertInRange(cell) {
   return cell;
 }
 function transformUnchecked(cell, t, amount, key) {
-  assertNoteEvents(cell.notes, "motif notes");
+  const notes = assertCellNotes(cell, "motif notes");
+  assertOneOf(t, MOTIF_TRANSFORMS, "motif transform");
   if (amount !== void 0) {
     assertFiniteNumber(amount, "motif transform amount");
   }
@@ -4233,7 +4736,6 @@ function transformUnchecked(cell, t, amount, key) {
   if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
     throw new InvalidInputError("time transform amount must be positive");
   }
-  const notes = cell.notes;
   switch (t) {
     case "transposeChromatic": {
       const semis = amount ?? 0;
@@ -4255,7 +4757,7 @@ function transformUnchecked(cell, t, amount, key) {
       };
     }
     case "invert": {
-      const pivot = notes[0]?.pitch ?? 0;
+      const pivot = pivotPitch(notes);
       return { notes: notes.map((n) => ({ ...n, pitch: 2 * pivot - n.pitch })) };
     }
     case "retrograde": {
@@ -4295,26 +4797,28 @@ function scaleTime(cell, factor) {
     }))
   };
 }
-function developMotif(cell, timeline, key, bars, ts = DEFAULT_TS5) {
+function developMotif(cell, timeline, key, bars, ts) {
+  const meter = meterAt(0, toMeterData(ts, "ts"));
+  assertChordTimeline(timeline);
   assertPositiveInt(bars, "development bars");
-  assertNoteEvents(cell.notes, "motif notes");
+  const cellNotes = assertCellNotes(cell, "motif notes");
   const scale = toKeyScale(key);
   const span = cellSpan(cell);
-  const barBeats = beatsPerBar(ts);
+  const barBeats = beatsPerBar(meter);
   const totalBeats = bars * barBeats;
-  const origin = cellOrigin(cell.notes);
+  const origin = cellOrigin(cellNotes);
   const out = [];
   if (span <= 0) {
-    return clone(cell);
+    return inTimeOrder(cell);
   }
   const tileSpan = Math.max(span, MIN_TILE_SPAN);
   const tileCount = Math.ceil(totalBeats / tileSpan);
-  assertGenerationBudget(tileCount * cell.notes.length, "developed motif notes");
+  assertGenerationBudget(tileCount * cellNotes.length, "developed motif notes");
   for (let k = 0; k < tileCount; k += 1) {
     const offset = k * tileSpan;
     const taken = /* @__PURE__ */ new Map();
     let previous;
-    for (const n of cell.notes) {
+    for (const n of cellNotes) {
       const startBeat = offset + (n.startBeat - origin);
       if (startBeat >= totalBeats) {
         continue;
@@ -4330,12 +4834,12 @@ function developMotif(cell, timeline, key, bars, ts = DEFAULT_TS5) {
       out.push({ pitch, startBeat, durationBeat: n.durationBeat });
     }
   }
-  return { notes: out };
+  return inTimeOrder({ notes: out });
 }
 
 // src/generate/ornament/index.ts
 var ORNAMENT_STYLES = Object.freeze(["ghost", "flam", "drag", "slide", "accent"]);
-var DEFAULT_TS6 = { numerator: 4, denominator: 4 };
+var DEFAULT_TS5 = { numerator: 4, denominator: 4 };
 var DEFAULT_STYLE2 = "ghost";
 var DEFAULT_AMOUNT = 0.5;
 var GHOST_VELOCITY_SCALE = 0.45;
@@ -4343,7 +4847,7 @@ var ACCENT_VELOCITY_BOOST = 12;
 var DEFAULT_VELOCITY2 = 80;
 var MIN_VELOCITY2 = 1;
 var MAX_VELOCITY2 = 127;
-var SLIDE_MIN_SEMITONES = 2;
+var SLIDE_MIN_SEMITONES = 1;
 function eligible(style, note2, previous, next, ts) {
   const strong = isStrongBeat(note2.startBeat, ts);
   switch (style) {
@@ -4378,28 +4882,23 @@ function clampVelocity(velocity) {
   return Math.min(MAX_VELOCITY2, Math.max(MIN_VELOCITY2, Math.round(velocity)));
 }
 function ornament(notes, opts = {}) {
+  const asked = assertOptions(opts, "opts");
   assertNoteEvents(notes, "ornament notes", { allowNonPositiveDuration: true });
-  const style = assertOneOf(opts.style ?? DEFAULT_STYLE2, ORNAMENT_STYLES, "ornament style");
-  const ts = opts.ts ?? DEFAULT_TS6;
+  const style = assertOneOf(asked.style ?? DEFAULT_STYLE2, ORNAMENT_STYLES, "ornament style");
+  const ts = meterAt(0, toMeterData(asked.ts ?? DEFAULT_TS5, "ts"));
   assertTimeSignature(ts);
-  if (opts.amount !== void 0) {
-    assertRange(opts.amount, 0, 1, "ornament amount");
+  if (asked.amount !== void 0) {
+    assertRange(asked.amount, 0, 1, "ornament amount");
   }
-  const ctx = resolveContextWith(opts.ctx, { ornament: opts.amount });
+  const ctx = resolveContextWith(asked.ctx, { ornament: asked.amount });
   const amount = ctx.ornament ?? DEFAULT_AMOUNT;
   const draw = ctx.part("ornament");
-  const sounding = dropSilentNotes(notes);
-  const ordered = [...sounding].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
-  const previousOf = /* @__PURE__ */ new Map();
-  for (let index = 0; index < ordered.length; index += 1) {
-    const note2 = ordered[index];
-    if (note2) {
-      previousOf.set(note2, index === 0 ? void 0 : ordered[index - 1]);
-    }
-  }
+  const sounding2 = dropSilentNotes(notes);
+  const ordered = [...sounding2].sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
+  const previousOf = previousOnsets(ordered);
   const nextOf = nextOnsets(ordered);
   const gaps = strokeGaps(ordered);
-  return sounding.map((note2) => {
+  return sounding2.map((note2) => {
     const decorated = { ...note2 };
     if (note2.articulation !== void 0 || !eligible(style, note2, previousOf.get(note2), nextOf.get(note2), ts)) {
       return decorated;
@@ -4418,6 +4917,19 @@ function ornament(notes, opts = {}) {
     return decorated;
   });
 }
+function previousOnsets(ordered) {
+  const previousOf = /* @__PURE__ */ new Map();
+  let earlier;
+  for (const note2 of ordered) {
+    if (earlier !== void 0 && earlier.startBeat === note2.startBeat) {
+      previousOf.set(note2, previousOf.get(earlier));
+    } else {
+      previousOf.set(note2, earlier);
+    }
+    earlier = note2;
+  }
+  return previousOf;
+}
 function nextOnsets(ordered) {
   const nextOf = /* @__PURE__ */ new Map();
   let later;
@@ -4450,6 +4962,8 @@ function strokeGaps(ordered) {
 }
 
 // src/generate/progression/index.ts
+var DEFAULT_TS6 = { numerator: 4, denominator: 4 };
+var PROG_STYLES = Object.freeze(["minimal", "dance", "idol", "rock"]);
 var BORROWED_DEGREES = Object.freeze({
   /** Flat submediant: bVI. */
   bVI: 8,
@@ -4633,23 +5147,23 @@ function progressions() {
   return PRESETS.map((p) => ({ ...p, degrees: [...p.degrees], styles: [...p.styles] }));
 }
 function progressionsByStyle(style) {
-  return progressions().filter((p) => p.styles.includes(style));
+  const named = assertOneOf(style, PROG_STYLES, "style");
+  return progressions().filter((p) => p.styles.includes(named));
 }
 function degreeToRootPc(degree, key) {
   if (degree >= 1 && degree <= 7) {
-    const tones = scaleTonesInDegreeOrder(key);
-    return tones.length > 0 ? tones[(degree - 1) % tones.length] ?? key.rootPc % 12 : key.rootPc % 12;
+    const tones = scaleTonesInDegreeOrder(heptatonicFrameOf(key));
+    return tones[degree - 1] ?? key.rootPc % 12;
   }
   const offset = BORROWED_OFFSET[degree] ?? 0;
   return ((key.rootPc % 12 + offset) % 12 + 12) % 12;
 }
 function autoQuality(degree, key, harmonicDominant) {
   if (degree >= 1 && degree <= 7) {
-    const isMinor = (key.modeMask12 >> 3 & 1) === 1 && (key.modeMask12 >> 4 & 1) === 0;
-    if (harmonicDominant && isMinor && degree === 5) {
+    if (harmonicDominant && isMinorKey(key) && degree === 5) {
       return "maj";
     }
-    return diatonicTriad(degree, key).quality;
+    return diatonicTriad(degree, heptatonicFrameOf(key)).quality;
   }
   if (degree === 14) {
     return "dim";
@@ -4660,46 +5174,44 @@ function autoQuality(degree, key, harmonicDominant) {
   return "maj";
 }
 function resolveCycle(degrees, key, ext, harmonicDominant) {
-  const steps = [];
-  for (const degree of degrees) {
+  const steps = degrees.map((degree) => {
     const step = {
-      source: degree,
       rootPc: degreeToRootPc(degree, key),
       quality: ext !== void 0 && ext !== "auto" ? ext : autoQuality(degree, key, harmonicDominant)
     };
     if (degree >= 1 && degree <= 7) {
       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" }];
+    return step;
+  });
+  return steps.length > 0 ? steps : [{ rootPc: degreeToRootPc(1, key), quality: "maj" }];
 }
-function sameStep(a, b) {
-  return a.rootPc === b.rootPc && a.quality === b.quality;
+function pickProgressionPreset(style, ctx = 0) {
+  return presetFor(style, resolveContext(ctx));
 }
-function pickProgressionPreset(style, seed = 0) {
+function presetFor(style, ctx) {
   const pool = PRESETS.filter((preset) => preset.styles.includes(style));
   if (pool.length === 0) {
     throw new InvalidInputError(`Unknown progression style: ${style}`);
   }
-  const index = resolveContext(seed).part("progression").range(0, pool.length - 1, "preset");
+  const index = ctx.part("progression").range(0, pool.length - 1, "preset");
   return pool[index] ?? PRESETS[0];
 }
+function tonicizableRootPcs(key) {
+  return new Set(tonicizableDegrees(key).map((degree) => degree.rootPc));
+}
+function canBeTonicized(span, tonicizable) {
+  if (!tonicizable.has(span.rootPc)) {
+    return false;
+  }
+  return fifthPcOf(makeChord(span.rootPc, span.quality)) === (span.rootPc + 7) % 12;
+}
 function generateProgression(opts) {
+  assertRecord(opts, "progression options");
   assertPositiveInt(opts.bars, "progression bars");
   assertGenerationBudget(opts.bars, "progression chords");
   const key = toKeyScale(opts.key);
   const ctx = resolveContext(opts.ctx);
-  const seed = ctx.seed;
   let preset;
   if (opts.preset !== void 0) {
     if (opts.preset.degrees.length === 0) {
@@ -4728,7 +5240,7 @@ function generateProgression(opts) {
       throw new InvalidInputError(`Unknown progression preset: ${opts.presetId}`);
     }
   }
-  preset ??= pickProgressionPreset(opts.style, seed);
+  preset ??= presetFor(opts.style, ctx);
   const ext = opts.ext === void 0 ? "auto" : assertOneOf(opts.ext, ["auto", ...chordQualities()], "progression extension");
   const cycle = resolveCycle(
     preset?.degrees ?? [0],
@@ -4736,13 +5248,14 @@ function generateProgression(opts) {
     ext,
     preset?.functional === "cadenceStrong"
   );
+  const barBeats = beatsPerBar(opts.ts ?? DEFAULT_TS6);
   const chords = [];
   for (let bar2 = 0; bar2 < opts.bars; bar2 += 1) {
     const step = cycle[bar2 % cycle.length];
     const chord = {
       rootPc: step?.rootPc ?? 0,
       quality: step?.quality ?? "maj",
-      startBeat: bar2 * 4
+      startBeat: bar2 * barBeats
     };
     if (step?.degree !== void 0) {
       chord.degree = step.degree;
@@ -4752,6 +5265,7 @@ function generateProgression(opts) {
   const harmonic = ctx.harmonic ?? DEFAULT_HARMONIC;
   if (harmonic > 0) {
     const tonicPc = (key.rootPc % 12 + 12) % 12;
+    const tonicizable = tonicizableRootPcs(key);
     const draw = ctx.part("progression");
     let tonicStatements = chords.filter((chord) => chord.rootPc === tonicPc).length;
     for (let i = 0; i < chords.length - 1; i += 1) {
@@ -4765,7 +5279,8 @@ function generateProgression(opts) {
       const isLastTonicStatement = cur.rootPc === tonicPc && tonicStatements <= 1;
       const alreadySecondary = cur.rootPc === domRoot && cur.quality === "dom7";
       const isResolutionTarget = chords[i - 1]?.secondaryDominant === true;
-      if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget) {
+      const takesNoDominant = !canBeTonicized(next, tonicizable);
+      if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget || takesNoDominant) {
         continue;
       }
       if (draw.prob(harmonic, "reharmonize", i)) {
@@ -4785,12 +5300,6 @@ function generateProgression(opts) {
 }
 
 // src/generate/reharmony/index.ts
-function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => pitchClassOf(iv) === semitone);
-}
-function isDominantType(chord) {
-  return hasInterval(chord, 4) && hasInterval(chord, 10);
-}
 function commonToneCount(a, b) {
   const set = new Set(b);
   return a.filter((pc) => set.has(pc)).length;
@@ -4821,23 +5330,10 @@ function sameChord(a, b) {
   return pitchClassOf(a.rootPc) === pitchClassOf(b.rootPc) && a.quality === b.quality;
 }
 var THIRD_OFFSETS = [3, 4, 8, 9];
-var MIDDLE_C = 60;
 var MAX_HINT_ALTER = 2;
 function bareSpelling(note2) {
   return { letter: note2.letter, alter: note2.alter };
 }
-function accidentalLoad(tonic, key) {
-  return spellScale(tonic, key).reduce((sum, note2) => sum + Math.abs(note2.alter), 0);
-}
-function keyTonicOf(key) {
-  const rootPc = pitchClassOf(key.rootPc);
-  const sharp = bareSpelling(midiToNote(MIDDLE_C + rootPc, "sharp"));
-  const flat = bareSpelling(midiToNote(MIDDLE_C + rootPc, "flat"));
-  if (sharp.letter === flat.letter) {
-    return sharp;
-  }
-  return accidentalLoad(flat, key) <= accidentalLoad(sharp, key) ? flat : sharp;
-}
 function spelledOnRoot(chord, root, tonic, key) {
   const usable = noteToPitchClass(root) === pitchClassOf(chord.rootPc) && Math.abs(root.alter) <= MAX_HINT_ALTER;
   const spelled = {
@@ -4861,12 +5357,12 @@ function tritoneSubstituteRoot(dominant, tonic, key) {
   return transposeNote(resolution, 1);
 }
 function substituteChord(chord, key, opts) {
+  assertOptions(opts, "opts");
   const source = toChordData(chord);
-  const scale = toKeyScale(key);
+  const { scale, tonic } = resolveKey(key);
   const originalTriad = chordPitchClasses(makeChord(source.rootPc, triadQualityOf(source)));
   const candidates = [];
-  const tonic = keyTonicOf(scale);
-  if (isDominantType(source)) {
+  if (soundsDominantSeventh(source)) {
     const substitute = makeChord(pitchClassOf(source.rootPc + 6), "dom7");
     candidates.push({
       chord: spelledOnRoot(substitute, tritoneSubstituteRoot(source, tonic, scale), tonic, scale),
@@ -4922,7 +5418,7 @@ function substituteChord(chord, key, opts) {
   return results;
 }
 function modalInterchangePalette(key) {
-  const scale = toKeyScale(key);
+  const { scale, tonic } = resolveKey(key);
   const palette = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (chord) => {
@@ -4937,7 +5433,6 @@ function modalInterchangePalette(key) {
       source: borrowedSource(chord, scale)
     });
   };
-  const tonic = keyTonicOf(scale);
   const parallel = parallelKey(scale);
   for (const triad of diatonicTriadsOf(parallel)) {
     if (!isDiatonic(triad, scale) && borrowedSource(triad, scale) !== null) {
@@ -4952,13 +5447,12 @@ function modalInterchangePalette(key) {
 }
 function negativeHarmonyMirror(chord, key) {
   const source = toChordData(chord);
-  const scale = toKeyScale(key);
+  const { scale, tonic } = resolveKey(key);
   const tonicPc = pitchClassOf(scale.rootPc);
-  const tonic = keyTonicOf(scale);
   const mirror = (p) => pitchClassOf(2 * tonicPc + 7 - p);
   const pcs = chordPitchClasses(source).map(mirror);
   const bassPc = source.bassPc !== void 0 ? mirror(source.bassPc) : void 0;
-  const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
+  const pitches = bassPc !== void 0 ? [bassPc, ...pcs.map((pc) => pc + 12)] : pcs;
   const detected = detectChordBest(pitches);
   if (detected) {
     if (bassPc === void 0 && detected.bassPc !== void 0) {
@@ -4973,9 +5467,9 @@ function negativeHarmonyMirror(chord, key) {
 // 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) => ({
+  assertMidiPitch(pitch, "pitch");
+  assertInteger(velocity, "velocity", 0, 127);
+  return assertArray(events, "events").map((event) => ({
     pitch,
     startBeat: event.position,
     durationBeat: event.duration,
@@ -4986,6 +5480,7 @@ var DEFAULT_SUBDIVISION = 2;
 var DEFAULT_DENSITY = 0.5;
 var DEFAULT_BARS = 1;
 function onsetWeightCurve(weight) {
+  assertInteger(weight, "weight", 0, 3);
   switch (weight) {
     case 3:
       return 1;
@@ -4998,13 +5493,15 @@ function onsetWeightCurve(weight) {
   }
 }
 function generateRhythm(ts, opts = {}) {
-  const bars = opts.bars ?? DEFAULT_BARS;
-  const subdivision = opts.subdivision ?? DEFAULT_SUBDIVISION;
-  const ctx = resolveContext(opts.ctx);
+  const asked = assertOptions(opts, "opts");
+  const meter = meterAt(0, toMeterData(ts, "ts"));
+  const bars = asked.bars ?? DEFAULT_BARS;
+  const subdivision = asked.subdivision ?? DEFAULT_SUBDIVISION;
+  const ctx = resolveContext(asked.ctx);
   const density = ctx.rhythmic ?? DEFAULT_DENSITY;
   assertPositiveInt(bars, "rhythm bars");
   assertPositiveInt(subdivision, "rhythm subdivision");
-  const barBeats = beatsPerBar(ts);
+  const barBeats = beatsPerBar(meter);
   const spanBeats = barBeats * bars;
   const step = 1 / subdivision;
   const slotsPerBar = Math.ceil(barBeats * subdivision);
@@ -5024,7 +5521,7 @@ function generateRhythm(ts, opts = {}) {
         positions.push(position);
         continue;
       }
-      const weight = metricWeight(position, ts);
+      const weight = metricWeight(position, meter);
       const probability = onsetWeightCurve(weight) * density;
       if (draw.prob(probability, "onset", bar2, slot)) {
         positions.push(position);
@@ -5040,12 +5537,14 @@ function generateRhythm(ts, opts = {}) {
   return events;
 }
 function rhythmDensity(events, ts) {
+  assertArray(events, "events");
+  const barBeats = beatsPerBar(ts);
   if (events.length === 0) {
     return 0;
   }
   const last = events[events.length - 1];
   const spanBeats = (last?.position ?? 0) + (last?.duration ?? 0);
-  const bars = spanBeats / beatsPerBar(ts);
+  const bars = spanBeats / barBeats;
   return bars > 0 ? events.length / bars : 0;
 }
 
@@ -5099,6 +5598,7 @@ export {
   applyGrooveTemplate,
   classifyMelodyTones,
   harmonizeMelody,
+  cellSpan,
   generateMotif,
   motifToNoteEvents,
   transformMotif,
@@ -5118,4 +5618,4 @@ export {
   generateRhythm,
   rhythmDensity
 };
-//# sourceMappingURL=chunk-VOHZB45S.js.map
+//# sourceMappingURL=chunk-R5VUXQMP.js.map