@libraz/libcantus 1.0.1 → 1.2.0

package/dist/{chunk-AFM2ULJH.cjs → chunk-J7FHVZII.cjs}

@@ -5,10 +5,10 @@
 
 
 
-var _chunkOE6WK2Y2cjs = require('./chunk-OE6WK2Y2.cjs');
 
 
 
+var _chunkSGLEQVJHcjs = require('./chunk-SGLEQVJH.cjs');
 
 
 
@@ -16,18 +16,18 @@ var _chunkOE6WK2Y2cjs = require('./chunk-OE6WK2Y2.cjs');
 
 
 
-var _chunkE3F4AHAHcjs = require('./chunk-E3F4AHAH.cjs');
 
 
 
+var _chunkCGBADIO5cjs = require('./chunk-CGBADIO5.cjs');
 
 
+var _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
 
 
-var _chunkK4ZJUGF4cjs = require('./chunk-K4ZJUGF4.cjs');
 
+var _chunkPM4XJE2Ycjs = require('./chunk-PM4XJE2Y.cjs');
 
-var _chunk6XPTBE7Ycjs = require('./chunk-6XPTBE7Y.cjs');
 
 
 
@@ -51,7 +51,6 @@ var _chunk6XPTBE7Ycjs = require('./chunk-6XPTBE7Y.cjs');
 
 
 
-var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
@@ -59,6 +58,7 @@ var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
+var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
@@ -71,7 +71,89 @@ var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
-var _chunkQ2WGKJNNcjs = require('./chunk-Q2WGKJNN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
+
+// src/generate/context/draw.ts
+var DRAW_METHODS = ["at", "prob", "range", "float"];
+function assertDraw(draw, name = "draw") {
+  const sampler = _chunkS5BKZZGMcjs.assertRecord.call(void 0, draw, name);
+  for (const method of DRAW_METHODS) {
+    _chunkS5BKZZGMcjs.assertFunction.call(void 0, sampler[method], `${name}.${method}`);
+  }
+  return sampler;
+}
+function assertSeedPath(path, name = "draw path") {
+  const steps = _chunkS5BKZZGMcjs.assertArray.call(void 0, path, name);
+  for (let index = 0; index < steps.length; index += 1) {
+    const step = steps[index];
+    if (typeof step !== "string" && !Number.isFinite(step)) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}[${index}] must be a string or a finite number; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, step)}`
+      );
+    }
+  }
+  return steps;
+}
+function drawFrom(rng, path) {
+  const draw = rng.at(...path);
+  if (!(draw >= 0 && draw < 1)) {
+    throw new (0, _chunkS5BKZZGMcjs.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) => _chunkCGBADIO5cjs.includeAt.call(void 0, rng, p, ...prefix, ...path),
+    range: (lo, hi, ...path) => {
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, lo, "range lower bound");
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi, "range upper bound");
+      if (lo > hi) {
+        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+          `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi - lo, "range span", 0);
+      return lo + Math.floor(at2(...path) * (hi - lo + 1));
+    },
+    float: (lo, hi, ...path) => {
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
+      if (lo > hi) {
+        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+          `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
+        );
+      }
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, entry, "vocabulary entry");
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 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, _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, 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 _chunkS5BKZZGMcjs.assertArray.call(void 0, 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) => _nullishCoalesce(byId.get(entry.id), () => ( entry)));
-  const replaced = new Set(builtIn.map((entry) => entry.id));
-  for (const entry of supplied) {
+  const library = _chunkS5BKZZGMcjs.assertArray.call(void 0, builtIn, "builtIn");
+  const extra = supplied === void 0 || supplied === null ? [] : _chunkS5BKZZGMcjs.assertArray.call(void 0, supplied, "supplied");
+  if (extra.length === 0) {
+    return [...library];
+  }
+  const idOf = (entry, index, side) => _chunkS5BKZZGMcjs.assertRecord.call(void 0, entry, `${side}[${index}]`).id;
+  const byId = new Map(extra.map((entry, index) => [idOf(entry, index, "supplied"), entry]));
+  const merged = library.map((entry, index) => _nullishCoalesce(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,33 +439,52 @@ function mergeVocabulary(builtIn, supplied) {
 }
 function vocabularyOfKind(entries, isMaterial) {
   const out = [];
-  for (const entry of entries) {
-    if (isMaterial(entry.material)) {
+  const recognises = _chunkS5BKZZGMcjs.assertFunction.call(void 0, isMaterial, "isMaterial");
+  for (const entry of _chunkS5BKZZGMcjs.assertArray.call(void 0, entries, "entries")) {
+    if (recognises(_chunkS5BKZZGMcjs.assertRecord.call(void 0, entry, "entry").material)) {
       out.push(entry);
     }
   }
   return out;
 }
-function assertVocabulary(entry, label = "vocabulary entry") {
-  _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, entry.genre, GENRES, `${label} genre`);
-  _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _optionalChain([entry, 'access', _2 => _2.provenance, 'optionalAccess', _3 => _3.basis]), PROVENANCE_BASES, `${label} provenance basis`);
-  entry.articulations.forEach((articulation, index) => {
-    _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, articulation, _chunkE3F4AHAHcjs.ARTICULATIONS, `${label} articulations[${index}]`);
+function assertNames(values, allowed, label) {
+  if (!Array.isArray(values)) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${label} must be an array of names; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, values)}`
+    );
+  }
+  values.forEach((value, index) => {
+    _chunkS5BKZZGMcjs.assertOneOf.call(void 0, value, allowed, `${label}[${index}]`);
   });
-  _optionalChain([entry, 'access', _4 => _4.sections, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((section, index) => {
-    _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, section, PUBLIC_SECTIONS, `${label} sections[${index}]`);
-  })]);
-  _optionalChain([entry, 'access', _7 => _7.fitsOver, 'optionalAccess', _8 => _8.forEach, 'call', _9 => _9((quality, index) => {
-    _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, quality, _chunkUADYAYATcjs.chordQualities.call(void 0, ), `${label} fitsOver[${index}]`);
-  })]);
+}
+function assertVocabulary(entry, label = "vocabulary entry") {
+  if (typeof entry !== "object" || entry === null) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${label} must be a dictionary entry; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, entry)}`
+    );
+  }
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, entry.genre, GENRES, `${label} genre`);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _optionalChain([entry, 'access', _2 => _2.provenance, 'optionalAccess', _3 => _3.basis]), PROVENANCE_BASES, `${label} provenance basis`);
+  assertNames(entry.articulations, _chunkS5BKZZGMcjs.ARTICULATIONS, `${label} articulations`);
+  if (entry.sections !== void 0) {
+    assertNames(entry.sections, PUBLIC_SECTIONS, `${label} sections`);
+  }
+  if (entry.fitsOver !== void 0) {
+    assertNames(entry.fitsOver, _chunk3R3QVKY5cjs.chordQualities.call(void 0, ), `${label} fitsOver`);
+  }
   if (entry.ts !== void 0) {
-    _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, entry.ts, `${label} ts`);
+    _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, entry.ts, `${label} ts`);
   }
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, entry.difficulty, 1, 5, `${label} difficulty`);
-  if (entry.tempoRange) {
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, entry.difficulty, 1, 5, `${label} difficulty`);
+  if (entry.tempoRange !== void 0) {
+    if (!Array.isArray(entry.tempoRange) || entry.tempoRange.length !== 2) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${label} tempoRange must be a low and a high tempo; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, entry.tempoRange)}`
+      );
+    }
     const [low, high] = entry.tempoRange;
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, low, Number.MIN_VALUE, 1e3, `${label} tempoRange low`);
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, high, low, 1e3, `${label} tempoRange high`);
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, low, Number.MIN_VALUE, 1e3, `${label} tempoRange low`);
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, high, low, 1e3, `${label} tempoRange high`);
   }
   return entry;
 }
@@ -386,72 +506,53 @@ function atLevel(table, difficulty) {
   return low + (high - low) * (level - lower);
 }
 function assertDifficulty(difficulty, label = "complexity difficulty") {
-  return _chunkQ2WGKJNNcjs.assertRange.call(void 0, difficulty, MIN_DIFFICULTY, MAX_DIFFICULTY, label);
+  return _chunkS5BKZZGMcjs.assertRange.call(void 0, 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);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, bpm, "bpm");
+  if (_chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, bpm, "bpm");
+  _chunkS5BKZZGMcjs.assertFiniteSemitones.call(void 0, semitones);
+  if (_chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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 (0, _chunkQ2WGKJNNcjs.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) => _chunkE3F4AHAHcjs.includeAt.call(void 0, rng, p, ...prefix, ...path),
-    range: (lo, hi, ...path) => {
-      _chunkQ2WGKJNNcjs.assertInteger.call(void 0, lo, "range lower bound");
-      _chunkQ2WGKJNNcjs.assertInteger.call(void 0, hi, "range upper bound");
-      if (lo > hi) {
-        throw new (0, _chunkQ2WGKJNNcjs.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) => {
-      _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
-      _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
-      if (lo > hi) {
-        throw new (0, _chunkQ2WGKJNNcjs.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) {
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, input, "ctx");
+  }
+  if (input === null) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("ctx must be a seed or a generation context; received null");
+  }
   const ctx = typeof input === "number" ? { seed: input } : _nullishCoalesce(input, () => ( { seed: DEFAULT_SEED }));
-  const seed = _chunkQ2WGKJNNcjs.assertInteger.call(void 0, _nullishCoalesce(ctx.seed, () => ( DEFAULT_SEED)), "seed", 0, 4294967295);
+  const seed = _chunkS5BKZZGMcjs.assertInteger.call(void 0, _nullishCoalesce(ctx.seed, () => ( DEFAULT_SEED)), "seed", 0, 4294967295);
   const complexity = _nullishCoalesce(ctx.complexity, () => ( {}));
-  const rhythmic = complexity.rhythmic === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertRange.call(void 0, complexity.rhythmic, 0, 1, "complexity rhythmic");
-  const harmonic = complexity.harmonic === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertRange.call(void 0, complexity.harmonic, 0, 1, "complexity harmonic");
-  const ornament2 = complexity.ornament === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertRange.call(void 0, complexity.ornament, 0, 1, "complexity ornament");
+  const rhythmic = complexity.rhythmic === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertRange.call(void 0, complexity.rhythmic, 0, 1, "complexity rhythmic");
+  const harmonic = complexity.harmonic === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertRange.call(void 0, complexity.harmonic, 0, 1, "complexity harmonic");
+  const ornament2 = complexity.ornament === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertRange.call(void 0, complexity.ornament, 0, 1, "complexity ornament");
   const difficulty = complexity.difficulty === void 0 ? void 0 : assertDifficulty(complexity.difficulty);
-  const bpm = ctx.bpm === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertRange.call(void 0, ctx.bpm, Number.MIN_VALUE, 1e3, "bpm");
-  const algorithmVersion = _chunkE3F4AHAHcjs.resolveAlgorithmVersion.call(void 0, ctx.algorithmVersion);
+  const bpm = ctx.bpm === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertRange.call(void 0, ctx.bpm, Number.MIN_VALUE, 1e3, "bpm");
+  const algorithmVersion = _chunkCGBADIO5cjs.resolveAlgorithmVersion.call(void 0, ctx.algorithmVersion);
   const supplied = ctx.rng;
   const instruments = ctx.instruments;
   const vocabulary = (_nullishCoalesce(ctx.vocabulary, () => ( []))).map(
@@ -465,70 +566,109 @@ function resolveContext(input) {
     difficulty,
     bpm,
     algorithmVersion,
-    instrument: (part) => _optionalChain([instruments, 'optionalAccess', _10 => _10[part]]),
+    instrument: (part) => _optionalChain([instruments, 'optionalAccess', _4 => _4[part]]),
     vocabulary,
-    part: (name) => supplied ? drawsFrom(supplied, name, VERSION_SEGMENT, algorithmVersion) : drawsFrom(_chunkE3F4AHAHcjs.createPositionalRng.call(void 0, _chunkE3F4AHAHcjs.deriveSeed.call(void 0, seed, name, VERSION_SEGMENT, algorithmVersion)))
+    part: (name) => supplied ? drawsFrom(supplied, name, VERSION_SEGMENT, algorithmVersion) : drawsFrom(_chunkCGBADIO5cjs.createPositionalRng.call(void 0, _chunkCGBADIO5cjs.deriveSeed.call(void 0, seed, name, VERSION_SEGMENT, algorithmVersion)))
   };
 }
 function resolveContextWith(input, sugar) {
   const base = resolveContext(input);
-  const ornament2 = _nullishCoalesce(base.ornament, () => ( (sugar.ornament === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertRange.call(void 0, sugar.ornament, 0, 1, "complexity ornament"))));
+  const supplied = sugar.ornament === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertRange.call(void 0, sugar.ornament, 0, 1, "complexity ornament");
+  const ornament2 = _nullishCoalesce(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 + _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pc - low);
+}
+function barTiles(startBeat, endBeat, ts) {
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
+  const tiles = [];
+  for (let index = 0; ; index += 1) {
+    const tileStart = startBeat + index * barBeats;
+    if (tileStart >= endBeat - _chunkS5BKZZGMcjs.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 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts);
+  return barStart + Math.floor((_chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts) / 2 + _chunkS5BKZZGMcjs.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;
+    }
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
+    if (segment.endBeat <= segment.startBeat) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`segments[${index}] must have a positive duration`);
+    }
+    const previous = segments[index - 1];
+    if (previous !== void 0 && segment.startBeat < previous.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `bass segments must not overlap: segments ${index - 1} and ${index} overlap`
+      );
+    }
   }
-  return midi;
 }
 function chordTonePcs(chord) {
   const seen = /* @__PURE__ */ new Set();
   const pcs = [];
   for (const interval of chord.intervals) {
-    const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + interval);
+    const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc + interval);
     if (!seen.has(pc)) {
       seen.add(pc);
       pcs.push(pc);
     }
   }
   if (pcs.length === 0) {
-    pcs.push(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc));
+    pcs.push(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc));
   }
   return pcs;
 }
-function fifthPcOf(chord) {
-  const fifths = new Set(chord.intervals.map((i) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, i)));
-  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : void 0;
-  return chosen === void 0 ? _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc) : _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc + chosen);
+function fifthPcOf2(chord) {
+  return _nullishCoalesce(_chunk3R3QVKY5cjs.fifthPcOf.call(void 0, chord), () => ( _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc)));
 }
 function bassPcOf(chord) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _nullishCoalesce(chord.bassPc, () => ( chord.rootPc)));
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, _nullishCoalesce(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 = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
-  const pulse2 = _chunkK4ZJUGF4cjs.pulseBeats.call(void 0, ts);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
+  const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts);
   const firstBar = Math.floor(start / barBeats);
-  const lastBar = Math.floor((end - EPS) / barBeats);
+  const lastBar = Math.floor((end - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.BEAT_EPS || position >= end - _chunkS5BKZZGMcjs.BEAT_EPS) {
         break;
       }
-      if (position >= start - EPS) {
+      if (position >= start - _chunkS5BKZZGMcjs.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 = _chunkE3F4AHAHcjs.instrumentRange.call(void 0, instrument);
-  let floor = low;
-  while (floor + 12 > range.high) {
-    floor -= 12;
-  }
-  while (floor < range.low) {
-    floor += 12;
-  }
-  return floor;
+  const range = _chunkCGBADIO5cjs.instrumentRange.call(void 0, instrument);
+  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 = _chunkUADYAYATcjs.nearestScaleTone.call(void 0, target + dir * 2, key);
+  const cand = _chunk3R3QVKY5cjs.nearestScaleTone.call(void 0, 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 : _chunkCGBADIO5cjs.toStringedProfile.call(void 0, 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) {
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, events, "figure events");
+  events.forEach((event, index) => {
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, event, `figure events[${index}]`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, event.step, `figure events[${index}].step`);
+  });
+  return events;
+}
+function assertSpanSteps(spanSteps) {
+  return _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, spanSteps, "figure span steps");
+}
 function streamOf(event) {
   return _nullishCoalesce(_nullishCoalesce(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;
-  }
-  return 0;
-}
-function thin(events, amount) {
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, amount, 0, 1, "thin amount");
+var FIGURE_TS = { numerator: 4, denominator: 4 };
+function subdivisionBeats(ts) {
+  const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts);
+  return _chunkS5BKZZGMcjs.isCompound.call(void 0, ts) ? pulse2 / 3 : pulse2 / 2;
+}
+function gridMetricWeight(step, ts) {
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, step, "step");
+  return stepWeight(step, _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts")));
+}
+function stepWeight(step, ts) {
+  const beats = step * STEP_BEATS;
+  const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, beats, ts);
+  if (weight > 0) {
+    return weight + 1;
+  }
+  const subdivision = subdivisionBeats(ts);
+  const divisions = beats / subdivision;
+  return Math.abs(divisions - Math.round(divisions)) < 1e-9 ? 1 : 0;
+}
+function thin(events, amount, ts) {
+  const figure = assertGridEvents(events);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, amount, 0, 1, "thin amount");
+  const signature = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, 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];
@@ -610,7 +768,7 @@ function double(events, spanSteps = BAR_STEPS) {
       continue;
     }
     out.push(event);
-    const next = _nullishCoalesce(_optionalChain([sorted, 'access', _11 => _11[i + 1], 'optionalAccess', _12 => _12.step]), () => ( spanSteps));
+    const next = _nullishCoalesce(_optionalChain([sorted, 'access', _5 => _5[i + 1], 'optionalAccess', _6 => _6.step]), () => ( spanSteps));
     const mid = event.step + (next - event.step) / 2;
     if (Number.isInteger(mid) && mid > event.step && mid < spanSteps) {
       out.push({ ...event, step: mid, velocity: event.velocity * ADDED_NOTE_VELOCITY });
@@ -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) {
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, 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 : _chunkS5BKZZGMcjs.assertRecord.call(void 0, amount, "amount");
+  const dial = asked === void 0 ? amount : asked.amount;
+  const signature = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(_optionalChain([asked, 'optionalAccess', _7 => _7.ts]), () => ( FIGURE_TS)), "ts"));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, 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) {
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, amount, 0, 1, "ornament amount");
-  return events.filter(
-    (event) => !isOrnament(event) || draw.prob(amount, ...path, "ornament", event.step)
+  const figure = assertGridEvents(events);
+  const marks = _chunkS5BKZZGMcjs.assertFunction.call(void 0, isOrnament, "isOrnament");
+  const sampler = assertDraw(draw);
+  assertSeedPath(path);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, amount, 0, 1, "ornament amount");
+  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 = _nullishCoalesce(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 = _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.rhythmic, 0, 1, "complexity rhythmic");
+  const figure = assertGridEvents(events);
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  assertDraw(draw);
+  assertSeedPath(path);
+  const spanSteps = assertSpanSteps(asked.spanSteps === void 0 ? BAR_STEPS : asked.spanSteps);
+  const ts = _nullishCoalesce(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 = _chunkS5BKZZGMcjs.assertRange.call(void 0, 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 = _chunkS5BKZZGMcjs.assertFunction.call(void 0, 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;
+  }
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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 _chunkPM4XJE2Ycjs.chordScales.call(void 0, chord)) {
+    const mask = _chunk3R3QVKY5cjs.namedScaleMask.call(void 0, 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) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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 = _nullishCoalesce(MAJOR_DEGREE_SEMITONES[within - 1], () => ( 0));
+  const semitone = alter !== 0 ? template : _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(chordDegreeSemitone(within, chord), () => ( replacedDegreeSemitone(within, chord))), () => ( _optionalChain([implied, 'optionalAccess', _8 => _8[within - 1]]))), () => ( // A degree neither the chord nor its quality settles is a passing tone,
+  // so the key decides it.
+  _chunk3R3QVKY5cjs.nearestScaleTone.call(void 0, chord.rootPc + template, key) - chord.rootPc));
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, semitone) + 12 * octaves + alter;
+}
+function chordDegreeSemitone(degree, chord) {
+  for (const interval of chord.intervals) {
+    if (_chunk3R3QVKY5cjs.degreeOfInterval.call(void 0, 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 = _nullishCoalesce(MAJOR_DEGREE_SEMITONES[within - 1], () => ( 0));
-  const semitone = _nullishCoalesce(fromChord, () => ( // A degree the chord does not name is a passing tone, so the key decides it.
-  _chunkUADYAYATcjs.nearestScaleTone.call(void 0, chord.rootPc + template, key) - chord.rootPc));
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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) {
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, timeline.length, "lick segments", opts.budget);
-  const genre = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.genre, GENRES, "lick genre");
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts, "lick time signature");
-  const octave = _nullishCoalesce(opts.octave, () => ( DEFAULT_OCTAVE));
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, octave, "lick octave", -1, 8);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const segments = timeline.map((segment) => ({ ...segment, chord: _chunkUADYAYATcjs.toChordData.call(void 0, segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
-  for (const segment of segments) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, segment.startBeat, 0, Number.MAX_SAFE_INTEGER, "lick segment startBeat");
-    if (segment.endBeat <= segment.startBeat) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `lick segment at beat ${segment.startBeat} must have a positive duration`
-      );
-    }
-  }
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  const placement = _chunkS5BKZZGMcjs.assertArray.call(void 0, 
+    timeline,
+    "timeline"
+  );
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, placement.length, "lick segments", asked.budget);
+  const genre = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, asked.genre, GENRES, "lick genre");
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS)), "ts"));
+  const octave = _nullishCoalesce(asked.octave, () => ( DEFAULT_OCTAVE));
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, octave, "lick octave", -1, 8);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
+  const segments = placement.map((segment) => ({ ...segment, chord: _chunk3R3QVKY5cjs.toChordData.call(void 0, segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
+  assertBassSegments(segments);
   if (segments.length === 0) {
     return [];
   }
-  const resolved = resolveContext(opts.ctx);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
+  const estimatedBars = segments.reduce(
+    (count, segment) => count + Math.max(1, Math.ceil((segment.endBeat - segment.startBeat) / barBeats)),
+    0
+  );
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, estimatedBars, "lick bars", asked.budget);
+  const resolved = resolveContext(asked.ctx);
   const draw = resolved.part("bass");
   const bpm = _nullishCoalesce(resolved.bpm, () => ( DEFAULT_BPM));
   const density = _nullishCoalesce(resolved.rhythmic, () => ( DEFAULT_LICK_DENSITY));
-  const difficulty = _nullishCoalesce(resolved.difficulty, () => ( (opts.difficulty === void 0 ? void 0 : assertDifficulty(opts.difficulty, "lick difficulty"))));
-  const named = resolved.instrument("bass");
-  const instrument = _nullishCoalesce(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 = _nullishCoalesce(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 = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, 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 = _nullishCoalesce(_optionalChain([tiles, 'access', _9 => _9[tile], 'optionalAccess', _10 => _10.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,30 +1240,36 @@ 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(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, segment.chord.rootPc), rootAnchor, low);
+        const figureRoot = segment.chord.bassPc === void 0 ? placePc(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, segment.chord.rootPc), rootMidi, low) : placeAboveBass(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, segment.chord.rootPc), rootMidi);
         for (const lickNote of notes) {
           const at2 = tileStart + lickNote.step * STEP_BEATS;
-          const offset = degreeSemitone(lickNote.degree, _nullishCoalesce(lickNote.alter, () => ( 0)), segment.chord, scale);
-          anchor = figureRoot + offset;
-          onsets.push(at2);
+          const offset = degreeSemitone(
+            lickNote.degree,
+            _nullishCoalesce(lickNote.alter, () => ( 0)),
+            segment.chord,
+            scale,
+            implied
+          );
+          const pitch = Math.abs(at2 - rootAt) < _chunkS5BKZZGMcjs.BEAT_EPS && lickNote.degree === 1 && (_nullishCoalesce(lickNote.alter, () => ( 0))) === 0 ? rootMidi : figureRoot + offset;
           raw.push({
             startBeat: at2,
-            pitch: anchor,
+            pitch,
             velocity: Math.round(
-              (_chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, at2, ts) ? STRONG_VELOCITY : WEAK_VELOCITY) * lickNote.velocity
+              (_chunkS5BKZZGMcjs.isStrongBeat.call(void 0, at2, ts) ? STRONG_VELOCITY : WEAK_VELOCITY) * lickNote.velocity
             ),
             note: lickNote
           });
@@ -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 = _nullishCoalesce(materialOnsetIn(playedTile, lastBeat, next.startBeat), () => ( lastBeat));
+      if (approachAt > firstOnset + _chunkS5BKZZGMcjs.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;
+          }
+        }
       }
     }
   }
@@ -1072,29 +1304,61 @@ function placeLicks(timeline, key, opts) {
     if (!item) {
       continue;
     }
-    const nextStart = _nullishCoalesce(_optionalChain([raw, 'access', _13 => _13[i + 1], 'optionalAccess', _14 => _14.startBeat]), () => ( lastEnd));
-    const written = _optionalChain([item, 'access', _15 => _15.note, 'optionalAccess', _16 => _16.lengthSteps]);
+    const nextStart = _nullishCoalesce(_optionalChain([raw, 'access', _11 => _11[i + 1], 'optionalAccess', _12 => _12.startBeat]), () => ( lastEnd));
+    const written = _optionalChain([item, 'access', _13 => _13.note, 'optionalAccess', _14 => _14.lengthSteps]);
     const durationBeat = Math.min(
       nextStart - item.startBeat,
       written === void 0 ? Number.POSITIVE_INFINITY : written * STEP_BEATS
     );
-    if (durationBeat <= EPS2) {
+    if (durationBeat <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
-    const placed = instrument ? _chunkE3F4AHAHcjs.foldIntoRange.call(void 0, item.pitch, instrument) : item.pitch;
+    const placed = instrument ? _chunkCGBADIO5cjs.foldIntoRange.call(void 0, item.pitch, instrument) : item.pitch;
     const event = {
-      pitch: _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, placed, "generated bass pitch"),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, placed, "generated bass pitch"),
       startBeat: item.startBeat,
       durationBeat,
       velocity: Math.max(1, Math.min(127, item.velocity))
     };
-    if (_optionalChain([item, 'access', _17 => _17.note, 'optionalAccess', _18 => _18.articulation])) {
+    if (_optionalChain([item, 'access', _15 => _15.note, 'optionalAccess', _16 => _16.articulation])) {
       event.articulation = item.note.articulation;
     }
     out.push(event);
   }
   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) < _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.BEAT_EPS || at2 > to - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.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 ? _chunkCGBADIO5cjs.foldIntoRange.call(void 0, 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 = _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, 
-    _nullishCoalesce(midiOverride, () => ( placePc(pc, ctx.prevMidi, ctx.low))),
-    "generated bass pitch"
-  );
-  const midi = ctx.instrument ? _chunkE3F4AHAHcjs.foldIntoRange.call(void 0, placed, ctx.instrument) : placed;
-  const velocity = _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, pos, ctx.ts) ? STRONG_VELOCITY : WEAK_VELOCITY;
+  const placed = _chunkS5BKZZGMcjs.clampToMidi.call(void 0, _nullishCoalesce(midiOverride, () => ( placeTone(ctx, pc))), "generated bass pitch");
+  const midi = sounding(ctx, placed);
+  const velocity = _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, 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 + _chunkS5BKZZGMcjs.BEAT_EPS && answer < tile.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      emit(ctx, answer, fifthPcOf2(seg.chord));
+    }
   }
 }
 function buildPop(ctx, seg, index) {
@@ -1169,102 +1441,102 @@ function buildPop(ctx, seg, index) {
   const rootPc = bassPcOf(seg.chord);
   let emitted = false;
   for (const pos of positions) {
-    if (_chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, pos, ctx.ts)) {
-      ctx.prevMidi = emit(ctx, pos, rootPc);
+    if (_chunkS5BKZZGMcjs.isStrongBeat.call(void 0, pos, ctx.ts)) {
+      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];
   const available = previous === void 0 ? Number.POSITIVE_INFINITY : pos - previous.startBeat;
   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 = _nullishCoalesce(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, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, midi), midi);
+      emit(ctx, pos, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, midi), midi);
       return;
     }
     const pc = _nullishCoalesce(tones[i % tones.length], () => ( bassPcOf(seg.chord)));
-    ctx.prevMidi = emit(ctx, pos, pc);
+    emit(ctx, pos, pc);
   });
 }
 function generateBassLine(opts) {
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 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;
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
-    if (segment.endBeat <= segment.startBeat) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`segments[${index}] must have a positive duration`);
-    }
-  }
-  const segments = opts.segments.map((segment) => ({ ...segment, chord: _chunkUADYAYATcjs.toChordData.call(void 0, 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 (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-        `bass segments must not overlap: segments ${index - 1} and ${index} overlap`
-      );
-    }
-  }
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "bass line options");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, opts.segments, "bass segments");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, opts.segments.length, "bass segments", opts.budget);
+  const segments = opts.segments.map((segment) => ({ ...segment, chord: _chunk3R3QVKY5cjs.toChordData.call(void 0, segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
+  assertBassSegments(segments);
   if (segments.length === 0) {
     return [];
   }
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS2));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  const style = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.style, () => ( DEFAULT_STYLE)), BASS_STYLES, "bass style");
-  const octave = _nullishCoalesce(opts.octave, () => ( DEFAULT_OCTAVE2));
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, octave, "bass octave", -1, 8);
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS)), "ts"));
+  const style = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.style, () => ( DEFAULT_STYLE)), BASS_STYLES, "bass style");
+  const octave = _nullishCoalesce(opts.octave, () => ( DEFAULT_OCTAVE));
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, octave, "bass octave", -1, 8);
   const estimatedNotes = segments.reduce(
     (count, segment) => count + Math.max(1, Math.ceil(segment.endBeat - segment.startBeat)),
     0
   );
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, estimatedNotes, "bass notes", opts.budget);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, estimatedNotes, "bass notes", opts.budget);
   const resolved = resolveContext(opts.ctx);
-  const named = resolved.instrument("bass");
-  const instrument = _nullishCoalesce(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: _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key),
+    key: _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key),
     draw: resolved.part("bass"),
     notes: [],
+    rootMidi: low,
+    overBass: false,
     prevMidi: low,
     instrument,
     pickupDensity: _nullishCoalesce(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);
@@ -1302,13 +1576,13 @@ function generateBassLine(opts) {
     if (!note2) {
       continue;
     }
-    const nextStart = _nullishCoalesce(_optionalChain([ctx, 'access', _19 => _19.notes, 'access', _20 => _20[i + 1], 'optionalAccess', _21 => _21.startBeat]), () => ( lastEnd));
+    const nextStart = _nullishCoalesce(_optionalChain([ctx, 'access', _17 => _17.notes, 'access', _18 => _18[i + 1], 'optionalAccess', _19 => _19.startBeat]), () => ( lastEnd));
     const durationBeat = nextStart - note2.startBeat;
-    if (durationBeat <= EPS) {
+    if (durationBeat <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
     out.push({
-      pitch: _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, note2.pitch, "generated bass pitch"),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, note2.pitch, "generated bass pitch"),
       startBeat: note2.startBeat,
       durationBeat,
       velocity: note2.velocity
@@ -1325,32 +1599,33 @@ function degreesOf(interval) {
 }
 function assertPlayable(pitch) {
   if (pitch < 0 || pitch > 127) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`imitated pitch ${pitch} is outside the MIDI range 0..127`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`imitated pitch ${pitch} is outside the MIDI range 0..127`);
   }
   return pitch;
 }
 function imitate(lead, opts) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, lead, "imitate lead", { allowNonPositiveDuration: true });
-  _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, opts.atBeat, "atBeat");
-  const interval = _chunkQ2WGKJNNcjs.toSpelledInterval.call(void 0, opts.interval);
-  const key = _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key);
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, lead, "imitate lead", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, opts.atBeat, "atBeat");
+  const interval = _chunkS5BKZZGMcjs.toSpelledInterval.call(void 0, opts.interval);
+  const key = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key);
   const from = _nullishCoalesce(opts.from, () => ( Number.NEGATIVE_INFINITY));
   const to = _nullishCoalesce(opts.to, () => ( Number.POSITIVE_INFINITY));
   if (opts.from !== void 0) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, opts.from, "from");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, opts.from, "from");
   }
   if (opts.to !== void 0) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, opts.to, "to");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, opts.to, "to");
   }
   if (from > to) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`imitate needs from <= to; received ${from} > ${to}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`imitate needs from <= to; received ${from} > ${to}`);
   }
   const velocityScale = _nullishCoalesce(opts.velocityScale, () => ( 1));
-  _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, velocityScale, "velocityScale");
-  const tonal = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.answer, () => ( "real")), IMITATION_ANSWERS, "imitate answer") === "tonal";
-  const subject = _chunkQ2WGKJNNcjs.dropSilentNotes.call(void 0, lead).filter((note2) => note2.startBeat >= from && note2.startBeat < to).sort((a, b) => a.startBeat - b.startBeat);
-  const origin = _optionalChain([subject, 'access', _22 => _22[0], 'optionalAccess', _23 => _23.startBeat]);
-  const pivot = _optionalChain([subject, 'access', _24 => _24[0], 'optionalAccess', _25 => _25.pitch]);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, velocityScale, "velocityScale");
+  const tonal = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.answer, () => ( "real")), IMITATION_ANSWERS, "imitate answer") === "tonal";
+  const subject = _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, lead).filter((note2) => note2.startBeat >= from && note2.startBeat < to).sort((a, b) => a.startBeat - b.startBeat);
+  const origin = _optionalChain([subject, 'access', _20 => _20[0], 'optionalAccess', _21 => _21.startBeat]);
+  const pivot = _optionalChain([subject, 'access', _22 => _22[0], 'optionalAccess', _23 => _23.pitch]);
   if (origin === void 0 || pivot === void 0) {
     return [];
   }
@@ -1362,18 +1637,18 @@ function imitate(lead, opts) {
     let offset = 0;
     if (invert) {
       if (tonal) {
-        const here = _chunkUADYAYATcjs.scaleLadderPosition.call(void 0, pitch, key);
-        pitch = _chunkUADYAYATcjs.scaleLadderPitch.call(void 0, 2 * _chunkUADYAYATcjs.scaleLadderPosition.call(void 0, pivot, key).rung - here.rung, key);
+        const here = _chunk3R3QVKY5cjs.scaleLadderPosition.call(void 0, pitch, key);
+        pitch = _chunk3R3QVKY5cjs.scaleLadderPitch.call(void 0, 2 * _chunk3R3QVKY5cjs.scaleLadderPosition.call(void 0, pivot, key).rung - here.rung, key);
         offset = -here.offset;
       } else {
         pitch = 2 * pivot - pitch;
       }
     }
-    pitch = tonal ? _chunkUADYAYATcjs.shiftByScaleDegrees.call(void 0, pitch, degrees, key) + offset : pitch + Math.round(interval.semitones);
+    pitch = tonal ? _chunk3R3QVKY5cjs.shiftByScaleDegrees.call(void 0, 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,10 +1669,10 @@ 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)) < _chunkS5BKZZGMcjs.BEAT_EPS;
 }
 function melodyNoteAt(melody, beat) {
-  return _optionalChain([melody, 'access', _26 => _26.at, 'call', _27 => _27(beat), 'optionalAccess', _28 => _28.note]);
+  return _optionalChain([melody, 'access', _24 => _24.at, 'call', _25 => _25(beat), 'optionalAccess', _26 => _26.note]);
 }
 function melodyAttacksAt(melody, beat) {
   return melody.attacksAt(beat);
@@ -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) < _chunkS5BKZZGMcjs.BEAT_EPS;
+  const previous = attacked ? melodyNoteAt(melody, beat - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.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 (_chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, beat, ts)) {
+    } else if (_chunkS5BKZZGMcjs.isStrongBeat.call(void 0, beat, ts)) {
       place = draw.prob(REINFORCE_PROB, "reinforce", beat);
     }
-    if (place && beat - last >= MIN_ONSET_GAP - EPS3) {
+    if (place && beat - last >= MIN_ONSET_GAP - _chunkS5BKZZGMcjs.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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `countermelody weights must be an object of weight overrides; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, overrides)}`
+    );
+  }
+  for (const [field, value] of Object.entries(overrides)) {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, 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;
@@ -1463,7 +1751,7 @@ function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weig
       score += weights.dissonance;
     }
   }
-  if (chord && _chunkUADYAYATcjs.chordToneRole.call(void 0, pitch, chord) !== null) {
+  if (chord && _chunk3R3QVKY5cjs.chordToneRole.call(void 0, pitch, chord) !== null) {
     score += weights.chordTone;
   }
   if (prevPitch !== void 0) {
@@ -1473,7 +1761,7 @@ function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weig
     if (dist > 0 && dist <= 2) {
       score += weights.stepwise;
     }
-    if (_chunkUADYAYATcjs.isForbiddenMelodicLeap.call(void 0, prevPitch, pitch)) {
+    if (_chunk3R3QVKY5cjs.isForbiddenMelodicLeap.call(void 0, prevPitch, pitch)) {
       score += weights.forbiddenLeap;
     }
     if (melPitch !== void 0 && melPrev !== void 0 && ic !== void 0) {
@@ -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 + _chunkS5BKZZGMcjs.BEAT_EPS && beat < endBeat - _chunkS5BKZZGMcjs.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 - _chunkS5BKZZGMcjs.BEAT_EPS; beat += GRID_STEP) {
     boundaries.add(beat);
   }
   return [...boundaries].sort((a, b) => a - b);
@@ -1516,8 +1804,8 @@ function boundaryContexts(melody, harmony, startBeat, endBeat, ts) {
       melodyVoice,
       otherVoices: melodyVoice === void 0 ? [] : [melodyVoice],
       chord: harmony.chordAt(boundary),
-      strongBeat: _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, boundary, ts),
-      atCounterOnset: Math.abs(boundary - startBeat) < EPS3
+      strongBeat: _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, boundary, ts),
+      atCounterOnset: Math.abs(boundary - startBeat) < _chunkS5BKZZGMcjs.BEAT_EPS
     };
   });
 }
@@ -1528,7 +1816,7 @@ function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low
     if (melodyVoice !== void 0 && (register === "below" && pitch >= melodyVoice.pitch || register === "above" && pitch <= melodyVoice.pitch)) {
       return null;
     }
-    const result = _chunkUADYAYATcjs.evaluateSafety.call(void 0, 
+    const result = _chunk3R3QVKY5cjs.evaluateSafety.call(void 0, 
       {
         profile,
         candidatePitch: pitch,
@@ -1550,49 +1838,51 @@ function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low
   return worst;
 }
 function generateCounterMelody(opts) {
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "countermelody options");
   const timeline = opts.timeline;
   const chordAt = timeline === void 0 ? opts.chordAt : (beat) => timeline.at(beat);
   if (chordAt === void 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("countermelody needs a timeline or a chordAt callback");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("countermelody needs a timeline or a chordAt callback");
   }
   const chordChangeBeats = timeline === void 0 ? _nullishCoalesce(opts.chordChangeBeats, () => ( [])) : timeline.segments.flatMap((segment) => [segment.startBeat, segment.endBeat]);
   const register = _nullishCoalesce(opts.register, () => ( "below"));
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, opts.melody, "countermelody melody", { allowNonPositiveDuration: true });
-  const melody = _chunkK4ZJUGF4cjs.createNoteEventIndex.call(void 0, _chunkQ2WGKJNNcjs.soundingNotesOnly.call(void 0, opts.melody), {
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, opts.melody, "countermelody melody", { allowNonPositiveDuration: true });
+  const melody = _chunk35NBV2FTcjs.createNoteEventIndex.call(void 0, _chunkS5BKZZGMcjs.soundingNotesOnly.call(void 0, opts.melody), {
     tieBreak: register === "below" ? "highest" : "lowest"
   });
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS3));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  const rhythm = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.rhythm, () => ( "complement")), ["complement", "follow"], "rhythm");
-  const profile = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.profile, () => ( "pop")), ["strict", "pop"], "safety profile");
-  const weights = _chunkUADYAYATcjs.profileWeights.call(void 0, profile, opts.weights);
-  const key = _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key);
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS2)), "ts"));
+  _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, ts);
+  const rhythm = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.rhythm, () => ( "complement")), ["complement", "follow"], "rhythm");
+  const profile = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.profile, () => ( "pop")), ["strict", "pop"], "safety profile");
+  assertWeightOverrides(opts.weights);
+  const weights = _chunk3R3QVKY5cjs.profileWeights.call(void 0, profile, opts.weights);
+  const key = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key);
   const draw = resolveContext(opts.ctx).part("countermelody");
   if (melody.notes.length === 0) {
     return [];
   }
-  const spanStart = _nullishCoalesce(_optionalChain([melody, 'access', _29 => _29.notes, 'access', _30 => _30[0], 'optionalAccess', _31 => _31.note, 'access', _32 => _32.startBeat]), () => ( 0));
+  const spanStart = _nullishCoalesce(_optionalChain([melody, 'access', _27 => _27.notes, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.note, 'access', _30 => _30.startBeat]), () => ( 0));
   const spanEnd = melody.notes.reduce((end, n) => Math.max(end, n.endBeat), spanStart);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, Math.ceil((spanEnd - spanStart) / GRID_STEP), "countermelody grid");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, Math.ceil((spanEnd - spanStart) / GRID_STEP), "countermelody grid");
   const meanPitch = melody.notes.reduce((sum, n) => sum + n.note.pitch, 0) / melody.notes.length;
   const defaultCenter = register === "below" ? meanPitch - REGISTER_OFFSET : meanPitch + REGISTER_OFFSET;
-  const low = _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, 
+  const low = _chunkS5BKZZGMcjs.clampToMidi.call(void 0, 
     _nullishCoalesce(opts.pitchLow, () => ( Math.round(defaultCenter) - DEFAULT_HALF_RANGE)),
     "countermelody pitchLow"
   );
-  const high = _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, 
+  const high = _chunkS5BKZZGMcjs.clampToMidi.call(void 0, 
     _nullishCoalesce(opts.pitchHigh, () => ( Math.round(defaultCenter) + DEFAULT_HALF_RANGE)),
     "countermelody pitchHigh"
   );
   if (low > high) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
       `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
     );
   }
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, high - low + 1, "countermelody pitch candidates");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, chordChangeBeats.length, "chord change beats");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, high - low + 1, "countermelody pitch candidates");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, chordChangeBeats.length, "chord change beats");
   for (let index = 0; index < chordChangeBeats.length; index += 1) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, 
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
       _nullishCoalesce(chordChangeBeats[index], () => ( Number.NaN)),
       0,
       Number.MAX_SAFE_INTEGER,
@@ -1602,7 +1892,7 @@ function generateCounterMelody(opts) {
   const center = (low + high) / 2;
   const onsets = rhythm === "follow" ? followOnsets(melody) : complementOnsets(melody, ts, spanStart, spanEnd, draw);
   const boundaryEstimate = onsets.length + Math.ceil((spanEnd - spanStart) / GRID_STEP) + melody.notes.length + chordChangeBeats.length;
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, boundaryEstimate * (high - low + 1), "countermelody search");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, boundaryEstimate * (high - low + 1), "countermelody search");
   const jitter = Array.from(
     { length: high - low + 1 },
     (_, index) => draw.at("jitter", index) * TIE_BREAK_JITTER
@@ -1617,20 +1907,20 @@ function generateCounterMelody(opts) {
     const nextOnset = onsets[onsetIndex + 1];
     const endBeat = _nullishCoalesce(nextOnset, () => ( Math.max(spanEnd, beat + GRID_STEP)));
     const melNote = melodyNoteAt(melody, beat);
-    const melPitch = _optionalChain([melNote, 'optionalAccess', _33 => _33.pitch]);
+    const melPitch = _optionalChain([melNote, 'optionalAccess', _31 => _31.pitch]);
     const melodyVoice = melodySnapshotAt(melody, beat);
-    const melPrev = _optionalChain([melodyVoice, 'optionalAccess', _34 => _34.prevPitch]);
+    const melPrev = _optionalChain([melodyVoice, 'optionalAccess', _32 => _32.prevPitch]);
     const contexts = boundaryContexts(melody, { chordAt, chordChangeBeats }, beat, endBeat, ts);
-    const chord = _nullishCoalesce(_optionalChain([contexts, 'access', _35 => _35[0], 'optionalAccess', _36 => _36.chord]), () => ( chordAt(beat)));
+    const chord = _nullishCoalesce(_optionalChain([contexts, 'access', _33 => _33[0], 'optionalAccess', _34 => _34.chord]), () => ( chordAt(beat)));
     const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
-    const candidates = _chunkUADYAYATcjs.enumerateSafePitches.call(void 0, 
+    const candidates = _chunk3R3QVKY5cjs.enumerateSafePitches.call(void 0, 
       {
         profile,
         prevPitch,
         chord,
         key,
         otherVoices,
-        strongBeat: _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, beat, ts),
+        strongBeat: _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, beat, ts),
         vocalLow: low,
         vocalHigh: high
       },
@@ -1657,13 +1947,13 @@ function generateCounterMelody(opts) {
       if (melPitch !== void 0) {
         if (prevPitch !== void 0 && melPrev !== void 0 && // Parallel octaves are the perfect-class-zero case of this predicate,
         // so a single check covers both parallel fifths and octaves.
-        _chunkUADYAYATcjs.createsParallelPerfect.call(void 0, prevPitch, candidate, melPrev, melPitch)) {
+        _chunk3R3QVKY5cjs.createsParallelPerfect.call(void 0, prevPitch, candidate, melPrev, melPitch)) {
           continue;
         }
       }
       const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center, weights) + (_nullishCoalesce(jitter[candidate - low], () => ( 0)));
-      const tie = Math.abs(score - bestScore) <= EPS3 && candidate < (_nullishCoalesce(bestPitch, () => ( Number.POSITIVE_INFINITY)));
-      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + EPS3 || tie)) {
+      const tie = Math.abs(score - bestScore) <= SCORE_EPS && candidate < (_nullishCoalesce(bestPitch, () => ( Number.POSITIVE_INFINITY)));
+      if (worstSafety < bestWorstSafety || worstSafety === bestWorstSafety && (score > bestScore + SCORE_EPS || tie)) {
         bestWorstSafety = worstSafety;
         bestScore = score;
         bestPitch = candidate;
@@ -1676,10 +1966,10 @@ function generateCounterMelody(opts) {
     const pitch = bestPitch;
     const velocity = Math.max(
       1,
-      Math.min(127, Math.round((_nullishCoalesce(_optionalChain([melNote, 'optionalAccess', _37 => _37.velocity]), () => ( DEFAULT_MELODY_VELOCITY))) - VELOCITY_DROP))
+      Math.min(127, Math.round((_nullishCoalesce(_optionalChain([melNote, 'optionalAccess', _35 => _35.velocity]), () => ( DEFAULT_MELODY_VELOCITY))) - VELOCITY_DROP))
     );
     out.push({
-      pitch: _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, pitch),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, pitch),
       startBeat: beat,
       durationBeat: endBeat - beat,
       velocity
@@ -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 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));
+  const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat && !usesOffbeatOpenHiHat(sec.style);
+  const dm = sec.densityMult;
+  if (ctx.hhLevel === "quarter") {
+    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)) {
@@ -2250,10 +2566,10 @@ function generateHiHatForBeat(ctx, sec) {
 
 // src/generate/drums/euclid.ts
 function euclideanRhythm(pulses, steps, rotation = 0) {
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, steps, "euclidean steps");
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, pulses, "euclidean pulses");
-  _chunkQ2WGKJNNcjs.assertInteger.call(void 0, rotation, "euclidean rotation");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, steps, "euclidean pattern steps");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, steps, "euclidean steps");
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, pulses, "euclidean pulses");
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, rotation, "euclidean rotation");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, steps, "euclidean pattern steps");
   const p = Math.max(0, Math.min(pulses, steps));
   const base = bjorklund(p, steps);
   const shift = (rotation % steps + steps) % steps;
@@ -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.
@@ -2423,7 +2739,7 @@ function isFillArchetype(material) {
   return typeof material === "object" && material !== null && Array.isArray(material.atBeat);
 }
 function fillArchetypeFor(id, supplied) {
-  return _nullishCoalesce(_optionalChain([supplied, 'optionalAccess', _38 => _38.get, 'call', _39 => _39(id)]), () => ( FILL_ARCHETYPES[id]));
+  return _nullishCoalesce(_optionalChain([supplied, 'optionalAccess', _36 => _36.get, 'call', _37 => _37(id)]), () => ( FILL_ARCHETYPES[id]));
 }
 function getFillStartBeat(energy) {
   switch (energy) {
@@ -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 + (_nullishCoalesce(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(_chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch));
 }
 var ONSET_KEY_SCALE = 128;
 var HitList = (_class = class {constructor() { _class.prototype.__init.call(this); }
   __init() {this.hits = []}
-  /** Onset keys already occupied, as `pitch:quantizedBeat`. */
-  #onsets = /* @__PURE__ */ new Set();
-  /** Append a hit, clamping velocity and dropping non-positive positions. */
+  /** 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 = class {constructor() { _class.prototype.__init.call(this
       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 _nullishCoalesce(_optionalChain([this, 'access', _38 => _38.#onsets, 'access', _39 => _39.get, 'call', _40 => _40(beatSlot(startBeat)), 'optionalAccess', _41 => _41.has, 'call', _42 => _42(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;
   }
 }, _class);
+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 : _nullishCoalesce(KICK_FIGURES[style], () => ( DEFAULT_FIGURE));
+  const own = _nullishCoalesce(KICK_FIGURES[style], () => ( DEFAULT_FIGURE));
+  const figure = section === "outro" ? [...OUTRO_FIGURE, ...statedSlots(own)] : own;
   return realiseKickFigure(figure, section, bar2, draw, rhythmic);
 }
 
@@ -2759,7 +3111,7 @@ var PERC_TABLE = [
 ];
 function getPercussionConfig(mood, section) {
   const row = _nullishCoalesce(PERC_TABLE[mood], () => ( PERC_TABLE[1 /* Standard */]));
-  const act = _nullishCoalesce(_optionalChain([row, 'optionalAccess', _40 => _40[sectionIndex(section)]]), () => ( F));
+  const act = _nullishCoalesce(_optionalChain([row, 'optionalAccess', _43 => _43[sectionIndex(section)]]), () => ( F));
   return {
     tambourine: act[0],
     shaker: act[1],
@@ -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)) {
@@ -2858,10 +3216,12 @@ var KIT_ARTICULATIONS = Object.freeze([
 var DRUM_KIT = Object.freeze({
   kind: "percussion",
   name: "drum kit",
-  limbs: _chunkE3F4AHAHcjs.LIMBS,
-  reach: Object.freeze(reachByNote()),
+  limbs: _chunkCGBADIO5cjs.LIMBS,
+  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: _chunkCGBADIO5cjs.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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${label} strokes[${index}].voice must name a drum voice; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, _optionalChain([stroke, 'optionalAccess', _44 => _44.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,27 +3425,33 @@ var DEFAULT_VELOCITY = 100;
 var DEFAULT_BPM2 = 120;
 var MAX_STROKES_PER_BAR = 64;
 function placeDrumPattern(opts) {
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, opts.bars, "drum pattern bars");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, opts.bars * MAX_STROKES_PER_BAR, "drum pattern hits", opts.budget);
-  const genre = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.genre, GENRES, "drum pattern genre");
-  const section = opts.section === void 0 ? void 0 : _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum pattern section");
-  const ts = _nullishCoalesce(opts.ts, () => ( FOUR_FOUR2));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts, "drum pattern time signature");
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "drum pattern options");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, opts.bars, "drum pattern bars");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, opts.bars * MAX_STROKES_PER_BAR, "drum pattern hits", opts.budget);
+  const genre = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.genre, GENRES, "drum pattern genre");
+  const section = opts.section === void 0 ? void 0 : _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum pattern section");
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( FOUR_FOUR2)), "ts"));
   if (opts.velocity !== void 0) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.velocity, 1, 127, "drum pattern velocity");
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, opts.velocity, 1, 127, "drum pattern velocity");
   }
-  const feel = opts.feel === void 0 ? "straight" : _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "feel");
+  const feel = opts.feel === void 0 ? "straight" : _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "feel");
   const resolved = resolveContext(opts.ctx);
   const bpm = _nullishCoalesce(resolved.bpm, () => ( DEFAULT_BPM2));
   const draw = resolved.part("drums");
   const baseVelocity = _nullishCoalesce(opts.velocity, () => ( DEFAULT_VELOCITY));
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, 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 (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `drum pattern ts names a meter no figure is written in: ${_chunkS5BKZZGMcjs.formatTimeSignature.call(void 0, 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: _nullishCoalesce(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"),
         _nullishCoalesce(stroke.duration, () => ( STEP_BEATS)),
         baseVelocity * stroke.velocity,
         stroke.articulation
@@ -3131,25 +3514,26 @@ function placeDrumPattern(opts) {
     }
   }
   const endBeat = opts.bars * barBeats;
-  return track.hits.filter((h) => h.startBeat < endBeat && (kit === void 0 || _chunkE3F4AHAHcjs.canSound.call(void 0, kit, h.pitch))).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
+  return track.hits.filter((h) => h.startBeat < endBeat && (kit === void 0 || _chunkCGBADIO5cjs.canSound.call(void 0, kit, h.pitch))).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch);
 }
 
 // src/generate/drums/index.ts
 var MAX_HITS_PER_BAR = 128;
 var DEFAULT_BPM3 = 120;
 function generateDrums(opts) {
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, opts.bars, "drum bars");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, opts.bars * MAX_HITS_PER_BAR, "drum hits", opts.budget);
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "drum options");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, opts.bars, "drum bars");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, opts.bars * MAX_HITS_PER_BAR, "drum hits", opts.budget);
   if (opts.euclideanKick) {
     const steps = _nullishCoalesce(opts.euclideanKick.steps, () => ( 16));
-    _chunkQ2WGKJNNcjs.assertInteger.call(void 0, steps, "euclidean steps", 1, 16);
-    _chunkQ2WGKJNNcjs.assertInteger.call(void 0, opts.euclideanKick.pulses, "euclidean pulses");
-    _chunkQ2WGKJNNcjs.assertInteger.call(void 0, _nullishCoalesce(opts.euclideanKick.rotation, () => ( 0)), "euclidean rotation");
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, steps, "euclidean steps", 1, 16);
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, opts.euclideanKick.pulses, "euclidean pulses");
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, _nullishCoalesce(opts.euclideanKick.rotation, () => ( 0)), "euclidean rotation");
   }
-  const publicStyle = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.style, GROOVE_STYLES, "drum style");
-  const publicSection = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum section");
+  const publicStyle = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.style, GROOVE_STYLES, "drum style");
+  const publicSection = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum section");
   if (opts.nextSection !== void 0) {
-    _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.nextSection, PUBLIC_SECTIONS, "drum nextSection");
+    _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.nextSection, PUBLIC_SECTIONS, "drum nextSection");
   }
   const track = new HitList();
   const resolved = resolveContext(opts.ctx);
@@ -3160,16 +3544,18 @@ function generateDrums(opts) {
   const difficulty = resolved.difficulty;
   const mapping = mapStyle(publicStyle);
   const style = mapping.style;
-  const feel = opts.feel === void 0 ? mapping.feel : _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "drum feel");
-  const role = opts.role === void 0 ? "full" : _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.role, DRUM_ROLES, "drum role");
-  const ts = _nullishCoalesce(opts.ts, () => ( { numerator: 4, denominator: 4 }));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts, "drum time signature");
-  if (ts.numerator !== 4 || ts.denominator !== 4) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-      `drum time signature must be 4/4; received ${ts.numerator}/${ts.denominator}`
-    );
+  const feel = opts.feel === void 0 ? mapping.feel : _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "drum feel");
+  const role = opts.role === void 0 ? "full" : _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.role, DRUM_ROLES, "drum role");
+  const meters = _chunkS5BKZZGMcjs.resolveMeters.call(void 0, { ts: opts.ts }, "ts");
+  for (const change of meters) {
+    if (change.ts.numerator !== 4 || change.ts.denominator !== 4) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `drum time signature must be 4/4 throughout; received ${change.ts.numerator}/${change.ts.denominator} at beat ${change.startBeat}`
+      );
+    }
   }
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, meters);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
   const playMainVoices = role !== "fxOnly";
   const section = mapSection(publicSection);
   const swingAmount = feelSwingAmount(feel);
@@ -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),
@@ -3203,7 +3588,7 @@ function generateDrums(opts) {
   );
   const callerFills = new Map(callerFillEntries.map((entry) => [entry.id, entry.material]));
   const callerFillIds = callerFillEntries.map((entry) => entry.id);
-  const euclidSteps = _nullishCoalesce(_optionalChain([opts, 'access', _41 => _41.euclideanKick, 'optionalAccess', _42 => _42.steps]), () => ( 16));
+  const euclidSteps = _nullishCoalesce(_optionalChain([opts, 'access', _45 => _45.euclideanKick, 'optionalAccess', _46 => _46.steps]), () => ( 16));
   const euclidKick = opts.euclideanKick ? euclideanRhythm(opts.euclideanKick.pulses, euclidSteps, _nullishCoalesce(opts.euclideanKick.rotation, () => ( 0))) : void 0;
   const reuseSectionKick = (section === "b" || section === "chorus") && style !== "sparse";
   let sectionKick;
@@ -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);
         }
       }
@@ -3356,11 +3748,11 @@ function underCeiling(hits, bpm, difficulty, exempt) {
   return kept;
 }
 function playableOn(kit, pitch) {
-  return kit === void 0 || _chunkE3F4AHAHcjs.canSound.call(void 0, kit, pitch);
+  return kit === void 0 || _chunkCGBADIO5cjs.canSound.call(void 0, 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,24 +3763,24 @@ var MAX_METRIC_WEIGHT = 3;
 var MIN_VELOCITY = 1;
 var MAX_VELOCITY = 127;
 function humanize(events, opts = {}) {
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS4));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, events, "humanize events", { allowNonPositiveDuration: true });
-  const sounding = _chunkQ2WGKJNNcjs.dropSilentNotes.call(void 0, events);
-  const timing = _nullishCoalesce(opts.timing, () => ( DEFAULT_TIMING));
-  const velocityJitter = _nullishCoalesce(opts.velocity, () => ( DEFAULT_VELOCITY_JITTER));
-  const accent2 = _nullishCoalesce(opts.accent, () => ( DEFAULT_ACCENT));
-  const baseVelocity = _nullishCoalesce(opts.baseVelocity, () => ( DEFAULT_BASE_VELOCITY));
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, velocityJitter, 0, 127, "humanize velocity jitter");
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, accent2, 0, 127, "humanize accent");
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, baseVelocity, 0, 127, "humanize base velocity");
-  const ctx = resolveContext(opts.ctx);
-  const draw = ctx.part(_nullishCoalesce(opts.part, () => ( DEFAULT_PART)));
-  return sounding.map((event) => {
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS3)), "ts"));
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "humanize events", { allowNonPositiveDuration: true });
+  const sounding2 = _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, events);
+  const timing = _nullishCoalesce(asked.timing, () => ( DEFAULT_TIMING));
+  const velocityJitter = _nullishCoalesce(asked.velocity, () => ( DEFAULT_VELOCITY_JITTER));
+  const accent2 = _nullishCoalesce(asked.accent, () => ( DEFAULT_ACCENT));
+  const baseVelocity = _nullishCoalesce(asked.baseVelocity, () => ( DEFAULT_BASE_VELOCITY));
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, velocityJitter, 0, 127, "humanize velocity jitter");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, accent2, 0, 127, "humanize accent");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, baseVelocity, 0, 127, "humanize base velocity");
+  const ctx = resolveContext(asked.ctx);
+  const draw = ctx.part(_nullishCoalesce(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 = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, event.startBeat, ts);
+    const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, event.startBeat, ts);
     const accentBoost = weight / MAX_METRIC_WEIGHT * accent2;
     const velocityOffset = draw.float(
       -velocityJitter,
@@ -3399,12 +3791,7 @@ function humanize(events, opts = {}) {
     );
     const rawVelocity = (_nullishCoalesce(event.velocity, () => ( baseVelocity))) + accentBoost + velocityOffset;
     const velocity = Math.min(MAX_VELOCITY, Math.max(MIN_VELOCITY, Math.round(rawVelocity)));
-    return {
-      pitch: event.pitch,
-      startBeat,
-      durationBeat: event.durationBeat,
-      velocity
-    };
+    return { ...event, startBeat, velocity };
   });
 }
 function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
@@ -3422,18 +3809,18 @@ function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
   };
 }
 function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVISION) {
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, events, "groove source events", { allowNonPositiveDuration: true });
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, subdivision, "groove subdivision");
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "groove source events", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, subdivision, "groove subdivision");
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, meter);
   const slotsPerBar = Math.ceil(barBeats * subdivision);
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, slotsPerBar, "groove template slots");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, slotsPerBar, "groove template slots");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, slotsPerBar, "groove template slots");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slotsPerBar, "groove template slots");
   const offsetSums = new Array(slotsPerBar).fill(0);
   const velocitySums = new Array(slotsPerBar).fill(0);
   const counts = new Array(slotsPerBar).fill(0);
   const velocityCounts = new Array(slotsPerBar).fill(0);
-  for (const event of _chunkQ2WGKJNNcjs.dropSilentNotes.call(void 0, events)) {
+  for (const event of _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, events)) {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -3460,24 +3847,40 @@ function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVIS
       velocity: velocityCount > 0 ? (_nullishCoalesce(velocitySums[i], () => ( 0))) / velocityCount : null
     });
   }
-  return { subdivision, slotsPerBar, slots, ts };
+  return { subdivision, slotsPerBar, slots, ts: meter };
 }
 function applyGrooveTemplate(events, template, ts) {
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, events, "groove target events", { allowNonPositiveDuration: true });
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, template.subdivision, "template subdivision");
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, template.slotsPerBar, "template slotsPerBar");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, template.slots.length, "template slots");
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, "groove target events", { allowNonPositiveDuration: true });
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, template.subdivision, "template subdivision");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, template.slotsPerBar, "template slotsPerBar");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, template.slots.length, "template slots");
   if (template.slots.length !== template.slotsPerBar) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("template slots length must equal slotsPerBar");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("template slots length must equal slotsPerBar");
+  }
+  if (template.ts && (template.ts.numerator !== meter.numerator || template.ts.denominator !== meter.denominator)) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `Groove template meter ${_chunkS5BKZZGMcjs.formatTimeSignature.call(void 0, template.ts)} does not match apply-time meter ${_chunkS5BKZZGMcjs.formatTimeSignature.call(void 0, meter)}`
+    );
   }
-  if (template.ts && (template.ts.numerator !== ts.numerator || template.ts.denominator !== ts.denominator)) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
-      `Groove template meter ${_chunkK4ZJUGF4cjs.formatTimeSignature.call(void 0, template.ts)} does not match apply-time meter ${_chunkK4ZJUGF4cjs.formatTimeSignature.call(void 0, ts)}`
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, meter);
+  const expectedSlots = Math.ceil(barBeats * template.subdivision);
+  if (template.slotsPerBar !== expectedSlots) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `Groove template slotsPerBar ${template.slotsPerBar} does not match ${expectedSlots} slots per bar of ${_chunkS5BKZZGMcjs.formatTimeSignature.call(void 0, meter)} at subdivision ${template.subdivision}`
     );
   }
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
-  return _chunkQ2WGKJNNcjs.dropSilentNotes.call(void 0, events).map((event) => {
+  for (let index = 0; index < template.slots.length; index += 1) {
+    const slot = template.slots[index];
+    if (slot === void 0) {
+      continue;
+    }
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, slot.timingOffset, `template slots[${index}].timingOffset`);
+    if (slot.velocity !== null && slot.velocity !== void 0) {
+      _chunkS5BKZZGMcjs.assertRange.call(void 0, slot.velocity, 0, 127, `template slots[${index}].velocity`);
+    }
+  }
+  return _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, events).map((event) => {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -3485,22 +3888,16 @@ function applyGrooveTemplate(events, template, ts) {
       template.slotsPerBar
     );
     const slot = template.slots[slotIndex];
-    const startBeat = quantizedBeat + (_nullishCoalesce(_optionalChain([slot, 'optionalAccess', _43 => _43.timingOffset]), () => ( 0)));
+    const startBeat = quantizedBeat + (_nullishCoalesce(_optionalChain([slot, 'optionalAccess', _47 => _47.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) <= _chunkSGLEQVJHcjs.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) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, melody, "melody notes", { allowNonPositiveDuration: true });
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  const pulse2 = _chunkK4ZJUGF4cjs.pulseBeats.call(void 0, ts);
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, melody, "melody notes", { allowNonPositiveDuration: true });
+  const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, 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,12 +3928,12 @@ 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 > _chunkSGLEQVJHcjs.HUMANIZE_ADJACENCY || outOfNote > _chunkSGLEQVJHcjs.HUMANIZE_ADJACENCY) {
     return "structural";
   }
-  const weight = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, snapToPulse(note2.startBeat, pulse2), ts);
-  const weightPrev = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, snapToPulse(prev.startBeat, pulse2), ts);
-  const weightNext = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, snapToPulse(next.startBeat, pulse2), ts);
+  const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, snapToPulse(note2.startBeat, pulse2), ts);
+  const weightPrev = _chunkS5BKZZGMcjs.metricWeight.call(void 0, snapToPulse(prev.startBeat, pulse2), ts);
+  const weightNext = _chunkS5BKZZGMcjs.metricWeight.call(void 0, snapToPulse(next.startBeat, pulse2), ts);
   const subordinate = weight <= weightPrev && weight <= weightNext && note2.durationBeat <= prev.durationBeat && note2.durationBeat <= next.durationBeat;
   const leaning = weight > weightPrev && weight >= weightNext;
   if (leaning && prev.pitch === note2.pitch && note2.pitch - next.pitch >= 1 && isStep(note2.pitch, next.pitch)) {
@@ -3562,63 +3959,44 @@ function roleOfNote(melody, index, ts, pulse2) {
   return "structural";
 }
 
-// src/generate/harmonize/index.ts
+// src/generate/harmonize/internal.ts
 var FALLBACK = {
   rootPc: 0,
   quality: "maj",
   secondaryDominant: false,
   base: 0,
-  pcs: _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, 0, "maj"))
+  pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 0, "maj"))
 };
 function defaultHarmonicRhythm(ts) {
-  const bar2 = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const bar2 = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
   const half = bar2 / 2;
-  return half % _chunkK4ZJUGF4cjs.pulseBeats.call(void 0, ts) === 0 ? half : bar2;
+  return half % _chunkS5BKZZGMcjs.pulseBeats.call(void 0, 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 (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc) + 11) % 12;
+function cadencesThroughRaisedSeventh(key) {
+  return _chunkSGLEQVJHcjs.isMinorKey.call(void 0, key) && _chunk3R3QVKY5cjs.scaleSystemOf.call(void 0, key) === "common-practice";
 }
 function isKeyTone(pitch, key) {
-  return _chunkUADYAYATcjs.isScaleTone.call(void 0, pitch, key) || isMinorKey(key) && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch) === leadingTonePc(key);
+  return _chunk3R3QVKY5cjs.isScaleTone.call(void 0, pitch, key) || cadencesThroughRaisedSeventh(key) && _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch) === _chunk3R3QVKY5cjs.leadingTonePcOf.call(void 0, key);
 }
 function inferKey(melody) {
-  let best = _chunkUADYAYATcjs.majorKey.call(void 0, 0);
+  let best = _chunk3R3QVKY5cjs.majorKey.call(void 0, 0);
   let bestScore = Number.NEGATIVE_INFINITY;
   const candidates = [];
   for (let tonic = 0; tonic < 12; tonic += 1) {
-    candidates.push(_chunkUADYAYATcjs.majorKey.call(void 0, tonic), _chunkUADYAYATcjs.minorKey.call(void 0, tonic));
+    candidates.push(_chunk3R3QVKY5cjs.majorKey.call(void 0, tonic), _chunk3R3QVKY5cjs.minorKey.call(void 0, tonic));
   }
   for (const key of candidates) {
-    const tonic = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
+    const tonic = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
     let score = 0;
     for (const n of melody) {
       const w = Math.max(0.25, n.durationBeat);
-      const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, n.pitch);
+      const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, n.pitch);
       if (isKeyTone(n.pitch, key)) {
         score += w;
       }
@@ -3633,99 +4011,27 @@ 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 = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key);
-  const candidates = tones.map((rootPc, index) => {
-    const degree = index + 1;
-    const quality = _chunkUADYAYATcjs.diatonicTriad.call(void 0, degree, key).quality;
-    return {
-      rootPc,
-      quality,
-      degree,
-      secondaryDominant: false,
-      base: _nullishCoalesce(DEGREE_BASE[index], () => ( 0.6)),
-      pcs: _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, quality))
-    };
-  });
-  if (isMinorKey(key)) {
-    const rootPc = (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc) + 7) % 12;
-    candidates.push({
-      rootPc,
-      quality: "maj",
-      degree: 5,
-      secondaryDominant: false,
-      base: _nullishCoalesce(DEGREE_BASE[4], () => ( 0.6)),
-      pcs: _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, 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 = _nullishCoalesce(tones[target - 1], () => ( 0));
-    const rootPc = (targetRoot + 7) % 12;
-    candidates.push({
-      rootPc,
-      quality: "dom7",
-      secondaryDominant: true,
-      targetDegree: target,
-      base: SECONDARY_DOMINANT_BASE,
-      pcs: _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, rootPc, "dom7"))
-    });
-  }
-  const parallel = _chunkOE6WK2Y2cjs.parallelKey.call(void 0, key);
-  const parallelTones = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, parallel);
-  const borrowed = [];
-  for (let degree = 1; degree <= parallelTones.length; degree += 1) {
-    const chord = _chunkUADYAYATcjs.diatonicTriad.call(void 0, degree, parallel);
-    if (!_chunkOE6WK2Y2cjs.isDiatonic.call(void 0, 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: _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord)
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return candidates.filter((candidate) => {
-    const id = `${candidate.rootPc}:${candidate.quality}`;
-    if (seen.has(id)) {
-      return false;
-    }
-    seen.add(id);
-    return true;
-  });
-}
+
+// 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;
   for (const { index, weight, strong } of seg.costNotes) {
     const note2 = melody[index];
-    if (!note2 || pcs.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, note2.pitch))) {
+    if (!note2 || pcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note2.pitch))) {
       continue;
     }
     cost += (strong ? NON_CHORD_TONE_STRONG : NON_CHORD_TONE_WEAK) * 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;
@@ -3794,14 +4069,99 @@ function phraseEndBonus(prev, cur, tonicPc, seg, melody) {
   if (cur.rootPc !== tonicPc || seg.closingIndex === void 0) {
     return 0;
   }
-  const closing = melody[seg.closingIndex];
-  if (!closing || _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, closing.pitch) !== tonicPc) {
-    return 0;
+  const closing = melody[seg.closingIndex];
+  if (!closing || _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, closing.pitch) !== tonicPc) {
+    return 0;
+  }
+  const weight = Math.max(seg.weight, seg.beats);
+  return (PHRASE_TONIC + (prev !== null && isDominantOf(prev, tonicPc) ? PHRASE_AUTHENTIC : 0)) * weight;
+}
+
+// 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 = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  const n = candidates.length;
+  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
+  const seg0 = segments[0];
+  let dp = candidates.map(
+    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key) : 0) + (seg0 && phraseEnds.has(0) ? phraseEndBonus(null, c, tonicPc, seg0, melody) : 0) + (_nullishCoalesce(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 = (_nullishCoalesce(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) + (_nullishCoalesce(jitter[c], () => ( 0)));
+      ptr[c] = bestPrev;
+    }
+    dp = next;
+    back.push(ptr);
+  }
+  let bestCost = Number.POSITIVE_INFINITY;
+  let bestEnd = 0;
+  for (let c = 0; c < n; c += 1) {
+    const total = _nullishCoalesce(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 = _nullishCoalesce(path[s + 1], () => ( bestEnd));
+    path[s] = ptr ? _nullishCoalesce(ptr[nextIdx], () => ( bestEnd)) : bestEnd;
   }
-  const weight = Math.max(seg.weight, seg.beats);
-  return (PHRASE_TONIC + (prev !== null && isDominantOf(prev, tonicPc) ? PHRASE_AUTHENTIC : 0)) * weight;
+  return { cost: bestCost, path };
 }
-var BEAT_EPS = 1e-9;
+
+// src/generate/harmonize/segments.ts
 function gridBounds(segmentStart, hr, gridCount, ends) {
   const bounds = [];
   for (let s = 0; s <= gridCount; s += 1) {
@@ -3809,13 +4169,13 @@ function gridBounds(segmentStart, hr, gridCount, ends) {
   }
   const last = segmentStart + gridCount * hr;
   for (const end of ends) {
-    if (end > segmentStart + BEAT_EPS && end < last - BEAT_EPS) {
+    if (end > segmentStart + _chunkS5BKZZGMcjs.BEAT_EPS && end < last - _chunkS5BKZZGMcjs.BEAT_EPS) {
       bounds.push(end);
     }
   }
   bounds.sort((a, b) => a - b);
   return bounds.filter(
-    (beat, index) => index === 0 || beat - (_nullishCoalesce(bounds[index - 1], () => ( beat))) > BEAT_EPS
+    (beat, index) => index === 0 || beat - (_nullishCoalesce(bounds[index - 1], () => ( beat))) > _chunkS5BKZZGMcjs.BEAT_EPS
   );
 }
 function closingNoteIndices(spans, ends) {
@@ -3824,7 +4184,7 @@ function closingNoteIndices(spans, ends) {
     let index = -1;
     let start = Number.NEGATIVE_INFINITY;
     for (const [i, span] of spans.entries()) {
-      if (span.startBeat < end - BEAT_EPS && span.startBeat >= start) {
+      if (span.startBeat < end - _chunkS5BKZZGMcjs.BEAT_EPS && span.startBeat >= start) {
         start = span.startBeat;
         index = i;
       }
@@ -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] : []);
@@ -3859,7 +4227,7 @@ function phraseEndSegments(segments, ends) {
   for (const end of ends) {
     let index = -1;
     for (let s = 0; s < segments.length; s += 1) {
-      if ((_nullishCoalesce(_optionalChain([segments, 'access', _44 => _44[s], 'optionalAccess', _45 => _45.startBeat]), () => ( 0))) < end - BEAT_EPS) {
+      if ((_nullishCoalesce(_optionalChain([segments, 'access', _48 => _48[s], 'optionalAccess', _49 => _49.startBeat]), () => ( 0))) < end - _chunkS5BKZZGMcjs.BEAT_EPS) {
         index = s;
       }
     }
@@ -3870,103 +4238,19 @@ function phraseEndSegments(segments, ends) {
   }
   return { closing, named };
 }
-function harmonizeOnce(melody, key, candidates, segments, jitter, phraseEnds, articulated) {
-  const tonicPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
-  const n = candidates.length;
-  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
-  const seg0 = segments[0];
-  let dp = candidates.map(
-    (c, ci) => (seg0 ? emissionCost(seg0, c, melody, key) : 0) + (seg0 && phraseEnds.has(0) ? phraseEndBonus(null, c, tonicPc, seg0, melody) : 0) + (_nullishCoalesce(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 = (_nullishCoalesce(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) + (_nullishCoalesce(jitter[c], () => ( 0)));
-      ptr[c] = bestPrev;
-    }
-    dp = next;
-    back.push(ptr);
-  }
-  let bestCost = Number.POSITIVE_INFINITY;
-  let bestEnd = 0;
-  for (let c = 0; c < n; c += 1) {
-    const total = _nullishCoalesce(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 = _nullishCoalesce(path[s + 1], () => ( bestEnd));
-    path[s] = ptr ? _nullishCoalesce(ptr[nextIdx], () => ( bestEnd)) : bestEnd;
-  }
-  return { cost: bestCost, path };
-}
-function harmonizeMelody(opts) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, opts.melody, "harmonize melody", { allowNonPositiveDuration: true });
-  const phraseEnds = _nullishCoalesce(opts.phraseEnds, () => ( []));
-  for (const end of phraseEnds) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, end, "harmonize phrase end");
-  }
-  const soundingMelody = _chunkQ2WGKJNNcjs.soundingNotesOnly.call(void 0, opts.melody);
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_METER));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  const requestedKey = _nullishCoalesce(opts.key, () => ( "infer"));
-  const key = requestedKey === "infer" ? inferKey(soundingMelody) : _chunkUADYAYATcjs.toKeyScale.call(void 0, requestedKey);
-  const placement = _nullishCoalesce(opts.placement, () => ( DEFAULT_PLACEMENT));
-  const ctx = resolveContext(opts.ctx);
-  const harmonic = _nullishCoalesce(ctx.harmonic, () => ( REHARMONIZE_DIAL[_nullishCoalesce(opts.reharmonize, () => ( "diatonic"))]));
-  if (soundingMelody.length === 0) {
-    return { transposeSemitones: 0, key, chords: [], melodyRoles: [] };
-  }
-  const candidates = buildCandidates(key, harmonic);
-  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
-  const draw = ctx.part("harmony");
-  const jitter = candidates.map((_, index) => draw.at("jitter", index) * TIE_BREAK_JITTER2);
-  const pulse2 = _chunkK4ZJUGF4cjs.pulseBeats.call(void 0, 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 = _chunkQ2WGKJNNcjs.assertRange.call(void 0, 
-    _nullishCoalesce(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));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, gridCount, "harmonic segments");
-  const bounds = gridBounds(segmentStart, hr, gridCount, phraseEnds);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, gridCount, "harmonic segments", budget);
+  const innerEnds = phraseEnds.filter(
+    (end) => end > segmentStart + _chunkS5BKZZGMcjs.BEAT_EPS && end < melodyEnd - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+  const bounds = gridBounds(segmentStart, hr, gridCount, innerEnds);
   const segCount = bounds.length - 1;
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, segCount, "harmonic segments");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, segCount, "harmonic segments", budget);
   const segments = Array.from({ length: segCount }, (_, s) => {
     const startBeat = _nullishCoalesce(bounds[s], () => ( segmentStart));
     const endBeat = _nullishCoalesce(bounds[s + 1], () => ( startBeat + hr));
@@ -3987,16 +4271,16 @@ function harmonizeMelody(opts) {
       lastExclusive += 1;
     }
     memberships += Math.max(0, lastExclusive - first);
-    _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, memberships, "note-to-segment memberships");
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, "note-to-segment memberships", budget);
     for (let segment = first; segment < lastExclusive; segment += 1) {
-      _optionalChain([segments, 'access', _46 => _46[segment], 'optionalAccess', _47 => _47.noteIndices, 'access', _48 => _48.push, 'call', _49 => _49(index)]);
+      _optionalChain([segments, 'access', _50 => _50[segment], 'optionalAccess', _51 => _51.noteIndices, 'access', _52 => _52.push, 'call', _53 => _53(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) => _optionalChain([tones, 'access', _50 => _50[idx], 'optionalAccess', _51 => _51.ornamental]) !== true || phraseClosingNotes.has(idx)
+      (idx) => _optionalChain([tones, 'access', _54 => _54[idx], 'optionalAccess', _55 => _55.ornamental]) !== true || phraseClosingNotes.has(idx)
     );
     const costIndices = structural.length > 0 ? structural : segment.noteIndices;
     let closingStart = Number.NEGATIVE_INFINITY;
@@ -4011,7 +4295,7 @@ function harmonizeMelody(opts) {
         continue;
       }
       const weight = Math.max(0.25, overlap);
-      segment.costNotes.push({ index, weight, strong: _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, overlapStart, ts) });
+      segment.costNotes.push({ index, weight, strong: _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, overlapStart, ts) });
       segment.weight += weight;
       if (span.startBeat >= closingStart) {
         closingStart = span.startBeat;
@@ -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 = (_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, rootPc) - tonicPc + 12) % 12;
+  const root = _nullishCoalesce(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(
+    _chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, 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 = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
+  const frame = _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key);
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, frame);
+  const candidates = tones.map((rootPc, index) => {
+    const degree = index + 1;
+    const quality = _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, frame).quality;
+    return {
+      rootPc,
+      quality,
+      degree,
+      secondaryDominant: false,
+      base: vocabularyBase(rootPc, quality, tonicPc),
+      pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 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: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 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: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "dom7"))
+    });
+  }
+  const parallel = _chunkSGLEQVJHcjs.parallelKey.call(void 0, key);
+  const parallelTones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, parallel);
+  const borrowed = [];
+  for (let degree = 1; degree <= parallelTones.length; degree += 1) {
+    const chord = _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, parallel);
+    if (!_chunkSGLEQVJHcjs.isDiatonic.call(void 0, chord, key)) {
+      borrowed.push(chord);
+    }
+  }
+  const borrowedRank = (chord) => {
+    const offset = BORROWED_ENTRY_ORDER.indexOf(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord)
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const id = `${candidate.rootPc}:${candidate.quality}`;
+    if (seen.has(id)) {
+      return false;
+    }
+    seen.add(id);
+    return true;
+  });
+}
+
+// src/generate/harmonize/index.ts
+function harmonizeMelody(opts) {
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "harmonize options");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, opts.melody, "harmonize melody", {
+    allowNonPositiveDuration: true,
+    budget: opts.budget
+  });
+  const phraseEnds = _nullishCoalesce(opts.phraseEnds, () => ( []));
+  for (const end of phraseEnds) {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, end, "harmonize phrase end");
+  }
+  const soundingMelody = _chunkS5BKZZGMcjs.soundingNotesOnly.call(void 0, opts.melody);
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_METER)), "ts"));
+  _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, ts);
+  const requestedKey = _nullishCoalesce(opts.key, () => ( "infer"));
+  const resolvedKey = _chunk3R3QVKY5cjs.resolveKey.call(void 0, 
+    requestedKey === "infer" ? inferKey(soundingMelody) : requestedKey
+  );
+  const key = resolvedKey.scale;
+  const placement = _nullishCoalesce(opts.placement, () => ( DEFAULT_PLACEMENT));
+  const ctx = resolveContext(opts.ctx);
+  const reharmonize = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, 
+    _nullishCoalesce(opts.reharmonize, () => ( "diatonic")),
+    REHARMONIZE_STRENGTHS,
+    "reharmonize"
+  );
+  const harmonic = _nullishCoalesce(ctx.harmonic, () => ( REHARMONIZE_DIAL[reharmonize]));
+  if (soundingMelody.length === 0) {
+    return { transposeSemitones: 0, key: resolvedKey, chords: [], melodyRoles: [] };
+  }
+  const candidates = buildCandidates(key, harmonic);
+  const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
+  const draw = ctx.part("harmony");
+  const jitter = candidates.map((_, index) => draw.at("jitter", index) * TIE_BREAK_JITTER2);
+  const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, 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 = _chunkS5BKZZGMcjs.assertRange.call(void 0, 
+    _nullishCoalesce(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];
@@ -4034,9 +4509,10 @@ function harmonizeMelody(opts) {
   }
   const octaveShifts = placement.octaveSearch ? [0, -12, 12] : [0];
   const transposes = semitoneShifts.flatMap((s) => octaveShifts.map((o) => s + o));
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 
-    transposes.length * segCount * candidates.length * candidates.length,
-    "harmonization placement search"
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
+    transposes.length * segments.length * candidates.length * candidates.length,
+    "harmonization placement search",
+    opts.budget
   );
   let bestCost = Number.POSITIVE_INFINITY;
   let bestTs = 0;
@@ -4065,7 +4541,7 @@ function harmonizeMelody(opts) {
       const chord = {
         rootPc: cand.rootPc,
         quality: cand.quality,
-        startBeat: _nullishCoalesce(_optionalChain([segments, 'access', _52 => _52[s], 'optionalAccess', _53 => _53.startBeat]), () => ( segmentStart + s * hr))
+        startBeat: _nullishCoalesce(_optionalChain([segments, 'access', _56 => _56[s], 'optionalAccess', _57 => _57.startBeat]), () => ( segmentStart + s * hr))
       };
       if (cand.degree !== void 0) {
         chord.degree = cand.degree;
@@ -4077,29 +4553,37 @@ 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(_nullishCoalesce(bestPath[segIdx], () => ( 0)));
-    const chord = _chunkUADYAYATcjs.makeChord.call(void 0, cand.rootPc, cand.quality);
-    return { noteIndex, role: _chunk6XPTBE7Ycjs.roleOf.call(void 0, note2.pitch + bestTs, chord).role };
+    const chord = _chunk3R3QVKY5cjs.makeChord.call(void 0, cand.rootPc, cand.quality);
+    return { noteIndex, role: _chunkPM4XJE2Ycjs.roleOf.call(void 0, 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)) < _chunkS5BKZZGMcjs.BEAT_EPS;
 }
 function nearestChordTone(pitch, chord) {
-  const pcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord);
+  const pcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
   for (let d = 0; d <= 12; d += 1) {
-    if (pcs.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch - d))) {
+    if (pcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch - d))) {
       return pitch - d;
     }
-    if (pcs.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch + d))) {
+    if (pcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch + d))) {
       return pitch + d;
     }
   }
@@ -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 _nullishCoalesce(_optionalChain([pivot, 'optionalAccess', _58 => _58.pitch]), () => ( 0));
+}
 function contourOffsets(contour, count) {
   const offsets = [];
   for (let i = 0; i < count; i += 1) {
@@ -4167,19 +4663,20 @@ function contourOffsets(contour, count) {
   return offsets;
 }
 function generateMotif(opts) {
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "motif options");
   const contour = _nullishCoalesce(opts.contour, () => ( "arch"));
-  const bars = _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, opts.bars, "motif bars");
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS5)));
+  const bars = _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, opts.bars, "motif bars");
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS4)), "ts")));
   const totalBeats = bars * barBeats;
   const noteCount = Math.max(3, bars * 2);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, noteCount, "motif notes");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, noteCount, "motif notes");
   const beatsPerNote = totalBeats / noteCount;
   const ctx = resolveContextWith(opts.ctx, { ornament: opts.jitter });
   const jitterProb = _nullishCoalesce(ctx.ornament, () => ( 0));
   const draw = ctx.part("motif");
-  const key = _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key);
-  const chord = opts.chord ? _chunkUADYAYATcjs.toChordData.call(void 0, opts.chord) : null;
-  const tonic = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc) + 60;
+  const key = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key);
+  const chord = opts.chord ? _chunk3R3QVKY5cjs.toChordData.call(void 0, opts.chord) : null;
+  const tonic = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc) + 60;
   const offsets = contourOffsets(contour, noteCount);
   const notes = [];
   for (let i = 0; i < noteCount; i += 1) {
@@ -4187,13 +4684,13 @@ function generateMotif(opts) {
     if (draw.prob(jitterProb, "jitter", i)) {
       jitter = draw.prob(0.5, "direction", i) ? 1 : -1;
     }
-    let pitch = _chunkUADYAYATcjs.shiftByScaleDegrees.call(void 0, tonic, (_nullishCoalesce(offsets[i], () => ( 0))) + jitter, key);
+    let pitch = _chunk3R3QVKY5cjs.shiftByScaleDegrees.call(void 0, tonic, (_nullishCoalesce(offsets[i], () => ( 0))) + jitter, key);
     const startBeat = i * beatsPerNote;
     if (chord && isDownbeat(startBeat, barBeats)) {
       pitch = nearestChordTone(pitch, chord);
     }
     notes.push({
-      pitch: _chunkQ2WGKJNNcjs.clampToMidi.call(void 0, pitch, "generated motif pitch"),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, pitch, "generated motif pitch"),
       startBeat,
       durationBeat: beatsPerNote
     });
@@ -4201,18 +4698,23 @@ 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 = _chunkS5BKZZGMcjs.assertRecord.call(void 0, cell, "motif cell");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, read.notes, name);
+  return read.notes;
 }
 function transformMotif(cell, t, amount, key) {
-  return transformCell(cell, t, amount, key === void 0 ? void 0 : _chunkUADYAYATcjs.toKeyScale.call(void 0, key));
+  return transformCell(cell, t, amount, key === void 0 ? void 0 : _chunk3R3QVKY5cjs.toKeyScale.call(void 0, 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) {
     if (note2.pitch < 0 || note2.pitch > 127) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
         `transformed motif pitch ${note2.pitch} is outside the MIDI range 0..127`
       );
     }
@@ -4220,20 +4722,20 @@ function assertInRange(cell) {
   return cell;
 }
 function transformUnchecked(cell, t, amount, key) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, cell.notes, "motif notes");
+  const notes = assertCellNotes(cell, "motif notes");
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, t, MOTIF_TRANSFORMS, "motif transform");
   if (amount !== void 0) {
-    _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, amount, "motif transform amount");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, amount, "motif transform amount");
   }
   if ((t === "transposeChromatic" || t === "transposeDiatonic" || t === "sequence") && amount !== void 0) {
-    _chunkQ2WGKJNNcjs.assertInteger.call(void 0, 
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
       amount,
       `${t === "transposeChromatic" ? "chromatic" : "diatonic"} transform amount`
     );
   }
   if ((t === "augment" || t === "diminish") && amount !== void 0 && amount <= 0) {
-    throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("time transform amount must be positive");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("time transform amount must be positive");
   }
-  const notes = cell.notes;
   switch (t) {
     case "transposeChromatic": {
       const semis = _nullishCoalesce(amount, () => ( 0));
@@ -4250,12 +4752,12 @@ function transformUnchecked(cell, t, amount, key) {
           // notes a motif is written with — a blues lick, a semitone neighbour —
           // come through as themselves, and shifting by no degrees returns the
           // cell it was given.
-          pitch: key ? _chunkUADYAYATcjs.shiftByScaleDegrees.call(void 0, n.pitch, degrees, key) : n.pitch + degrees
+          pitch: key ? _chunk3R3QVKY5cjs.shiftByScaleDegrees.call(void 0, n.pitch, degrees, key) : n.pitch + degrees
         }))
       };
     }
     case "invert": {
-      const pivot = _nullishCoalesce(_optionalChain([notes, 'access', _54 => _54[0], 'optionalAccess', _55 => _55.pitch]), () => ( 0));
+      const pivot = pivotPitch(notes);
       return { notes: notes.map((n) => ({ ...n, pitch: 2 * pivot - n.pitch })) };
     }
     case "retrograde": {
@@ -4295,34 +4797,36 @@ function scaleTime(cell, factor) {
     }))
   };
 }
-function developMotif(cell, timeline, key, bars, ts = DEFAULT_TS5) {
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, bars, "development bars");
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, cell.notes, "motif notes");
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
+function developMotif(cell, timeline, key, bars, ts) {
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  _chunkSGLEQVJHcjs.assertChordTimeline.call(void 0, timeline);
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, bars, "development bars");
+  const cellNotes = assertCellNotes(cell, "motif notes");
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
   const span = cellSpan(cell);
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, 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);
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, tileCount * cell.notes.length, "developed motif notes");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 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;
       }
       const chord = timeline.at(startBeat);
       const structural = n.startBeat === origin || isDownbeat(startBeat, barBeats);
-      const chordTones = chord && structural ? _chunkUADYAYATcjs.chordPitchClasses.call(void 0, chord) : null;
-      const allows = chordTones ? (candidate) => chordTones.includes(_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, candidate)) : (candidate) => _chunkUADYAYATcjs.isScaleTone.call(void 0, candidate, scale);
+      const chordTones = chord && structural ? _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord) : null;
+      const allows = chordTones ? (candidate) => chordTones.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, candidate)) : (candidate) => _chunk3R3QVKY5cjs.isScaleTone.call(void 0, candidate, scale);
       const direction = previous === void 0 ? 0 : n.pitch - previous;
       const pitch = developedPitch(n.pitch, allows, direction, taken);
       taken.set(pitch, n.pitch);
@@ -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,9 +4847,9 @@ 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 = _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, note2.startBeat, ts);
+  const strong = _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, note2.startBeat, ts);
   switch (style) {
     case "ghost":
       return !strong;
@@ -4353,7 +4857,7 @@ function eligible(style, note2, previous, next, ts) {
     case "accent":
       return strong;
     case "drag":
-      return !strong && next !== void 0 && _chunkK4ZJUGF4cjs.isStrongBeat.call(void 0, next.startBeat, ts);
+      return !strong && next !== void 0 && _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, next.startBeat, ts);
     case "slide":
       return previous !== void 0 && Math.abs(note2.pitch - previous.pitch) >= SLIDE_MIN_SEMITONES;
   }
@@ -4378,28 +4882,23 @@ function clampVelocity(velocity) {
   return Math.min(MAX_VELOCITY2, Math.max(MIN_VELOCITY2, Math.round(velocity)));
 }
 function ornament(notes, opts = {}) {
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "ornament notes", { allowNonPositiveDuration: true });
-  const style = _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, _nullishCoalesce(opts.style, () => ( DEFAULT_STYLE2)), ORNAMENT_STYLES, "ornament style");
-  const ts = _nullishCoalesce(opts.ts, () => ( DEFAULT_TS6));
-  _chunkQ2WGKJNNcjs.assertTimeSignature.call(void 0, ts);
-  if (opts.amount !== void 0) {
-    _chunkQ2WGKJNNcjs.assertRange.call(void 0, opts.amount, 0, 1, "ornament amount");
-  }
-  const ctx = resolveContextWith(opts.ctx, { ornament: opts.amount });
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, notes, "ornament notes", { allowNonPositiveDuration: true });
+  const style = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, _nullishCoalesce(asked.style, () => ( DEFAULT_STYLE2)), ORNAMENT_STYLES, "ornament style");
+  const ts = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS5)), "ts"));
+  _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, ts);
+  if (asked.amount !== void 0) {
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, asked.amount, 0, 1, "ornament amount");
+  }
+  const ctx = resolveContextWith(asked.ctx, { ornament: asked.amount });
   const amount = _nullishCoalesce(ctx.ornament, () => ( DEFAULT_AMOUNT));
   const draw = ctx.part("ornament");
-  const sounding = _chunkQ2WGKJNNcjs.dropSilentNotes.call(void 0, 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 = _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, 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 = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, style, PROG_STYLES, "style");
+  return progressions().filter((p) => p.styles.includes(named));
 }
 function degreeToRootPc(degree, key) {
   if (degree >= 1 && degree <= 7) {
-    const tones = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key);
-    return tones.length > 0 ? _nullishCoalesce(tones[(degree - 1) % tones.length], () => ( key.rootPc % 12)) : key.rootPc % 12;
+    const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key));
+    return _nullishCoalesce(tones[degree - 1], () => ( key.rootPc % 12));
   }
   const offset = _nullishCoalesce(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 && _chunkSGLEQVJHcjs.isMinorKey.call(void 0, key) && degree === 5) {
       return "maj";
     }
-    return _chunkUADYAYATcjs.diatonicTriad.call(void 0, degree, key).quality;
+    return _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key)).quality;
   }
   if (degree === 14) {
     return "dim";
@@ -4660,59 +5174,57 @@ 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 (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Unknown progression style: ${style}`);
+    throw new (0, _chunkS5BKZZGMcjs.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 _nullishCoalesce(pool[index], () => ( PRESETS[0]));
 }
+function tonicizableRootPcs(key) {
+  return new Set(_chunk3R3QVKY5cjs.tonicizableDegrees.call(void 0, key).map((degree) => degree.rootPc));
+}
+function canBeTonicized(span, tonicizable) {
+  if (!tonicizable.has(span.rootPc)) {
+    return false;
+  }
+  return _chunk3R3QVKY5cjs.fifthPcOf.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, span.rootPc, span.quality)) === (span.rootPc + 7) % 12;
+}
 function generateProgression(opts) {
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, opts.bars, "progression bars");
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, opts.bars, "progression chords");
-  const key = _chunkUADYAYATcjs.toKeyScale.call(void 0, opts.key);
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "progression options");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, opts.bars, "progression bars");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, opts.bars, "progression chords");
+  const key = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key);
   const ctx = resolveContext(opts.ctx);
-  const seed = ctx.seed;
   let preset;
   if (opts.preset !== void 0) {
     if (opts.preset.degrees.length === 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)("progression preset must name at least one degree");
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("progression preset must name at least one degree");
     }
     preset = {
       id: _nullishCoalesce(opts.preset.id, () => ( "custom")),
       name: _nullishCoalesce(opts.preset.name, () => ( "Custom")),
       degrees: opts.preset.degrees.map((degree, index) => {
-        _chunkQ2WGKJNNcjs.assertDegree.call(void 0, degree, `progression preset degrees[${index}]`);
+        _chunkS5BKZZGMcjs.assertDegree.call(void 0, degree, `progression preset degrees[${index}]`);
         const supported = degree >= 1 && degree <= 7 || Object.values(BORROWED_DEGREES).includes(degree);
         if (!supported) {
-          throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(
+          throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
             `progression preset degrees[${index}] is not a supported progression degree; received ${degree}`
           );
         }
@@ -4725,26 +5237,27 @@ function generateProgression(opts) {
   if (preset === void 0 && opts.presetId !== void 0) {
     preset = PRESETS.find((p) => p.id === opts.presetId);
     if (preset === void 0) {
-      throw new (0, _chunkQ2WGKJNNcjs.InvalidInputError)(`Unknown progression preset: ${opts.presetId}`);
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Unknown progression preset: ${opts.presetId}`);
     }
   }
-  preset ??= pickProgressionPreset(opts.style, seed);
-  const ext = opts.ext === void 0 ? "auto" : _chunkQ2WGKJNNcjs.assertOneOf.call(void 0, opts.ext, ["auto", ..._chunkUADYAYATcjs.chordQualities.call(void 0, )], "progression extension");
+  preset ??= presetFor(opts.style, ctx);
+  const ext = opts.ext === void 0 ? "auto" : _chunkS5BKZZGMcjs.assertOneOf.call(void 0, opts.ext, ["auto", ..._chunk3R3QVKY5cjs.chordQualities.call(void 0, )], "progression extension");
   const cycle = resolveCycle(
-    _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _56 => _56.degrees]), () => ( [0])),
+    _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _59 => _59.degrees]), () => ( [0])),
     key,
     ext,
-    _optionalChain([preset, 'optionalAccess', _57 => _57.functional]) === "cadenceStrong"
+    _optionalChain([preset, 'optionalAccess', _60 => _60.functional]) === "cadenceStrong"
   );
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS6)));
   const chords = [];
   for (let bar2 = 0; bar2 < opts.bars; bar2 += 1) {
     const step = cycle[bar2 % cycle.length];
     const chord = {
-      rootPc: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _58 => _58.rootPc]), () => ( 0)),
-      quality: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _59 => _59.quality]), () => ( "maj")),
-      startBeat: bar2 * 4
+      rootPc: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _61 => _61.rootPc]), () => ( 0)),
+      quality: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _62 => _62.quality]), () => ( "maj")),
+      startBeat: bar2 * barBeats
     };
-    if (_optionalChain([step, 'optionalAccess', _60 => _60.degree]) !== void 0) {
+    if (_optionalChain([step, 'optionalAccess', _63 => _63.degree]) !== void 0) {
       chord.degree = step.degree;
     }
     chords.push(chord);
@@ -4752,6 +5265,7 @@ function generateProgression(opts) {
   const harmonic = _nullishCoalesce(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) {
@@ -4764,8 +5278,9 @@ function generateProgression(opts) {
       const targetsTonic = (next.rootPc - tonicPc + 12) % 12 === 0;
       const isLastTonicStatement = cur.rootPc === tonicPc && tonicStatements <= 1;
       const alreadySecondary = cur.rootPc === domRoot && cur.quality === "dom7";
-      const isResolutionTarget = _optionalChain([chords, 'access', _61 => _61[i - 1], 'optionalAccess', _62 => _62.secondaryDominant]) === true;
-      if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget) {
+      const isResolutionTarget = _optionalChain([chords, 'access', _64 => _64[i - 1], 'optionalAccess', _65 => _65.secondaryDominant]) === true;
+      const takesNoDominant = !canBeTonicized(next, tonicizable);
+      if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget || takesNoDominant) {
         continue;
       }
       if (draw.prob(harmonic, "reharmonize", i)) {
@@ -4785,18 +5300,12 @@ function generateProgression(opts) {
 }
 
 // src/generate/reharmony/index.ts
-function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 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;
 }
 function triadQualityOf(chord) {
-  const semis = new Set(chord.intervals.map((interval) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, interval)));
+  const semis = new Set(chord.intervals.map((interval) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval)));
   const hasThird = semis.has(4) ? "maj" : semis.has(3) ? "min" : void 0;
   if (hasThird === void 0) {
     return chord.quality;
@@ -4810,104 +5319,91 @@ function triadQualityOf(chord) {
   return hasThird;
 }
 function diatonicTriadsOf(key) {
-  const degrees = _chunkUADYAYATcjs.scaleTonesInDegreeOrder.call(void 0, key).length;
+  const degrees = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key).length;
   const triads = [];
   for (let degree = 1; degree <= degrees; degree += 1) {
-    triads.push(_chunkUADYAYATcjs.diatonicTriad.call(void 0, degree, key));
+    triads.push(_chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key));
   }
   return triads;
 }
 function sameChord(a, b) {
-  return _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, a.rootPc) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, b.rootPc) && a.quality === b.quality;
+  return _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, a.rootPc) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 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 _chunkUADYAYATcjs.spellScale.call(void 0, tonic, key).reduce((sum, note2) => sum + Math.abs(note2.alter), 0);
-}
-function keyTonicOf(key) {
-  const rootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, key.rootPc);
-  const sharp = bareSpelling(_chunkQ2WGKJNNcjs.midiToNote.call(void 0, MIDDLE_C + rootPc, "sharp"));
-  const flat = bareSpelling(_chunkQ2WGKJNNcjs.midiToNote.call(void 0, 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 = _chunkQ2WGKJNNcjs.noteToPitchClass.call(void 0, root) === _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc) && Math.abs(root.alter) <= MAX_HINT_ALTER;
+  const usable = _chunkS5BKZZGMcjs.noteToPitchClass.call(void 0, root) === _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc) && Math.abs(root.alter) <= MAX_HINT_ALTER;
   const spelled = {
     ...chord,
-    rootSpelling: bareSpelling(usable ? root : _chunkUADYAYATcjs.spellPitchClass.call(void 0, chord.rootPc, tonic, key))
+    rootSpelling: bareSpelling(usable ? root : _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, chord.rootPc, tonic, key))
   };
   if (chord.bassPc !== void 0) {
-    spelled.bassSpelling = bareSpelling(_chunkUADYAYATcjs.spellPitchClass.call(void 0, chord.bassPc, tonic, key));
+    spelled.bassSpelling = bareSpelling(_chunk3R3QVKY5cjs.spellPitchClass.call(void 0, chord.bassPc, tonic, key));
   }
   return spelled;
 }
 function spelledInKey(chord, tonic, key) {
-  return spelledOnRoot(chord, _chunkUADYAYATcjs.spellPitchClass.call(void 0, chord.rootPc, tonic, key), tonic, key);
+  return spelledOnRoot(chord, _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, chord.rootPc, tonic, key), tonic, key);
 }
 function tritoneSubstituteRoot(dominant, tonic, key) {
-  const substituteRootPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, dominant.rootPc + 6);
-  if (_chunkUADYAYATcjs.isScaleTone.call(void 0, substituteRootPc, key)) {
-    return _chunkUADYAYATcjs.spellPitchClass.call(void 0, substituteRootPc, tonic, key);
+  const substituteRootPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, dominant.rootPc + 6);
+  if (_chunk3R3QVKY5cjs.isScaleTone.call(void 0, substituteRootPc, key)) {
+    return _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, substituteRootPc, tonic, key);
   }
-  const resolution = _chunkUADYAYATcjs.spellPitchClass.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, dominant.rootPc + 5), tonic, key);
-  return _chunkQ2WGKJNNcjs.transposeNote.call(void 0, resolution, 1);
+  const resolution = _chunk3R3QVKY5cjs.spellPitchClass.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, dominant.rootPc + 5), tonic, key);
+  return _chunkS5BKZZGMcjs.transposeNote.call(void 0, resolution, 1);
 }
 function substituteChord(chord, key, opts) {
-  const source = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const originalTriad = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, _chunkUADYAYATcjs.makeChord.call(void 0, source.rootPc, triadQualityOf(source)));
+  _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const source = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const { scale, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
+  const originalTriad = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, source.rootPc, triadQualityOf(source)));
   const candidates = [];
-  const tonic = keyTonicOf(scale);
-  if (isDominantType(source)) {
-    const substitute = _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, source.rootPc + 6), "dom7");
+  if (_chunk3R3QVKY5cjs.soundsDominantSeventh.call(void 0, source)) {
+    const substitute = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, source.rootPc + 6), "dom7");
     candidates.push({
       chord: spelledOnRoot(substitute, tritoneSubstituteRoot(source, tonic, scale), tonic, scale),
       type: "tritone"
     });
   }
   for (const triad of diatonicTriadsOf(scale)) {
-    const offset = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, triad.rootPc - source.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunkUADYAYATcjs.chordPitchClasses.call(void 0, triad)) === 2) {
+    const offset = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, triad.rootPc - source.rootPc);
+    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, triad)) === 2) {
       candidates.push({ chord: spelledInKey(triad, tonic, scale), type: "relative" });
     }
   }
-  const targetFunction = _chunkOE6WK2Y2cjs.functionOf.call(void 0, source, scale);
-  const parallel = _chunkOE6WK2Y2cjs.parallelKey.call(void 0, scale);
+  const targetFunction = _chunkSGLEQVJHcjs.functionOf.call(void 0, source, scale);
+  const parallel = _chunkSGLEQVJHcjs.parallelKey.call(void 0, scale);
   for (const triad of diatonicTriadsOf(parallel)) {
-    if (_chunkOE6WK2Y2cjs.functionOf.call(void 0, triad, scale) === targetFunction && !_chunkOE6WK2Y2cjs.isDiatonic.call(void 0, triad, scale)) {
+    if (_chunkSGLEQVJHcjs.functionOf.call(void 0, triad, scale) === targetFunction && !_chunkSGLEQVJHcjs.isDiatonic.call(void 0, triad, scale)) {
       candidates.push({ chord: spelledInKey(triad, tonic, parallel), type: "borrowed" });
     }
   }
   for (const offset of THIRD_OFFSETS) {
     for (const quality of ["maj", "min"]) {
-      const mediant = _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, source.rootPc + offset), quality);
-      if (commonToneCount(originalTriad, _chunkUADYAYATcjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkOE6WK2Y2cjs.isDiatonic.call(void 0, mediant, scale)) {
+      const mediant = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, source.rootPc + offset), quality);
+      if (commonToneCount(originalTriad, _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkSGLEQVJHcjs.isDiatonic.call(void 0, mediant, scale)) {
         candidates.push({ chord: spelledInKey(mediant, tonic, scale), type: "chromaticMediant" });
       }
     }
   }
-  const melodyPcs = _optionalChain([opts, 'optionalAccess', _63 => _63.melodyPcs, 'optionalAccess', _64 => _64.map, 'call', _65 => _65(_chunkQ2WGKJNNcjs.pitchClassOf)]);
+  const melodyPcs = _optionalChain([opts, 'optionalAccess', _66 => _66.melodyPcs, 'optionalAccess', _67 => _67.map, 'call', _68 => _68(_chunkS5BKZZGMcjs.pitchClassOf)]);
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const candidate of candidates) {
     if (sameChord(candidate.chord, source)) {
       continue;
     }
-    const dedupeKey = `${_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, candidate.chord.rootPc)}:${candidate.chord.quality}`;
+    const dedupeKey = `${_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, candidate.chord.rootPc)}:${candidate.chord.quality}`;
     if (seen.has(dedupeKey)) {
       continue;
     }
     seen.add(dedupeKey);
     if (melodyPcs !== void 0) {
-      const pcs = new Set(_chunkUADYAYATcjs.chordPitchClasses.call(void 0, candidate.chord));
+      const pcs = new Set(_chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, candidate.chord));
       if (!melodyPcs.every((pc) => pcs.has(pc))) {
         continue;
       }
@@ -4915,67 +5411,65 @@ function substituteChord(chord, key, opts) {
     results.push({
       chord: candidate.chord,
       type: candidate.type,
-      roman: _chunkOE6WK2Y2cjs.chordToRoman.call(void 0, candidate.chord, scale),
-      function: _chunkOE6WK2Y2cjs.functionOf.call(void 0, candidate.chord, scale)
+      roman: _chunkSGLEQVJHcjs.chordToRoman.call(void 0, candidate.chord, scale),
+      function: _chunkSGLEQVJHcjs.functionOf.call(void 0, candidate.chord, scale)
     });
   }
   return results;
 }
 function modalInterchangePalette(key) {
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
+  const { scale, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
   const palette = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (chord) => {
-    const dedupeKey = `${_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, chord.rootPc)}:${chord.quality}`;
+    const dedupeKey = `${_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc)}:${chord.quality}`;
     if (seen.has(dedupeKey)) {
       return;
     }
     seen.add(dedupeKey);
     palette.push({
       chord,
-      roman: _chunkOE6WK2Y2cjs.chordToRoman.call(void 0, chord, scale),
-      source: _chunkOE6WK2Y2cjs.borrowedSource.call(void 0, chord, scale)
+      roman: _chunkSGLEQVJHcjs.chordToRoman.call(void 0, chord, scale),
+      source: _chunkSGLEQVJHcjs.borrowedSource.call(void 0, chord, scale)
     });
   };
-  const tonic = keyTonicOf(scale);
-  const parallel = _chunkOE6WK2Y2cjs.parallelKey.call(void 0, scale);
+  const parallel = _chunkSGLEQVJHcjs.parallelKey.call(void 0, scale);
   for (const triad of diatonicTriadsOf(parallel)) {
-    if (!_chunkOE6WK2Y2cjs.isDiatonic.call(void 0, triad, scale) && _chunkOE6WK2Y2cjs.borrowedSource.call(void 0, triad, scale) !== null) {
+    if (!_chunkSGLEQVJHcjs.isDiatonic.call(void 0, triad, scale) && _chunkSGLEQVJHcjs.borrowedSource.call(void 0, triad, scale) !== null) {
       add(spelledInKey(triad, tonic, parallel));
     }
   }
-  const neapolitan = _chunkUADYAYATcjs.makeChord.call(void 0, _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, scale.rootPc + 1), "maj");
-  if (!_chunkOE6WK2Y2cjs.isDiatonic.call(void 0, neapolitan, scale)) {
-    add(spelledOnRoot(neapolitan, _chunkQ2WGKJNNcjs.transposeNote.call(void 0, tonic, 1), tonic, scale));
+  const neapolitan = _chunk3R3QVKY5cjs.makeChord.call(void 0, _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, scale.rootPc + 1), "maj");
+  if (!_chunkSGLEQVJHcjs.isDiatonic.call(void 0, neapolitan, scale)) {
+    add(spelledOnRoot(neapolitan, _chunkS5BKZZGMcjs.transposeNote.call(void 0, tonic, 1), tonic, scale));
   }
   return palette;
 }
 function negativeHarmonyMirror(chord, key) {
-  const source = _chunkUADYAYATcjs.toChordData.call(void 0, chord);
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const tonicPc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, scale.rootPc);
-  const tonic = keyTonicOf(scale);
-  const mirror = (p) => _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, 2 * tonicPc + 7 - p);
-  const pcs = _chunkUADYAYATcjs.chordPitchClasses.call(void 0, source).map(mirror);
+  const source = _chunk3R3QVKY5cjs.toChordData.call(void 0, chord);
+  const { scale, tonic } = _chunk3R3QVKY5cjs.resolveKey.call(void 0, key);
+  const tonicPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, scale.rootPc);
+  const mirror = (p) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, 2 * tonicPc + 7 - p);
+  const pcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, source).map(mirror);
   const bassPc = source.bassPc !== void 0 ? mirror(source.bassPc) : void 0;
-  const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
-  const detected = _chunkOE6WK2Y2cjs.detectChordBest.call(void 0, pitches);
+  const pitches = bassPc !== void 0 ? [bassPc, ...pcs.map((pc) => pc + 12)] : pcs;
+  const detected = _chunkSGLEQVJHcjs.detectChordBest.call(void 0, pitches);
   if (detected) {
     if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return spelledInKey(_chunkUADYAYATcjs.makeChord.call(void 0, detected.rootPc, detected.quality), tonic, scale);
+      return spelledInKey(_chunk3R3QVKY5cjs.makeChord.call(void 0, detected.rootPc, detected.quality), tonic, scale);
     }
     return spelledInKey(detected, tonic, scale);
   }
   const quality = source.quality;
-  return spelledInKey(_chunkUADYAYATcjs.makeChord.call(void 0, mirror(source.rootPc), quality, bassPc), tonic, scale);
+  return spelledInKey(_chunk3R3QVKY5cjs.makeChord.call(void 0, mirror(source.rootPc), quality, bassPc), tonic, scale);
 }
 
 // src/generate/rhythm/index.ts
 var DEFAULT_RHYTHM_VELOCITY = 96;
 function rhythmToNoteEvents(events, pitch, velocity = DEFAULT_RHYTHM_VELOCITY) {
-  _chunkQ2WGKJNNcjs.assertFiniteNumber.call(void 0, pitch, "pitch");
-  _chunkQ2WGKJNNcjs.assertRange.call(void 0, velocity, 0, 127, "velocity");
-  return events.map((event) => ({
+  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, pitch, "pitch");
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, velocity, "velocity", 0, 127);
+  return _chunkS5BKZZGMcjs.assertArray.call(void 0, 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) {
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, weight, "weight", 0, 3);
   switch (weight) {
     case 3:
       return 1;
@@ -4998,18 +5493,20 @@ function onsetWeightCurve(weight) {
   }
 }
 function generateRhythm(ts, opts = {}) {
-  const bars = _nullishCoalesce(opts.bars, () => ( DEFAULT_BARS));
-  const subdivision = _nullishCoalesce(opts.subdivision, () => ( DEFAULT_SUBDIVISION));
-  const ctx = resolveContext(opts.ctx);
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  const bars = _nullishCoalesce(asked.bars, () => ( DEFAULT_BARS));
+  const subdivision = _nullishCoalesce(asked.subdivision, () => ( DEFAULT_SUBDIVISION));
+  const ctx = resolveContext(asked.ctx);
   const density = _nullishCoalesce(ctx.rhythmic, () => ( DEFAULT_DENSITY));
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, bars, "rhythm bars");
-  _chunkQ2WGKJNNcjs.assertPositiveInt.call(void 0, subdivision, "rhythm subdivision");
-  const barBeats = _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, bars, "rhythm bars");
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, subdivision, "rhythm subdivision");
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, meter);
   const spanBeats = barBeats * bars;
   const step = 1 / subdivision;
   const slotsPerBar = Math.ceil(barBeats * subdivision);
   const slotCount = slotsPerBar * bars;
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, slotCount, "rhythm grid slots");
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slotCount, "rhythm grid slots");
   const draw = ctx.part("rhythm");
   const positions = [];
   for (let bar2 = 0; bar2 < bars; bar2 += 1) {
@@ -5024,7 +5521,7 @@ function generateRhythm(ts, opts = {}) {
         positions.push(position);
         continue;
       }
-      const weight = _chunkK4ZJUGF4cjs.metricWeight.call(void 0, position, ts);
+      const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, 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) {
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, events, "events");
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
   if (events.length === 0) {
     return 0;
   }
   const last = events[events.length - 1];
-  const spanBeats = (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _66 => _66.position]), () => ( 0))) + (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _67 => _67.duration]), () => ( 0)));
-  const bars = spanBeats / _chunkK4ZJUGF4cjs.beatsPerBar.call(void 0, ts);
+  const spanBeats = (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _69 => _69.position]), () => ( 0))) + (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _70 => _70.duration]), () => ( 0)));
+  const bars = spanBeats / barBeats;
   return bars > 0 ? events.length / bars : 0;
 }
 
@@ -5117,5 +5616,6 @@ function rhythmDensity(events, ts) {
 
 
 
-exports.GENRES = GENRES; exports.PROVENANCE_BASES = PROVENANCE_BASES; exports.fitsQuery = fitsQuery; exports.selectVocabulary = selectVocabulary; exports.pickVocabulary = pickVocabulary; exports.mergeVocabulary = mergeVocabulary; exports.vocabularyOfKind = vocabularyOfKind; exports.assertVocabulary = assertVocabulary; exports.MIN_DIFFICULTY = MIN_DIFFICULTY; exports.MAX_DIFFICULTY = MAX_DIFFICULTY; exports.sustainsStrokes = sustainsStrokes; exports.sustainsShift = sustainsShift; exports.resolveContext = resolveContext; exports.BAR_STEPS = BAR_STEPS; exports.BEAT_STEPS = BEAT_STEPS; exports.STEP_BEATS = STEP_BEATS; exports.gridMetricWeight = gridMetricWeight; exports.thin = thin; exports.double = double; exports.halfTime = halfTime; exports.doubleTime = doubleTime; exports.syncopate = syncopate; exports.ornamentBy = ornamentBy; exports.deform = deform; exports.withinCeiling = withinCeiling; exports.isLickMaterial = isLickMaterial; exports.BASS_LICKS = BASS_LICKS; exports.placeLicks = placeLicks; exports.BASS_STYLES = BASS_STYLES; exports.generateBassLine = generateBassLine; exports.imitate = imitate; exports.generateCounterMelody = generateCounterMelody; exports.FILL_TYPES = FILL_TYPES; exports.FILL_ARCHETYPES = FILL_ARCHETYPES; exports.isFillArchetype = isFillArchetype; exports.DRUM_NOTES = DRUM_NOTES; exports.drumVoiceOf = drumVoiceOf; exports.KICK_STEPS = KICK_STEPS; exports.KICK_FIGURES = KICK_FIGURES; exports.DRUM_KIT = DRUM_KIT; exports.isDrumPattern = isDrumPattern; exports.DRUM_PATTERNS = DRUM_PATTERNS; exports.placeDrumPattern = placeDrumPattern; exports.generateDrums = generateDrums; exports.humanize = humanize; exports.extractGrooveTemplate = extractGrooveTemplate; exports.applyGrooveTemplate = applyGrooveTemplate; exports.classifyMelodyTones = classifyMelodyTones; exports.harmonizeMelody = harmonizeMelody; exports.generateMotif = generateMotif; exports.motifToNoteEvents = motifToNoteEvents; exports.transformMotif = transformMotif; exports.developMotif = developMotif; exports.ORNAMENT_STYLES = ORNAMENT_STYLES; exports.ornament = ornament; exports.BORROWED_DEGREES = BORROWED_DEGREES; exports.progressions = progressions; exports.progressionsByStyle = progressionsByStyle; exports.pickProgressionPreset = pickProgressionPreset; exports.generateProgression = generateProgression; exports.substituteChord = substituteChord; exports.modalInterchangePalette = modalInterchangePalette; exports.negativeHarmonyMirror = negativeHarmonyMirror; exports.rhythmToNoteEvents = rhythmToNoteEvents; exports.onsetWeightCurve = onsetWeightCurve; exports.generateRhythm = generateRhythm; exports.rhythmDensity = rhythmDensity;
-//# sourceMappingURL=chunk-AFM2ULJH.cjs.map
+
+exports.GENRES = GENRES; exports.PROVENANCE_BASES = PROVENANCE_BASES; exports.fitsQuery = fitsQuery; exports.selectVocabulary = selectVocabulary; exports.pickVocabulary = pickVocabulary; exports.mergeVocabulary = mergeVocabulary; exports.vocabularyOfKind = vocabularyOfKind; exports.assertVocabulary = assertVocabulary; exports.MIN_DIFFICULTY = MIN_DIFFICULTY; exports.MAX_DIFFICULTY = MAX_DIFFICULTY; exports.sustainsStrokes = sustainsStrokes; exports.sustainsShift = sustainsShift; exports.resolveContext = resolveContext; exports.BAR_STEPS = BAR_STEPS; exports.BEAT_STEPS = BEAT_STEPS; exports.STEP_BEATS = STEP_BEATS; exports.gridMetricWeight = gridMetricWeight; exports.thin = thin; exports.double = double; exports.halfTime = halfTime; exports.doubleTime = doubleTime; exports.syncopate = syncopate; exports.ornamentBy = ornamentBy; exports.deform = deform; exports.withinCeiling = withinCeiling; exports.isLickMaterial = isLickMaterial; exports.BASS_LICKS = BASS_LICKS; exports.placeLicks = placeLicks; exports.BASS_STYLES = BASS_STYLES; exports.generateBassLine = generateBassLine; exports.imitate = imitate; exports.generateCounterMelody = generateCounterMelody; exports.FILL_TYPES = FILL_TYPES; exports.FILL_ARCHETYPES = FILL_ARCHETYPES; exports.isFillArchetype = isFillArchetype; exports.DRUM_NOTES = DRUM_NOTES; exports.drumVoiceOf = drumVoiceOf; exports.KICK_STEPS = KICK_STEPS; exports.KICK_FIGURES = KICK_FIGURES; exports.DRUM_KIT = DRUM_KIT; exports.isDrumPattern = isDrumPattern; exports.DRUM_PATTERNS = DRUM_PATTERNS; exports.placeDrumPattern = placeDrumPattern; exports.generateDrums = generateDrums; exports.humanize = humanize; exports.extractGrooveTemplate = extractGrooveTemplate; exports.applyGrooveTemplate = applyGrooveTemplate; exports.classifyMelodyTones = classifyMelodyTones; exports.harmonizeMelody = harmonizeMelody; exports.cellSpan = cellSpan; exports.generateMotif = generateMotif; exports.motifToNoteEvents = motifToNoteEvents; exports.transformMotif = transformMotif; exports.developMotif = developMotif; exports.ORNAMENT_STYLES = ORNAMENT_STYLES; exports.ornament = ornament; exports.BORROWED_DEGREES = BORROWED_DEGREES; exports.progressions = progressions; exports.progressionsByStyle = progressionsByStyle; exports.pickProgressionPreset = pickProgressionPreset; exports.generateProgression = generateProgression; exports.substituteChord = substituteChord; exports.modalInterchangePalette = modalInterchangePalette; exports.negativeHarmonyMirror = negativeHarmonyMirror; exports.rhythmToNoteEvents = rhythmToNoteEvents; exports.onsetWeightCurve = onsetWeightCurve; exports.generateRhythm = generateRhythm; exports.rhythmDensity = rhythmDensity;
+//# sourceMappingURL=chunk-J7FHVZII.cjs.map