@libraz/libcantus 1.1.0 → 1.3.0

package/dist/{chunk-5KW7DNCJ.cjs → chunk-B2PW6EHN.cjs}

@@ -8,7 +8,6 @@
 
 
 
-var _chunkQ6R3QAZDcjs = require('./chunk-Q6R3QAZD.cjs');
 
 
 
@@ -19,14 +18,11 @@ var _chunkQ6R3QAZDcjs = require('./chunk-Q6R3QAZD.cjs');
 
 
 
-var _chunkJ772DL3Bcjs = require('./chunk-J772DL3B.cjs');
 
 
-var _chunkTT6PKMPRcjs = require('./chunk-TT6PKMPR.cjs');
 
 
 
-var _chunkR7B5N2JKcjs = require('./chunk-R7B5N2JK.cjs');
 
 
 
@@ -34,6 +30,7 @@ var _chunkR7B5N2JKcjs = require('./chunk-R7B5N2JK.cjs');
 
 
 
+var _chunkIFZDWIKMcjs = require('./chunk-IFZDWIKM.cjs');
 
 
 
@@ -46,11 +43,14 @@ var _chunkR7B5N2JKcjs = require('./chunk-R7B5N2JK.cjs');
 
 
 
+var _chunkCGBADIO5cjs = require('./chunk-CGBADIO5.cjs');
 
 
+var _chunk35NBV2FTcjs = require('./chunk-35NBV2FT.cjs');
 
 
 
+var _chunkPM4XJE2Ycjs = require('./chunk-PM4XJE2Y.cjs');
 
 
 
@@ -58,7 +58,6 @@ var _chunkR7B5N2JKcjs = require('./chunk-R7B5N2JK.cjs');
 
 
 
-var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
@@ -85,6 +84,7 @@ var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
+var _chunk3R3QVKY5cjs = require('./chunk-3R3QVKY5.cjs');
 
 
 
@@ -95,24 +95,59 @@ var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
 
 
-var _chunkXKSO2V5Icjs = require('./chunk-XKSO2V5I.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 = _chunkXKSO2V5Icjs.assertRecord.call(void 0, draw, name);
+  const sampler = _chunkS5BKZZGMcjs.assertRecord.call(void 0, draw, name);
   for (const method of DRAW_METHODS) {
-    _chunkXKSO2V5Icjs.assertFunction.call(void 0, sampler[method], `${name}.${method}`);
+    _chunkS5BKZZGMcjs.assertFunction.call(void 0, sampler[method], `${name}.${method}`);
   }
   return sampler;
 }
 function assertSeedPath(path, name = "draw path") {
-  const steps = _chunkXKSO2V5Icjs.assertArray.call(void 0, path, name);
+  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, _chunkXKSO2V5Icjs.InvalidInputError)(
-        `${name}[${index}] must be a string or a finite number; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, step)}`
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}[${index}] must be a string or a finite number; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, step)}`
       );
     }
   }
@@ -121,7 +156,7 @@ function assertSeedPath(path, name = "draw path") {
 function drawFrom(rng, path) {
   const draw = rng.at(...path);
   if (!(draw >= 0 && draw < 1)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`positional draw must be in [0, 1); received ${draw}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`positional draw must be in [0, 1); received ${draw}`);
   }
   return draw;
 }
@@ -129,27 +164,27 @@ function drawsFrom(rng, ...prefix) {
   const at2 = (...path) => drawFrom(rng, [...prefix, ...path]);
   return {
     at: at2,
-    prob: (p, ...path) => _chunkJ772DL3Bcjs.includeAt.call(void 0, rng, p, ...prefix, ...path),
+    prob: (p, ...path) => _chunkCGBADIO5cjs.includeAt.call(void 0, rng, p, ...prefix, ...path),
     range: (lo, hi, ...path) => {
-      _chunkXKSO2V5Icjs.assertInteger.call(void 0, lo, "range lower bound");
-      _chunkXKSO2V5Icjs.assertInteger.call(void 0, hi, "range upper bound");
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, lo, "range lower bound");
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi, "range upper bound");
       if (lo > hi) {
-        throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
           `range lower bound must not exceed upper bound; received ${lo} > ${hi}`
         );
       }
-      _chunkXKSO2V5Icjs.assertInteger.call(void 0, hi - lo, "range span", 0);
+      _chunkS5BKZZGMcjs.assertInteger.call(void 0, hi - lo, "range span", 0);
       return lo + Math.floor(at2(...path) * (hi - lo + 1));
     },
     float: (lo, hi, ...path) => {
-      _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
-      _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, lo, "float lower bound");
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, hi, "float upper bound");
       if (lo > hi) {
-        throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
           `float lower bound must not exceed upper bound; received ${lo} > ${hi}`
         );
       }
-      _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, hi - lo, "float span");
+      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, hi - lo, "float span");
       return lo + at2(...path) * (hi - lo);
     }
   };
@@ -378,8 +413,8 @@ function sameTs(a, b) {
   return a.numerator === b.numerator && a.denominator === b.denominator;
 }
 function fitsQuery(entry, query) {
-  const candidate = _chunkXKSO2V5Icjs.assertRecord.call(void 0, entry, "vocabulary entry");
-  const asked = _chunkXKSO2V5Icjs.assertRecord.call(void 0, query, "vocabulary query");
+  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;
   }
@@ -392,7 +427,7 @@ function fitsQuery(entry, query) {
       return false;
     }
   }
-  if (asked.ts !== void 0 && candidate.ts && !sameTs(candidate.ts, _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, asked.ts, "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 (asked.quality !== void 0 && candidate.fitsOver && !candidate.fitsOver.includes(asked.quality)) {
@@ -407,7 +442,7 @@ function fitsQuery(entry, query) {
   return asked.difficulty === void 0 || candidate.difficulty <= asked.difficulty;
 }
 function selectVocabulary(dictionary, query) {
-  return _chunkXKSO2V5Icjs.assertArray.call(void 0, dictionary, "dictionary").filter(
+  return _chunkS5BKZZGMcjs.assertArray.call(void 0, dictionary, "dictionary").filter(
     (entry) => fitsQuery(entry, query)
   );
 }
@@ -421,12 +456,12 @@ function pickVocabulary(dictionary, query, draw, ...path) {
   return candidates[sampler.range(0, candidates.length - 1, ...path)];
 }
 function mergeVocabulary(builtIn, supplied) {
-  const library = _chunkXKSO2V5Icjs.assertArray.call(void 0, builtIn, "builtIn");
-  const extra = supplied === void 0 || supplied === null ? [] : _chunkXKSO2V5Icjs.assertArray.call(void 0, supplied, "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) => _chunkXKSO2V5Icjs.assertRecord.call(void 0, entry, `${side}[${index}]`).id;
+  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")));
@@ -439,9 +474,9 @@ function mergeVocabulary(builtIn, supplied) {
 }
 function vocabularyOfKind(entries, isMaterial) {
   const out = [];
-  const recognises = _chunkXKSO2V5Icjs.assertFunction.call(void 0, isMaterial, "isMaterial");
-  for (const entry of _chunkXKSO2V5Icjs.assertArray.call(void 0, entries, "entries")) {
-    if (recognises(_chunkXKSO2V5Icjs.assertRecord.call(void 0, entry, "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);
     }
   }
@@ -449,42 +484,42 @@ function vocabularyOfKind(entries, isMaterial) {
 }
 function assertNames(values, allowed, label) {
   if (!Array.isArray(values)) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `${label} must be an array of names; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, values)}`
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${label} must be an array of names; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, values)}`
     );
   }
   values.forEach((value, index) => {
-    _chunkXKSO2V5Icjs.assertOneOf.call(void 0, value, allowed, `${label}[${index}]`);
+    _chunkS5BKZZGMcjs.assertOneOf.call(void 0, value, allowed, `${label}[${index}]`);
   });
 }
 function assertVocabulary(entry, label = "vocabulary entry") {
   if (typeof entry !== "object" || entry === null) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `${label} must be a dictionary entry; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, entry)}`
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${label} must be a dictionary entry; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, entry)}`
     );
   }
-  _chunkXKSO2V5Icjs.assertOneOf.call(void 0, entry.genre, GENRES, `${label} genre`);
-  _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _optionalChain([entry, 'access', _2 => _2.provenance, 'optionalAccess', _3 => _3.basis]), PROVENANCE_BASES, `${label} provenance basis`);
-  assertNames(entry.articulations, _chunkXKSO2V5Icjs.ARTICULATIONS, `${label} articulations`);
+  _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, _chunkYPB3A3EYcjs.chordQualities.call(void 0, ), `${label} fitsOver`);
+    assertNames(entry.fitsOver, _chunk3R3QVKY5cjs.chordQualities.call(void 0, ), `${label} fitsOver`);
   }
   if (entry.ts !== void 0) {
-    _chunkXKSO2V5Icjs.assertTimeSignature.call(void 0, entry.ts, `${label} ts`);
+    _chunkS5BKZZGMcjs.assertTimeSignature.call(void 0, entry.ts, `${label} ts`);
   }
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, entry.difficulty, 1, 5, `${label} difficulty`);
+  _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, _chunkXKSO2V5Icjs.InvalidInputError)(
-        `${label} tempoRange must be a low and a high tempo; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, entry.tempoRange)}`
+      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;
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, low, Number.MIN_VALUE, 1e3, `${label} tempoRange low`);
-    _chunkXKSO2V5Icjs.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;
 }
@@ -506,15 +541,15 @@ function atLevel(table, difficulty) {
   return low + (high - low) * (level - lower);
 }
 function assertDifficulty(difficulty, label = "complexity difficulty") {
-  return _chunkXKSO2V5Icjs.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) {
     return true;
   }
   assertDifficulty(difficulty);
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, bpm, "bpm");
-  if (_chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, stepBeats, "stepBeats") <= 0) {
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, bpm, "bpm");
+  if (_chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, stepBeats, "stepBeats") <= 0) {
     return true;
   }
   const rate = 1 / (stepBeats * secondsPerBeat(bpm));
@@ -525,9 +560,9 @@ function sustainsShift(semitones, stepBeats, bpm, difficulty) {
     return true;
   }
   assertDifficulty(difficulty);
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, bpm, "bpm");
-  _chunkXKSO2V5Icjs.assertFiniteSemitones.call(void 0, semitones);
-  if (_chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, stepBeats, "stepBeats") <= 0) {
+  _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);
@@ -539,20 +574,20 @@ var DEFAULT_SEED = 0;
 var VERSION_SEGMENT = "v";
 function resolveContext(input) {
   if (input !== null && typeof input !== "number" && input !== void 0) {
-    _chunkXKSO2V5Icjs.assertRecord.call(void 0, input, "ctx");
+    _chunkS5BKZZGMcjs.assertRecord.call(void 0, input, "ctx");
   }
   if (input === null) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)("ctx must be a seed or a generation context; received 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 = _chunkXKSO2V5Icjs.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 : _chunkXKSO2V5Icjs.assertRange.call(void 0, complexity.rhythmic, 0, 1, "complexity rhythmic");
-  const harmonic = complexity.harmonic === void 0 ? void 0 : _chunkXKSO2V5Icjs.assertRange.call(void 0, complexity.harmonic, 0, 1, "complexity harmonic");
-  const ornament2 = complexity.ornament === void 0 ? void 0 : _chunkXKSO2V5Icjs.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 : _chunkXKSO2V5Icjs.assertRange.call(void 0, ctx.bpm, Number.MIN_VALUE, 1e3, "bpm");
-  const algorithmVersion = _chunkJ772DL3Bcjs.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(
@@ -568,12 +603,12 @@ function resolveContext(input) {
     algorithmVersion,
     instrument: (part) => _optionalChain([instruments, 'optionalAccess', _4 => _4[part]]),
     vocabulary,
-    part: (name) => supplied ? drawsFrom(supplied, name, VERSION_SEGMENT, algorithmVersion) : drawsFrom(_chunkJ772DL3Bcjs.createPositionalRng.call(void 0, _chunkJ772DL3Bcjs.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 supplied = sugar.ornament === void 0 ? void 0 : _chunkXKSO2V5Icjs.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 };
 }
@@ -590,14 +625,14 @@ function placeAboveBass(pc, bassMidi) {
   return foldIntoBand(pc + 12 * Math.round((bassMidi - pc) / 12), bassMidi);
 }
 function placeRoot(pc, low) {
-  return low + _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pc - low);
+  return low + _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pc - low);
 }
 function barTiles(startBeat, endBeat, ts) {
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, 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 - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (tileStart >= endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
       break;
     }
     tiles.push({ startBeat: tileStart, endBeat: Math.min(tileStart + barBeats, endBeat) });
@@ -605,8 +640,8 @@ function barTiles(startBeat, endBeat, ts) {
   return tiles;
 }
 function midBarPulse(barStart, ts) {
-  const pulse2 = _chunkXKSO2V5Icjs.pulseBeats.call(void 0, ts);
-  return barStart + Math.floor((_chunkXKSO2V5Icjs.beatsPerBar.call(void 0, ts) / 2 + _chunkXKSO2V5Icjs.BEAT_EPS) / pulse2) * pulse2;
+  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) {
@@ -614,14 +649,14 @@ function assertBassSegments(segments) {
     if (segment === void 0) {
       continue;
     }
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, segment.startBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].startBeat`);
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, segment.endBeat, 0, Number.MAX_SAFE_INTEGER, `segments[${index}].endBeat`);
+    _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, _chunkXKSO2V5Icjs.InvalidInputError)(`segments[${index}] must have a positive duration`);
+      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 - _chunkXKSO2V5Icjs.BEAT_EPS) {
-      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+    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`
       );
     }
@@ -631,22 +666,22 @@ function chordTonePcs(chord) {
   const seen = /* @__PURE__ */ new Set();
   const pcs = [];
   for (const interval of chord.intervals) {
-    const pc = _chunkXKSO2V5Icjs.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(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc));
+    pcs.push(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc));
   }
   return pcs;
 }
 function fifthPcOf2(chord) {
-  return _nullishCoalesce(_chunkYPB3A3EYcjs.fifthPcOf.call(void 0, chord), () => ( _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc)));
+  return _nullishCoalesce(_chunk3R3QVKY5cjs.fifthPcOf.call(void 0, chord), () => ( _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, chord.rootPc)));
 }
 function bassPcOf(chord) {
-  return _chunkXKSO2V5Icjs.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);
@@ -656,19 +691,19 @@ function bassToneCycle(chord) {
 }
 function beatPositions(start, end, ts) {
   const positions = [];
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, ts);
-  const pulse2 = _chunkXKSO2V5Icjs.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 - _chunkXKSO2V5Icjs.BEAT_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 - _chunkXKSO2V5Icjs.BEAT_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 - _chunkXKSO2V5Icjs.BEAT_EPS || position >= end - _chunkXKSO2V5Icjs.BEAT_EPS) {
+      if (position >= barStart + barBeats - _chunkS5BKZZGMcjs.BEAT_EPS || position >= end - _chunkS5BKZZGMcjs.BEAT_EPS) {
         break;
       }
-      if (position >= start - _chunkXKSO2V5Icjs.BEAT_EPS) {
+      if (position >= start - _chunkS5BKZZGMcjs.BEAT_EPS) {
         positions.push(position);
       }
     }
@@ -686,7 +721,7 @@ function bandFloor(low, instrument) {
   if (!instrument) {
     return low;
   }
-  const range = _chunkJ772DL3Bcjs.instrumentRange.call(void 0, instrument);
+  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));
 }
@@ -705,12 +740,12 @@ function neighborOnSide(target, dir, key, chromatic) {
   if (chromatic) {
     return semitone;
   }
-  const cand = _chunkYPB3A3EYcjs.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 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 : _chunkJ772DL3Bcjs.toStringedProfile.call(void 0, given, "instrument");
+  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) };
 }
 
@@ -719,31 +754,31 @@ var BAR_STEPS = 16;
 var BEAT_STEPS = 4;
 var STEP_BEATS = 1 / BEAT_STEPS;
 function assertGridEvents(events) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, events, "figure events");
+  _chunkS5BKZZGMcjs.assertArray.call(void 0, events, "figure events");
   events.forEach((event, index) => {
-    _chunkXKSO2V5Icjs.assertRecord.call(void 0, event, `figure events[${index}]`);
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, event.step, `figure events[${index}].step`);
+    _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 _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, spanSteps, "figure span steps");
+  return _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, spanSteps, "figure span steps");
 }
 function streamOf(event) {
   return _nullishCoalesce(_nullishCoalesce(event.limb, () => ( event.voice)), () => ( ""));
 }
 var FIGURE_TS = { numerator: 4, denominator: 4 };
 function subdivisionBeats(ts) {
-  const pulse2 = _chunkXKSO2V5Icjs.pulseBeats.call(void 0, ts);
-  return _chunkXKSO2V5Icjs.isCompound.call(void 0, ts) ? pulse2 / 3 : pulse2 / 2;
+  const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts);
+  return _chunkS5BKZZGMcjs.isCompound.call(void 0, ts) ? pulse2 / 3 : pulse2 / 2;
 }
 function gridMetricWeight(step, ts) {
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, step, "step");
-  return stepWeight(step, _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "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 = _chunkXKSO2V5Icjs.metricWeight.call(void 0, beats, ts);
+  const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, beats, ts);
   if (weight > 0) {
     return weight + 1;
   }
@@ -753,8 +788,8 @@ function stepWeight(step, ts) {
 }
 function thin(events, amount, ts) {
   const figure = assertGridEvents(events);
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, amount, 0, 1, "thin amount");
-  const signature = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
+  _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 figure.filter((event) => stepWeight(event.step, signature) >= floor);
 }
@@ -806,10 +841,10 @@ function syncopate(events, amount, draw, ...path) {
   const figure = assertGridEvents(events);
   const sampler = assertDraw(draw);
   assertSeedPath(path);
-  const asked = typeof amount === "number" ? void 0 : _chunkXKSO2V5Icjs.assertRecord.call(void 0, amount, "amount");
+  const asked = typeof amount === "number" ? void 0 : _chunkS5BKZZGMcjs.assertRecord.call(void 0, amount, "amount");
   const dial = asked === void 0 ? amount : asked.amount;
-  const signature = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(_optionalChain([asked, 'optionalAccess', _7 => _7.ts]), () => ( FIGURE_TS)), "ts"));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, dial, 0, 1, "syncopate 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) {
@@ -826,10 +861,10 @@ function syncopate(events, amount, draw, ...path) {
 }
 function ornamentBy(events, isOrnament, amount, draw, ...path) {
   const figure = assertGridEvents(events);
-  const marks = _chunkXKSO2V5Icjs.assertFunction.call(void 0, isOrnament, "isOrnament");
+  const marks = _chunkS5BKZZGMcjs.assertFunction.call(void 0, isOrnament, "isOrnament");
   const sampler = assertDraw(draw);
   assertSeedPath(path);
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, amount, 0, 1, "ornament amount");
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, amount, 0, 1, "ornament amount");
   return figure.filter(
     (event) => !marks(event) || sampler.prob(amount, ...path, "ornament", event.step)
   );
@@ -837,14 +872,14 @@ function ornamentBy(events, isOrnament, amount, draw, ...path) {
 var NEUTRAL_RHYTHMIC = 0.5;
 function deform(events, opts, draw, ...path) {
   const figure = assertGridEvents(events);
-  const asked = _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "opts");
+  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 = _chunkXKSO2V5Icjs.assertRange.call(void 0, asked.rhythmic, 0, 1, "complexity rhythmic");
+    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, ts);
     } else if (rhythmic > NEUTRAL_RHYTHMIC) {
@@ -857,7 +892,7 @@ function deform(events, opts, draw, ...path) {
     }
   }
   if (asked.ornament !== void 0 && asked.isOrnament) {
-    const isOrnament = _chunkXKSO2V5Icjs.assertFunction.call(void 0, asked.isOrnament, "opts.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);
@@ -867,7 +902,7 @@ function withinCeiling(events, bpm, difficulty) {
   if (difficulty === void 0 || bpm === void 0) {
     return true;
   }
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, bpm, "bpm");
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, bpm, "bpm");
   assertDifficulty(difficulty);
   if (figure.length < 2) {
     return true;
@@ -905,8 +940,8 @@ function impliedScaleTones(chord) {
   if (chordDegreeSemitone(7, chord) === void 0) {
     return void 0;
   }
-  for (const match of _chunkR7B5N2JKcjs.chordScales.call(void 0, chord)) {
-    const mask = _chunkYPB3A3EYcjs.namedScaleMask.call(void 0, match.name);
+  for (const match of _chunkPM4XJE2Ycjs.chordScales.call(void 0, chord)) {
+    const mask = _chunk3R3QVKY5cjs.namedScaleMask.call(void 0, match.name);
     if (mask === void 0) {
       continue;
     }
@@ -926,7 +961,7 @@ function replacedDegreeSemitone(degree, chord) {
   if (degree !== 3) {
     return void 0;
   }
-  const sounds = (semitones) => chord.intervals.some((interval) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, interval) === semitones);
+  const sounds = (semitones) => chord.intervals.some((interval) => _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, interval) === semitones);
   if (sounds(3) || sounds(4)) {
     return void 0;
   }
@@ -938,12 +973,12 @@ function degreeSemitone(degree, alter, chord, key, implied) {
   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.
-  _chunkYPB3A3EYcjs.nearestScaleTone.call(void 0, chord.rootPc + template, key) - chord.rootPc));
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, semitone) + 12 * octaves + alter;
+  _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 (_chunkYPB3A3EYcjs.degreeOfInterval.call(void 0, interval, chord) === degree) {
+    if (_chunk3R3QVKY5cjs.degreeOfInterval.call(void 0, interval, chord) === degree) {
       return interval;
     }
   }
@@ -1173,28 +1208,28 @@ var BASS_LICKS = deepFreeze([
 var DEFAULT_BPM = 120;
 var DEFAULT_LICK_DENSITY = 0.6;
 function placeLicks(timeline, key, opts) {
-  const asked = _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "opts");
-  const placement = _chunkXKSO2V5Icjs.assertArray.call(void 0, 
+  const asked = _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "opts");
+  const placement = _chunkS5BKZZGMcjs.assertArray.call(void 0, 
     timeline,
     "timeline"
   );
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, placement.length, "lick segments", asked.budget);
-  const genre = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, asked.genre, GENRES, "lick genre");
-  const ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS)), "ts"));
+  _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));
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, octave, "lick octave", -1, 8);
-  const scale = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key);
-  const segments = placement.map((segment) => ({ ...segment, chord: _chunkYPB3A3EYcjs.toChordData.call(void 0, segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
+  _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 barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, ts);
+  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
   );
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, estimatedBars, "lick bars", asked.budget);
+  _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));
@@ -1254,7 +1289,7 @@ function placeLicks(timeline, key, opts) {
       }
       raw.push({ startBeat: rootAt, pitch: rootMidi, velocity: STRONG_VELOCITY });
       if (notes) {
-        const figureRoot = segment.chord.bassPc === void 0 ? placePc(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, segment.chord.rootPc), rootMidi, low) : placeAboveBass(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, segment.chord.rootPc), rootMidi);
+        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(
@@ -1264,12 +1299,12 @@ function placeLicks(timeline, key, opts) {
             scale,
             implied
           );
-          const pitch = Math.abs(at2 - rootAt) < _chunkXKSO2V5Icjs.BEAT_EPS && lickNote.degree === 1 && (_nullishCoalesce(lickNote.alter, () => ( 0))) === 0 ? rootMidi : figureRoot + offset;
+          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,
             velocity: Math.round(
-              (_chunkXKSO2V5Icjs.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
           });
@@ -1280,7 +1315,7 @@ function placeLicks(timeline, key, opts) {
     if (next && lastTilePlayed) {
       const lastBeat = next.startBeat - STEP_BEATS * BEAT_STEPS;
       const approachAt = _nullishCoalesce(materialOnsetIn(playedTile, lastBeat, next.startBeat), () => ( lastBeat));
-      if (approachAt > firstOnset + _chunkXKSO2V5Icjs.BEAT_EPS) {
+      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);
@@ -1310,12 +1345,12 @@ function placeLicks(timeline, key, opts) {
       nextStart - item.startBeat,
       written === void 0 ? Number.POSITIVE_INFINITY : written * STEP_BEATS
     );
-    if (durationBeat <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (durationBeat <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
-    const placed = instrument ? _chunkJ772DL3Bcjs.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: _chunkXKSO2V5Icjs.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))
@@ -1330,7 +1365,7 @@ function placeLicks(timeline, key, opts) {
 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) < _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (item !== void 0 && Math.abs(item.startBeat - at2) < _chunkS5BKZZGMcjs.BEAT_EPS) {
       return item;
     }
   }
@@ -1343,7 +1378,7 @@ function materialOnsetIn(played, from, to) {
   let last;
   for (const note2 of played.material.notes) {
     const at2 = played.tileStart + note2.step * STEP_BEATS;
-    if (at2 < from - _chunkXKSO2V5Icjs.BEAT_EPS || at2 > to - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (at2 < from - _chunkS5BKZZGMcjs.BEAT_EPS || at2 > to - _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
     last = last === void 0 ? at2 : Math.max(last, at2);
@@ -1353,7 +1388,7 @@ function materialOnsetIn(played, from, to) {
 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 - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (item !== void 0 && item.startBeat < at2 - _chunkS5BKZZGMcjs.BEAT_EPS) {
       return item.pitch;
     }
   }
@@ -1366,7 +1401,7 @@ function anchorStepOf(material, spanBeats) {
       first = note2.step;
     }
   }
-  if (first === void 0 || first < 0 || first * STEP_BEATS >= spanBeats - _chunkXKSO2V5Icjs.BEAT_EPS) {
+  if (first === void 0 || first < 0 || first * STEP_BEATS >= spanBeats - _chunkS5BKZZGMcjs.BEAT_EPS) {
     return 0;
   }
   return first;
@@ -1393,7 +1428,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 - _chunkXKSO2V5Icjs.BEAT_EPS);
+  const inside = deformed.filter((lickNote) => lickNote.step < spanSteps - _chunkS5BKZZGMcjs.BEAT_EPS);
   if (inside.length === 0 || !withinCeiling(inside, bpm, difficulty)) {
     return void 0;
   }
@@ -1411,15 +1446,15 @@ var BASS_STYLES = Object.freeze([
 var DEFAULT_STYLE = "root";
 var DEFAULT_PICKUP_DENSITY = 0.35;
 function sounding(ctx, placed) {
-  return ctx.instrument ? _chunkJ772DL3Bcjs.foldIntoRange.call(void 0, placed, ctx.instrument) : 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 = _chunkXKSO2V5Icjs.clampToMidi.call(void 0, _nullishCoalesce(midiOverride, () => ( placeTone(ctx, pc))), "generated bass pitch");
+  const placed = _chunkS5BKZZGMcjs.clampToMidi.call(void 0, _nullishCoalesce(midiOverride, () => ( placeTone(ctx, pc))), "generated bass pitch");
   const midi = sounding(ctx, placed);
-  const velocity = _chunkXKSO2V5Icjs.isStrongBeat.call(void 0, pos, ctx.ts) ? STRONG_VELOCITY : WEAK_VELOCITY;
+  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;
@@ -1431,7 +1466,7 @@ function buildRootFifth(ctx, seg) {
   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 + _chunkXKSO2V5Icjs.BEAT_EPS && answer < tile.endBeat - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (answer > tile.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && answer < tile.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
       emit(ctx, answer, fifthPcOf2(seg.chord));
     }
   }
@@ -1441,7 +1476,7 @@ function buildPop(ctx, seg, index) {
   const rootPc = bassPcOf(seg.chord);
   let emitted = false;
   for (const pos of positions) {
-    if (_chunkXKSO2V5Icjs.isStrongBeat.call(void 0, pos, ctx.ts)) {
+    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)) {
@@ -1502,7 +1537,7 @@ function buildWalking(ctx, seg, next, index) {
     if (next && count > 1 && i === count - 1) {
       const nextBass = placeRoot(bassPcOf(next.chord), ctx.low);
       const midi = approachNote2(ctx, nextBass, ctx.prevMidi, index);
-      emit(ctx, pos, _chunkXKSO2V5Icjs.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)));
@@ -1510,29 +1545,29 @@ function buildWalking(ctx, seg, next, index) {
   });
 }
 function generateBassLine(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "bass line options");
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, opts.segments, "bass segments");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, opts.segments.length, "bass segments", opts.budget);
-  const segments = opts.segments.map((segment) => ({ ...segment, chord: _chunkYPB3A3EYcjs.toChordData.call(void 0, segment.chord) })).sort((a, b) => a.startBeat - b.startBeat);
+  _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 = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS)), "ts"));
-  const style = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _nullishCoalesce(opts.style, () => ( DEFAULT_STYLE)), BASS_STYLES, "bass style");
+  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));
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, octave, "bass octave", -1, 8);
+  _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
   );
-  _chunkXKSO2V5Icjs.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 { instrument, low } = bassRegister(resolved.instrument("bass"), opts.instrument, octave);
   const ctx = {
     ts,
     low,
-    key: _chunkYPB3A3EYcjs.toKeyScale.call(void 0, opts.key),
+    key: _chunk3R3QVKY5cjs.toKeyScale.call(void 0, opts.key),
     draw: resolved.part("bass"),
     notes: [],
     rootMidi: low,
@@ -1578,11 +1613,11 @@ function generateBassLine(opts) {
     }
     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 <= _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (durationBeat <= _chunkS5BKZZGMcjs.BEAT_EPS) {
       continue;
     }
     out.push({
-      pitch: _chunkXKSO2V5Icjs.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
@@ -1599,31 +1634,31 @@ function degreesOf(interval) {
 }
 function assertPlayable(pitch) {
   if (pitch < 0 || pitch > 127) {
-    throw new (0, _chunkXKSO2V5Icjs.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) {
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, lead, "imitate lead", { allowNonPositiveDuration: true });
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "opts");
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, opts.atBeat, "atBeat");
-  const interval = _chunkXKSO2V5Icjs.toSpelledInterval.call(void 0, opts.interval);
-  const key = _chunkYPB3A3EYcjs.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) {
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, opts.from, "from");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, opts.from, "from");
   }
   if (opts.to !== void 0) {
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, opts.to, "to");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, opts.to, "to");
   }
   if (from > to) {
-    throw new (0, _chunkXKSO2V5Icjs.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));
-  _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, velocityScale, "velocityScale");
-  const tonal = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _nullishCoalesce(opts.answer, () => ( "real")), IMITATION_ANSWERS, "imitate answer") === "tonal";
-  const subject = _chunkXKSO2V5Icjs.dropSilentNotes.call(void 0, lead).filter((note2) => note2.startBeat >= from && note2.startBeat < to).sort((a, b) => a.startBeat - b.startBeat);
+  _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) {
@@ -1637,14 +1672,14 @@ function imitate(lead, opts) {
     let offset = 0;
     if (invert) {
       if (tonal) {
-        const here = _chunkYPB3A3EYcjs.scaleLadderPosition.call(void 0, pitch, key);
-        pitch = _chunkYPB3A3EYcjs.scaleLadderPitch.call(void 0, 2 * _chunkYPB3A3EYcjs.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 ? _chunkYPB3A3EYcjs.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),
@@ -1669,7 +1704,7 @@ var DEFAULT_MELODY_VELOCITY = 96;
 var VELOCITY_DROP = 16;
 var TIE_BREAK_JITTER = 1e-6;
 function isWholeBeat(beat) {
-  return Math.abs(beat - Math.round(beat)) < _chunkXKSO2V5Icjs.BEAT_EPS;
+  return Math.abs(beat - Math.round(beat)) < _chunkS5BKZZGMcjs.BEAT_EPS;
 }
 function melodyNoteAt(melody, beat) {
   return _optionalChain([melody, 'access', _24 => _24.at, 'call', _25 => _25(beat), 'optionalAccess', _26 => _26.note]);
@@ -1682,8 +1717,8 @@ function melodySnapshotAt(melody, beat) {
   if (current === void 0) {
     return void 0;
   }
-  const attacked = Math.abs(current.startBeat - beat) < _chunkXKSO2V5Icjs.BEAT_EPS;
-  const previous = attacked ? melodyNoteAt(melody, beat - _chunkXKSO2V5Icjs.BEAT_EPS * 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;
@@ -1699,7 +1734,7 @@ 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 - _chunkXKSO2V5Icjs.BEAT_EPS; beat += GRID_STEP) {
+  for (let beat = gridStart; beat < spanEnd - _chunkS5BKZZGMcjs.BEAT_EPS; beat += GRID_STEP) {
     const attacked = melodyAttacksAt(melody, beat);
     const sounding2 = melodyNoteAt(melody, beat) !== void 0;
     let place = false;
@@ -1707,10 +1742,10 @@ function complementOnsets(melody, ts, spanStart, spanEnd, draw) {
       place = isWholeBeat(beat);
     } else if (!attacked) {
       place = draw.prob(isWholeBeat(beat) ? HOLD_ON_BEAT_PROB : HOLD_OFF_BEAT_PROB, "hold", beat);
-    } else if (_chunkXKSO2V5Icjs.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 - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    if (place && beat - last >= MIN_ONSET_GAP - _chunkS5BKZZGMcjs.BEAT_EPS) {
       onsets.push(beat);
       last = beat;
     }
@@ -1731,12 +1766,12 @@ function assertWeightOverrides(overrides) {
     return;
   }
   if (typeof overrides !== "object" || overrides === null) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `countermelody weights must be an object of weight overrides; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, overrides)}`
+    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)) {
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, value, `countermelody weights.${field}`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, value, `countermelody weights.${field}`);
   }
 }
 function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weights) {
@@ -1751,7 +1786,7 @@ function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weig
       score += weights.dissonance;
     }
   }
-  if (chord && _chunkYPB3A3EYcjs.chordToneRole.call(void 0, pitch, chord) !== null) {
+  if (chord && _chunk3R3QVKY5cjs.chordToneRole.call(void 0, pitch, chord) !== null) {
     score += weights.chordTone;
   }
   if (prevPitch !== void 0) {
@@ -1761,7 +1796,7 @@ function scoreCandidate(pitch, melPitch, melPrev, prevPitch, chord, center, weig
     if (dist > 0 && dist <= 2) {
       score += weights.stepwise;
     }
-    if (_chunkYPB3A3EYcjs.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) {
@@ -1786,12 +1821,12 @@ function heldNoteBoundaries(melody, startBeat, endBeat, chordChangeBeats) {
     boundaries.add(onset);
   }
   for (const beat of chordChangeBeats) {
-    if (beat > startBeat + _chunkXKSO2V5Icjs.BEAT_EPS && beat < endBeat - _chunkXKSO2V5Icjs.BEAT_EPS) {
+    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 - _chunkXKSO2V5Icjs.BEAT_EPS; 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);
@@ -1804,8 +1839,8 @@ function boundaryContexts(melody, harmony, startBeat, endBeat, ts) {
       melodyVoice,
       otherVoices: melodyVoice === void 0 ? [] : [melodyVoice],
       chord: harmony.chordAt(boundary),
-      strongBeat: _chunkXKSO2V5Icjs.isStrongBeat.call(void 0, boundary, ts),
-      atCounterOnset: Math.abs(boundary - startBeat) < _chunkXKSO2V5Icjs.BEAT_EPS
+      strongBeat: _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, boundary, ts),
+      atCounterOnset: Math.abs(boundary - startBeat) < _chunkS5BKZZGMcjs.BEAT_EPS
     };
   });
 }
@@ -1816,7 +1851,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 = _chunkYPB3A3EYcjs.evaluateSafety.call(void 0, 
+    const result = _chunk3R3QVKY5cjs.evaluateSafety.call(void 0, 
       {
         profile,
         candidatePitch: pitch,
@@ -1838,51 +1873,51 @@ function heldPitchSafety(pitch, contexts, prevPitch, key, profile, register, low
   return worst;
 }
 function generateCounterMelody(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "countermelody options");
+  _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, _chunkXKSO2V5Icjs.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"));
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, opts.melody, "countermelody melody", { allowNonPositiveDuration: true });
-  const melody = _chunkTT6PKMPRcjs.createNoteEventIndex.call(void 0, _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS2)), "ts"));
-  _chunkXKSO2V5Icjs.assertTimeSignature.call(void 0, ts);
-  const rhythm = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _nullishCoalesce(opts.rhythm, () => ( "complement")), ["complement", "follow"], "rhythm");
-  const profile = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _nullishCoalesce(opts.profile, () => ( "pop")), ["strict", "pop"], "safety profile");
+  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 = _chunkYPB3A3EYcjs.profileWeights.call(void 0, profile, opts.weights);
-  const key = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, opts.key);
+  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', _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);
-  _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.clampToMidi.call(void 0, 
+  const low = _chunkS5BKZZGMcjs.clampToMidi.call(void 0, 
     _nullishCoalesce(opts.pitchLow, () => ( Math.round(defaultCenter) - DEFAULT_HALF_RANGE)),
     "countermelody pitchLow"
   );
-  const high = _chunkXKSO2V5Icjs.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, _chunkXKSO2V5Icjs.InvalidInputError)(
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
       `countermelody pitchLow must not exceed pitchHigh; received ${low} > ${high}`
     );
   }
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, high - low + 1, "countermelody pitch candidates");
-  _chunkXKSO2V5Icjs.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) {
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, 
+    _chunkS5BKZZGMcjs.assertRange.call(void 0, 
       _nullishCoalesce(chordChangeBeats[index], () => ( Number.NaN)),
       0,
       Number.MAX_SAFE_INTEGER,
@@ -1892,7 +1927,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;
-  _chunkXKSO2V5Icjs.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
@@ -1913,14 +1948,14 @@ function generateCounterMelody(opts) {
     const contexts = boundaryContexts(melody, { chordAt, chordChangeBeats }, beat, endBeat, ts);
     const chord = _nullishCoalesce(_optionalChain([contexts, 'access', _33 => _33[0], 'optionalAccess', _34 => _34.chord]), () => ( chordAt(beat)));
     const otherVoices = melodyVoice !== void 0 ? [melodyVoice] : [];
-    const candidates = _chunkYPB3A3EYcjs.enumerateSafePitches.call(void 0, 
+    const candidates = _chunk3R3QVKY5cjs.enumerateSafePitches.call(void 0, 
       {
         profile,
         prevPitch,
         chord,
         key,
         otherVoices,
-        strongBeat: _chunkXKSO2V5Icjs.isStrongBeat.call(void 0, beat, ts),
+        strongBeat: _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, beat, ts),
         vocalLow: low,
         vocalHigh: high
       },
@@ -1947,7 +1982,7 @@ 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.
-        _chunkYPB3A3EYcjs.createsParallelPerfect.call(void 0, prevPitch, candidate, melPrev, melPitch)) {
+        _chunk3R3QVKY5cjs.createsParallelPerfect.call(void 0, prevPitch, candidate, melPrev, melPitch)) {
           continue;
         }
       }
@@ -1969,7 +2004,7 @@ function generateCounterMelody(opts) {
       Math.min(127, Math.round((_nullishCoalesce(_optionalChain([melNote, 'optionalAccess', _35 => _35.velocity]), () => ( DEFAULT_MELODY_VELOCITY))) - VELOCITY_DROP))
     );
     out.push({
-      pitch: _chunkXKSO2V5Icjs.clampToMidi.call(void 0, pitch),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, pitch),
       startBeat: beat,
       durationBeat: endBeat - beat,
       velocity
@@ -2566,10 +2601,10 @@ function generateHiHatForBeat(ctx, sec) {
 
 // src/generate/drums/euclid.ts
 function euclideanRhythm(pulses, steps, rotation = 0) {
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, steps, "euclidean steps");
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, pulses, "euclidean pulses");
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, rotation, "euclidean rotation");
-  _chunkXKSO2V5Icjs.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;
@@ -2905,7 +2940,7 @@ function drumNoteOf(voice) {
   return Object.hasOwn(DRUM_NOTES, voice) ? DRUM_NOTES[voice] : void 0;
 }
 function drumVoiceOf(pitch) {
-  return VOICE_BY_NOTE.get(_chunkXKSO2V5Icjs.assertMidiPitch.call(void 0, 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); }
@@ -3216,12 +3251,12 @@ var KIT_ARTICULATIONS = Object.freeze([
 var DRUM_KIT = Object.freeze({
   kind: "percussion",
   name: "drum kit",
-  limbs: _chunkJ772DL3Bcjs.LIMBS,
+  limbs: _chunkCGBADIO5cjs.LIMBS,
   reach: deepFreeze(reachByNote()),
   overdub: deepFreeze(OVERDUB_VOICES.map((voice) => DRUM_NOTES[voice])),
   articulations: KIT_ARTICULATIONS,
   // One stroke per limb, and one more per voice dubbed over them.
-  polyphony: _chunkJ772DL3Bcjs.LIMBS.length + OVERDUB_VOICES.length
+  polyphony: _chunkCGBADIO5cjs.LIMBS.length + OVERDUB_VOICES.length
 });
 
 // src/generate/drums/vocabulary.ts
@@ -3232,8 +3267,8 @@ function isDrumPattern(material) {
 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, _chunkXKSO2V5Icjs.InvalidInputError)(
-        `${label} strokes[${index}].voice must name a drum voice; received ${_chunkXKSO2V5Icjs.describeRejected.call(void 0, _optionalChain([stroke, 'optionalAccess', _44 => _44.voice]))}`
+      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]))}`
       );
     }
   });
@@ -3425,21 +3460,21 @@ var DEFAULT_VELOCITY = 100;
 var DEFAULT_BPM2 = 120;
 var MAX_STROKES_PER_BAR = 64;
 function placeDrumPattern(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "drum pattern options");
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, opts.bars, "drum pattern bars");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, opts.bars * MAX_STROKES_PER_BAR, "drum pattern hits", opts.budget);
-  const genre = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.genre, GENRES, "drum pattern genre");
-  const section = opts.section === void 0 ? void 0 : _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.section, PUBLIC_SECTIONS, "drum pattern section");
-  const ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( FOUR_FOUR2)), "ts"));
+  _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) {
-    _chunkXKSO2V5Icjs.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" : _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.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 supplied = vocabularyOfKind(resolved.vocabulary, isDrumPattern);
@@ -3448,8 +3483,8 @@ function placeDrumPattern(opts) {
   });
   const dictionary = mergeVocabulary(DRUM_PATTERNS, supplied);
   if (selectVocabulary(dictionary, { ts }).length === 0) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `drum pattern ts names a meter no figure is written in: ${_chunkXKSO2V5Icjs.formatTimeSignature.call(void 0, ts)}. The built-in figures are written in 4/4; supply vocabulary in another meter through the context.`
+    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();
@@ -3514,26 +3549,26 @@ function placeDrumPattern(opts) {
     }
   }
   const endBeat = opts.bars * barBeats;
-  return track.hits.filter((h) => h.startBeat < endBeat && (kit === void 0 || _chunkJ772DL3Bcjs.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) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "drum options");
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, opts.bars, "drum bars");
-  _chunkXKSO2V5Icjs.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));
-    _chunkXKSO2V5Icjs.assertInteger.call(void 0, steps, "euclidean steps", 1, 16);
-    _chunkXKSO2V5Icjs.assertInteger.call(void 0, opts.euclideanKick.pulses, "euclidean pulses");
-    _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.style, GROOVE_STYLES, "drum style");
-  const publicSection = _chunkXKSO2V5Icjs.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) {
-    _chunkXKSO2V5Icjs.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);
@@ -3544,18 +3579,18 @@ function generateDrums(opts) {
   const difficulty = resolved.difficulty;
   const mapping = mapStyle(publicStyle);
   const style = mapping.style;
-  const feel = opts.feel === void 0 ? mapping.feel : _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.feel, DRUM_FEELS, "drum feel");
-  const role = opts.role === void 0 ? "full" : _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.role, DRUM_ROLES, "drum role");
-  const meters = _chunkXKSO2V5Icjs.resolveMeters.call(void 0, { ts: opts.ts }, "ts");
+  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, _chunkXKSO2V5Icjs.InvalidInputError)(
+      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 ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, meters);
-  const barBeats = _chunkXKSO2V5Icjs.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);
@@ -3748,7 +3783,7 @@ function underCeiling(hits, bpm, difficulty, exempt) {
   return kept;
 }
 function playableOn(kit, pitch) {
-  return kit === void 0 || _chunkJ772DL3Bcjs.canSound.call(void 0, kit, pitch);
+  return kit === void 0 || _chunkCGBADIO5cjs.canSound.call(void 0, kit, pitch);
 }
 
 // src/generate/groove/index.ts
@@ -3763,24 +3798,24 @@ var MAX_METRIC_WEIGHT = 3;
 var MIN_VELOCITY = 1;
 var MAX_VELOCITY = 127;
 function humanize(events, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  const ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS3)), "ts"));
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, events, "humanize events", { allowNonPositiveDuration: true });
-  const sounding2 = _chunkXKSO2V5Icjs.dropSilentNotes.call(void 0, events);
+  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));
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, timing, 0, Number.MAX_SAFE_INTEGER, "humanize timing");
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, velocityJitter, 0, 127, "humanize velocity jitter");
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, accent2, 0, 127, "humanize accent");
-  _chunkXKSO2V5Icjs.assertRange.call(void 0, baseVelocity, 0, 127, "humanize 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 = _chunkXKSO2V5Icjs.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,
@@ -3809,18 +3844,18 @@ function quantizeToGrid(beat, barBeats, subdivision, slotsPerBar) {
   };
 }
 function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVISION) {
-  const meter = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, events, "groove source events", { allowNonPositiveDuration: true });
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, subdivision, "groove subdivision");
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, meter);
+  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);
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, slotsPerBar, "groove template slots");
-  _chunkXKSO2V5Icjs.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 _chunkXKSO2V5Icjs.dropSilentNotes.call(void 0, events)) {
+  for (const event of _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, events)) {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -3850,24 +3885,24 @@ function extractGrooveTemplate(events, ts, subdivision = DEFAULT_GROOVE_SUBDIVIS
   return { subdivision, slotsPerBar, slots, ts: meter };
 }
 function applyGrooveTemplate(events, template, ts) {
-  const meter = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, events, "groove target events", { allowNonPositiveDuration: true });
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, template.subdivision, "template subdivision");
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, template.slotsPerBar, "template slotsPerBar");
-  _chunkXKSO2V5Icjs.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, _chunkXKSO2V5Icjs.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, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `Groove template meter ${_chunkXKSO2V5Icjs.formatTimeSignature.call(void 0, template.ts)} does not match apply-time meter ${_chunkXKSO2V5Icjs.formatTimeSignature.call(void 0, meter)}`
+    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)}`
     );
   }
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, meter);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, meter);
   const expectedSlots = Math.ceil(barBeats * template.subdivision);
   if (template.slotsPerBar !== expectedSlots) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
-      `Groove template slotsPerBar ${template.slotsPerBar} does not match ${expectedSlots} slots per bar of ${_chunkXKSO2V5Icjs.formatTimeSignature.call(void 0, meter)} at subdivision ${template.subdivision}`
+    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}`
     );
   }
   for (let index = 0; index < template.slots.length; index += 1) {
@@ -3875,12 +3910,12 @@ function applyGrooveTemplate(events, template, ts) {
     if (slot === void 0) {
       continue;
     }
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, slot.timingOffset, `template slots[${index}].timingOffset`);
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, slot.timingOffset, `template slots[${index}].timingOffset`);
     if (slot.velocity !== null && slot.velocity !== void 0) {
-      _chunkXKSO2V5Icjs.assertRange.call(void 0, slot.velocity, 0, 127, `template slots[${index}].velocity`);
+      _chunkS5BKZZGMcjs.assertRange.call(void 0, slot.velocity, 0, 127, `template slots[${index}].velocity`);
     }
   }
-  return _chunkXKSO2V5Icjs.dropSilentNotes.call(void 0, events).map((event) => {
+  return _chunkS5BKZZGMcjs.dropSilentNotes.call(void 0, events).map((event) => {
     const { quantizedBeat, slotIndex } = quantizeToGrid(
       event.startBeat,
       barBeats,
@@ -3897,7 +3932,7 @@ function applyGrooveTemplate(events, template, ts) {
 // src/generate/harmonize/nct.ts
 function snapToPulse(beat, pulse2) {
   const snapped = Math.round(beat / pulse2) * pulse2;
-  return Math.abs(snapped - beat) <= _chunkQ6R3QAZDcjs.HUMANIZE_ADJACENCY ? snapped : beat;
+  return Math.abs(snapped - beat) <= _chunkIFZDWIKMcjs.HUMANIZE_ADJACENCY ? snapped : beat;
 }
 var STEP_SEMITONES = 2;
 function isStep(a, b) {
@@ -3911,9 +3946,9 @@ function sameDirection(prev, note2, next) {
   return prev !== note2 && next !== note2 && note2 - prev > 0 === next - note2 > 0;
 }
 function classifyMelodyTones(melody, ts) {
-  const meter = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, melody, "melody notes", { allowNonPositiveDuration: true });
-  const pulse2 = _chunkXKSO2V5Icjs.pulseBeats.call(void 0, meter);
+  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, meter, pulse2);
     return { noteIndex: index, role, ornamental: role !== "structural" };
@@ -3928,12 +3963,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 > _chunkQ6R3QAZDcjs.HUMANIZE_ADJACENCY || outOfNote > _chunkQ6R3QAZDcjs.HUMANIZE_ADJACENCY) {
+  if (intoNote > _chunkIFZDWIKMcjs.HUMANIZE_ADJACENCY || outOfNote > _chunkIFZDWIKMcjs.HUMANIZE_ADJACENCY) {
     return "structural";
   }
-  const weight = _chunkXKSO2V5Icjs.metricWeight.call(void 0, snapToPulse(note2.startBeat, pulse2), ts);
-  const weightPrev = _chunkXKSO2V5Icjs.metricWeight.call(void 0, snapToPulse(prev.startBeat, pulse2), ts);
-  const weightNext = _chunkXKSO2V5Icjs.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)) {
@@ -3965,12 +4000,12 @@ var FALLBACK = {
   quality: "maj",
   secondaryDominant: false,
   base: 0,
-  pcs: _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, 0, "maj"))
+  pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, 0, "maj"))
 };
 function defaultHarmonicRhythm(ts) {
-  const bar2 = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, ts);
+  const bar2 = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, ts);
   const half = bar2 / 2;
-  return half % _chunkXKSO2V5Icjs.pulseBeats.call(void 0, ts) === 0 ? half : bar2;
+  return half % _chunkS5BKZZGMcjs.pulseBeats.call(void 0, ts) === 0 ? half : bar2;
 }
 var DEFAULT_PLACEMENT = {
   transposeSearch: false,
@@ -3979,24 +4014,24 @@ var DEFAULT_PLACEMENT = {
 var DEFAULT_METER = { numerator: 4, denominator: 4 };
 var TIE_BREAK_JITTER2 = 1e-6;
 function cadencesThroughRaisedSeventh(key) {
-  return _chunkQ6R3QAZDcjs.isMinorKey.call(void 0, key) && _chunkYPB3A3EYcjs.scaleSystemOf.call(void 0, key) === "common-practice";
+  return _chunkIFZDWIKMcjs.isMinorKey.call(void 0, key) && _chunk3R3QVKY5cjs.scaleSystemOf.call(void 0, key) === "common-practice";
 }
 function isKeyTone(pitch, key) {
-  return _chunkYPB3A3EYcjs.isScaleTone.call(void 0, pitch, key) || cadencesThroughRaisedSeventh(key) && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch) === _chunkYPB3A3EYcjs.leadingTonePcOf.call(void 0, 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 = _chunkYPB3A3EYcjs.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(_chunkYPB3A3EYcjs.majorKey.call(void 0, tonic), _chunkYPB3A3EYcjs.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 = _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, n.pitch);
+      const pc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, n.pitch);
       if (isKeyTone(n.pitch, key)) {
         score += w;
       }
@@ -4031,7 +4066,7 @@ function emissionCost(seg, cand, melody, key) {
   let cost = cand.base * seg.weight;
   for (const { index, weight, strong } of seg.costNotes) {
     const note2 = melody[index];
-    if (!note2 || pcs.includes(_chunkXKSO2V5Icjs.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;
@@ -4070,7 +4105,7 @@ function phraseEndBonus(prev, cur, tonicPc, seg, melody) {
     return 0;
   }
   const closing = melody[seg.closingIndex];
-  if (!closing || _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, closing.pitch) !== tonicPc) {
+  if (!closing || _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, closing.pitch) !== tonicPc) {
     return 0;
   }
   const weight = Math.max(seg.weight, seg.beats);
@@ -4107,7 +4142,7 @@ function sameHarmony(a, b) {
   return a.rootPc === b.rootPc && a.quality === b.quality;
 }
 function harmonizeOnce(melody, key, candidates, segments, jitter, phraseEnds, articulated) {
-  const tonicPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc);
+  const tonicPc = _chunkS5BKZZGMcjs.pitchClassOf.call(void 0, key.rootPc);
   const n = candidates.length;
   const candAt = (i) => _nullishCoalesce(candidates[i], () => ( FALLBACK));
   const seg0 = segments[0];
@@ -4169,13 +4204,13 @@ function gridBounds(segmentStart, hr, gridCount, ends) {
   }
   const last = segmentStart + gridCount * hr;
   for (const end of ends) {
-    if (end > segmentStart + _chunkXKSO2V5Icjs.BEAT_EPS && end < last - _chunkXKSO2V5Icjs.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))) > _chunkXKSO2V5Icjs.BEAT_EPS
+    (beat, index) => index === 0 || beat - (_nullishCoalesce(bounds[index - 1], () => ( beat))) > _chunkS5BKZZGMcjs.BEAT_EPS
   );
 }
 function closingNoteIndices(spans, ends) {
@@ -4184,7 +4219,7 @@ function closingNoteIndices(spans, ends) {
     let index = -1;
     let start = Number.NEGATIVE_INFINITY;
     for (const [i, span] of spans.entries()) {
-      if (span.startBeat < end - _chunkXKSO2V5Icjs.BEAT_EPS && span.startBeat >= start) {
+      if (span.startBeat < end - _chunkS5BKZZGMcjs.BEAT_EPS && span.startBeat >= start) {
         start = span.startBeat;
         index = i;
       }
@@ -4227,7 +4262,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', _48 => _48[s], 'optionalAccess', _49 => _49.startBeat]), () => ( 0))) < end - _chunkXKSO2V5Icjs.BEAT_EPS) {
+      if ((_nullishCoalesce(_optionalChain([segments, 'access', _48 => _48[s], 'optionalAccess', _49 => _49.startBeat]), () => ( 0))) < end - _chunkS5BKZZGMcjs.BEAT_EPS) {
         index = s;
       }
     }
@@ -4244,13 +4279,13 @@ function buildSegments(spans, melody, ts, grid, phraseEnds, budget) {
   const hr = grid.harmonicRhythm;
   const segmentStart = Math.floor(melodyStart / hr) * hr;
   const gridCount = Math.max(1, Math.ceil((melodyEnd - segmentStart) / hr));
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, gridCount, "harmonic segments", budget);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, gridCount, "harmonic segments", budget);
   const innerEnds = phraseEnds.filter(
-    (end) => end > segmentStart + _chunkXKSO2V5Icjs.BEAT_EPS && end < melodyEnd - _chunkXKSO2V5Icjs.BEAT_EPS
+    (end) => end > segmentStart + _chunkS5BKZZGMcjs.BEAT_EPS && end < melodyEnd - _chunkS5BKZZGMcjs.BEAT_EPS
   );
   const bounds = gridBounds(segmentStart, hr, gridCount, innerEnds);
   const segCount = bounds.length - 1;
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, segCount, "harmonic segments", budget);
+  _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));
@@ -4271,7 +4306,7 @@ function buildSegments(spans, melody, ts, grid, phraseEnds, budget) {
       lastExclusive += 1;
     }
     memberships += Math.max(0, lastExclusive - first);
-    _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, memberships, "note-to-segment memberships", budget);
+    _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, memberships, "note-to-segment memberships", budget);
     for (let segment = first; segment < lastExclusive; segment += 1) {
       _optionalChain([segments, 'access', _50 => _50[segment], 'optionalAccess', _51 => _51.noteIndices, 'access', _52 => _52.push, 'call', _53 => _53(index)]);
     }
@@ -4295,7 +4330,7 @@ function buildSegments(spans, melody, ts, grid, phraseEnds, budget) {
         continue;
       }
       const weight = Math.max(0.25, overlap);
-      segment.costNotes.push({ index, weight, strong: _chunkXKSO2V5Icjs.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;
@@ -4317,7 +4352,7 @@ var UNSTABLE_QUALITIES = /* @__PURE__ */ new Set([
   "aug7"
 ]);
 function vocabularyBase(rootPc, quality, tonicPc) {
-  const above = (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, rootPc) - tonicPc + 12) % 12;
+  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;
 }
@@ -4326,7 +4361,7 @@ var BORROWED_BASE = 0.5;
 var SECONDARY_DOMINANT_TARGETS = [2, 4, 5, 6];
 function secondaryDominantTargets(key) {
   const tonicizable = new Map(
-    _chunkYPB3A3EYcjs.tonicizableDegrees.call(void 0, key).map((degree) => [degree.degreeNumber, degree])
+    _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
@@ -4345,19 +4380,19 @@ function admittedCount(fraction, size) {
   return Math.max(0, Math.min(size, Math.ceil(fraction * size)));
 }
 function buildCandidates(key, harmonic) {
-  const tonicPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, key.rootPc);
-  const frame = _chunkYPB3A3EYcjs.heptatonicFrameOf.call(void 0, key);
-  const tones = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, frame);
+  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 = _chunkYPB3A3EYcjs.diatonicTriad.call(void 0, degree, frame).quality;
+    const quality = _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, frame).quality;
     return {
       rootPc,
       quality,
       degree,
       secondaryDominant: false,
       base: vocabularyBase(rootPc, quality, tonicPc),
-      pcs: _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, quality))
+      pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, quality))
     };
   });
   if (cadencesThroughRaisedSeventh(key)) {
@@ -4368,7 +4403,7 @@ function buildCandidates(key, harmonic) {
       degree: 5,
       secondaryDominant: false,
       base: vocabularyBase(rootPc, "maj", tonicPc),
-      pcs: _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, "maj"))
+      pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "maj"))
     });
   }
   const targets = secondaryDominantTargets(key);
@@ -4387,20 +4422,20 @@ function buildCandidates(key, harmonic) {
       secondaryDominant: true,
       targetDegree: target.degreeNumber,
       base: SECONDARY_DOMINANT_BASE,
-      pcs: _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, rootPc, "dom7"))
+      pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, rootPc, "dom7"))
     });
   }
-  const parallel = _chunkQ6R3QAZDcjs.parallelKey.call(void 0, key);
-  const parallelTones = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, parallel);
+  const parallel = _chunkIFZDWIKMcjs.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 = _chunkYPB3A3EYcjs.diatonicTriad.call(void 0, degree, parallel);
-    if (!_chunkQ6R3QAZDcjs.isDiatonic.call(void 0, chord, key)) {
+    const chord = _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, parallel);
+    if (!_chunkIFZDWIKMcjs.isDiatonic.call(void 0, chord, key)) {
       borrowed.push(chord);
     }
   }
   const borrowedRank = (chord) => {
-    const offset = BORROWED_ENTRY_ORDER.indexOf(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, chord.rootPc - tonicPc));
+    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));
@@ -4419,7 +4454,7 @@ function buildCandidates(key, harmonic) {
       // 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: _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord)
+      pcs: _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord)
     });
   }
   const seen = /* @__PURE__ */ new Set();
@@ -4435,26 +4470,26 @@ function buildCandidates(key, harmonic) {
 
 // src/generate/harmonize/index.ts
 function harmonizeMelody(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "harmonize options");
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, opts.melody, "harmonize melody", {
+  _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) {
-    _chunkXKSO2V5Icjs.assertFiniteNumber.call(void 0, end, "harmonize phrase end");
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, end, "harmonize phrase end");
   }
-  const soundingMelody = _chunkXKSO2V5Icjs.soundingNotesOnly.call(void 0, opts.melody);
-  const ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_METER)), "ts"));
-  _chunkXKSO2V5Icjs.assertTimeSignature.call(void 0, ts);
+  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 = _chunkYPB3A3EYcjs.resolveKey.call(void 0, 
+  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 = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, 
+  const reharmonize = _chunkS5BKZZGMcjs.assertOneOf.call(void 0, 
     _nullishCoalesce(opts.reharmonize, () => ( "diatonic")),
     REHARMONIZE_STRENGTHS,
     "reharmonize"
@@ -4467,7 +4502,7 @@ function harmonizeMelody(opts) {
   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 = _chunkXKSO2V5Icjs.pulseBeats.call(void 0, ts);
+  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)
@@ -4480,7 +4515,7 @@ function harmonizeMelody(opts) {
     (end, span) => Math.max(end, span.endBeat),
     Number.NEGATIVE_INFINITY
   );
-  const hr = _chunkXKSO2V5Icjs.assertRange.call(void 0, 
+  const hr = _chunkS5BKZZGMcjs.assertRange.call(void 0, 
     _nullishCoalesce(opts.harmonicRhythm, () => ( defaultHarmonicRhythm(ts))),
     Number.MIN_VALUE,
     Number.MAX_SAFE_INTEGER,
@@ -4509,7 +4544,7 @@ function harmonizeMelody(opts) {
   }
   const octaveShifts = placement.octaveSearch ? [0, -12, 12] : [0];
   const transposes = semitoneShifts.flatMap((s) => octaveShifts.map((o) => s + o));
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, 
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, 
     transposes.length * segments.length * candidates.length * candidates.length,
     "harmonization placement search",
     opts.budget
@@ -4555,8 +4590,8 @@ function harmonizeMelody(opts) {
   const melodyRoles = opts.melody.map((note2, noteIndex) => {
     const segIdx = segmentIndexAt(bounds, snapToPulse(note2.startBeat, pulse2));
     const cand = candAt(_nullishCoalesce(bestPath[segIdx], () => ( 0)));
-    const chord = _chunkYPB3A3EYcjs.makeChord.call(void 0, cand.rootPc, cand.quality);
-    return { noteIndex, role: _chunkR7B5N2JKcjs.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: resolvedKey, chords, melodyRoles };
 }
@@ -4575,15 +4610,15 @@ var MIN_TILE_SPAN = 1 / 256;
 var DEFAULT_TS4 = { numerator: 4, denominator: 4 };
 function isDownbeat(startBeat, barBeats) {
   const bar2 = startBeat / barBeats;
-  return Math.abs(bar2 - Math.round(bar2)) < _chunkXKSO2V5Icjs.BEAT_EPS;
+  return Math.abs(bar2 - Math.round(bar2)) < _chunkS5BKZZGMcjs.BEAT_EPS;
 }
 function nearestChordTone(pitch, chord) {
-  const pcs = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord);
+  const pcs = _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
   for (let d = 0; d <= 12; d += 1) {
-    if (pcs.includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch - d))) {
+    if (pcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch - d))) {
       return pitch - d;
     }
-    if (pcs.includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch + d))) {
+    if (pcs.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch + d))) {
       return pitch + d;
     }
   }
@@ -4663,20 +4698,20 @@ function contourOffsets(contour, count) {
   return offsets;
 }
 function generateMotif(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "motif options");
+  _chunkS5BKZZGMcjs.assertRecord.call(void 0, opts, "motif options");
   const contour = _nullishCoalesce(opts.contour, () => ( "arch"));
-  const bars = _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, opts.bars, "motif bars");
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS4)), "ts")));
+  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);
-  _chunkXKSO2V5Icjs.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 = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, opts.key);
-  const chord = opts.chord ? _chunkYPB3A3EYcjs.toChordData.call(void 0, opts.chord) : null;
-  const tonic = _chunkXKSO2V5Icjs.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) {
@@ -4684,13 +4719,13 @@ function generateMotif(opts) {
     if (draw.prob(jitterProb, "jitter", i)) {
       jitter = draw.prob(0.5, "direction", i) ? 1 : -1;
     }
-    let pitch = _chunkYPB3A3EYcjs.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: _chunkXKSO2V5Icjs.clampToMidi.call(void 0, pitch, "generated motif pitch"),
+      pitch: _chunkS5BKZZGMcjs.clampToMidi.call(void 0, pitch, "generated motif pitch"),
       startBeat,
       durationBeat: beatsPerNote
     });
@@ -4701,12 +4736,12 @@ function motifToNoteEvents(cell) {
   return assertCellNotes(cell, "motif cell notes").map((note2) => ({ ...note2 }));
 }
 function assertCellNotes(cell, name) {
-  const read = _chunkXKSO2V5Icjs.assertRecord.call(void 0, cell, "motif cell");
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, read.notes, 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 : _chunkYPB3A3EYcjs.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(inTimeOrder(transformUnchecked(cell, t, amount, key)));
@@ -4714,7 +4749,7 @@ function transformCell(cell, t, amount, key) {
 function assertInRange(cell) {
   for (const note2 of cell.notes) {
     if (note2.pitch < 0 || note2.pitch > 127) {
-      throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
         `transformed motif pitch ${note2.pitch} is outside the MIDI range 0..127`
       );
     }
@@ -4723,18 +4758,18 @@ function assertInRange(cell) {
 }
 function transformUnchecked(cell, t, amount, key) {
   const notes = assertCellNotes(cell, "motif notes");
-  _chunkXKSO2V5Icjs.assertOneOf.call(void 0, t, MOTIF_TRANSFORMS, "motif transform");
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, t, MOTIF_TRANSFORMS, "motif transform");
   if (amount !== void 0) {
-    _chunkXKSO2V5Icjs.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) {
-    _chunkXKSO2V5Icjs.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, _chunkXKSO2V5Icjs.InvalidInputError)("time transform amount must be positive");
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("time transform amount must be positive");
   }
   switch (t) {
     case "transposeChromatic": {
@@ -4752,7 +4787,7 @@ 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 ? _chunkYPB3A3EYcjs.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
         }))
       };
     }
@@ -4798,13 +4833,13 @@ function scaleTime(cell, factor) {
   };
 }
 function developMotif(cell, timeline, key, bars, ts) {
-  const meter = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
-  _chunkQ6R3QAZDcjs.assertChordTimeline.call(void 0, timeline);
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, bars, "development bars");
+  const meter = _chunkS5BKZZGMcjs.meterAt.call(void 0, 0, _chunkS5BKZZGMcjs.toMeterData.call(void 0, ts, "ts"));
+  _chunkIFZDWIKMcjs.assertChordTimeline.call(void 0, timeline);
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, bars, "development bars");
   const cellNotes = assertCellNotes(cell, "motif notes");
-  const scale = _chunkYPB3A3EYcjs.toKeyScale.call(void 0, key);
+  const scale = _chunk3R3QVKY5cjs.toKeyScale.call(void 0, key);
   const span = cellSpan(cell);
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, meter);
+  const barBeats = _chunkS5BKZZGMcjs.beatsPerBar.call(void 0, meter);
   const totalBeats = bars * barBeats;
   const origin = cellOrigin(cellNotes);
   const out = [];
@@ -4813,7 +4848,7 @@ function developMotif(cell, timeline, key, bars, ts) {
   }
   const tileSpan = Math.max(span, MIN_TILE_SPAN);
   const tileCount = Math.ceil(totalBeats / tileSpan);
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, tileCount * cellNotes.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();
@@ -4825,8 +4860,8 @@ function developMotif(cell, timeline, key, bars, ts) {
       }
       const chord = timeline.at(startBeat);
       const structural = n.startBeat === origin || isDownbeat(startBeat, barBeats);
-      const chordTones = chord && structural ? _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, chord) : null;
-      const allows = chordTones ? (candidate) => chordTones.includes(_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, candidate)) : (candidate) => _chunkYPB3A3EYcjs.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);
@@ -4837,6 +4872,1063 @@ function developMotif(cell, timeline, key, bars, ts) {
   return inTimeOrder({ notes: out });
 }
 
+// src/generate/plan/internal.ts
+var STRONG_WEIGHT = 2;
+function positionClass(beat, meters) {
+  const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, beat, meters);
+  return weight >= STRONG_WEIGHT ? "strong" : weight > 0 ? "weak" : "off";
+}
+
+// src/generate/plan/types.ts
+var COMPOSITION_PLAN_VERSION = 1;
+function tent(t, apex) {
+  if (t <= apex) {
+    return apex === 0 ? 1 : -1 + 2 * t / apex;
+  }
+  return apex === 1 ? 1 : 1 - 2 * (t - apex) / (1 - apex);
+}
+function plannedContourAt(shape, peakPosition, t) {
+  switch (shape) {
+    case "arch":
+      return tent(t, peakPosition);
+    case "ascending":
+      return -1 + 2 * t;
+    case "descending":
+      return 1 - 2 * t;
+    case "wave":
+      return t < 0.5 ? tent(2 * t, 0.5) : tent(2 * t - 1, 0.5);
+    case "static":
+      return 0;
+  }
+}
+
+// src/generate/plan/validate.ts
+var MASS_TOLERANCE = 1e-9;
+function assertString(value, name) {
+  if (typeof value !== "string") {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be a string; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, value)}`);
+  }
+  return value;
+}
+function assertSpanOrder(startBeat, endBeat, name) {
+  if (endBeat < startBeat) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.endBeat must be at least ${name}.startBeat; received ${endBeat} < ${startBeat}`
+    );
+  }
+}
+function assertNullable(value, name, validate) {
+  if (value === void 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be present; received undefined`);
+  }
+  return value === null ? null : validate(value, name);
+}
+function assertMassDistribution(value, length, name) {
+  const shares = _chunkS5BKZZGMcjs.assertArray.call(void 0, value, name);
+  if (shares.length !== length) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must have length ${length}; received ${shares.length}`);
+  }
+  let sum = 0;
+  for (let index = 0; index < shares.length; index += 1) {
+    const share = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, shares[index], `${name}[${index}]`);
+    if (share < 0) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}[${index}] must be at least 0; received ${share}`);
+    }
+    sum += share;
+  }
+  if (Math.abs(sum - 1) > MASS_TOLERANCE) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must sum to 1; received ${sum}`);
+  }
+  return shares;
+}
+function assertResolvedKeyField(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  try {
+    _chunk3R3QVKY5cjs.resolveKey.call(void 0, read);
+  } catch (error) {
+    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name} must be a valid key: ${error.message}`);
+    }
+    throw error;
+  }
+  return read;
+}
+function assertPlannedSection(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  assertString(read.label, `${name}.label`);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  return read;
+}
+function assertPlannedPhrase(value, name, sectionCount, motifCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  assertNullable(
+    read.section,
+    `${name}.section`,
+    (v, n) => _chunkS5BKZZGMcjs.assertInteger.call(void 0, v, n, 0, Math.max(sectionCount - 1, 0))
+  );
+  assertNullable(read.cadence, `${name}.cadence`, (v, n) => _chunkS5BKZZGMcjs.assertOneOf.call(void 0, v, _chunkIFZDWIKMcjs.CADENCE_TYPES, n));
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.shape, _chunkIFZDWIKMcjs.MELODIC_CONTOUR_SHAPES, `${name}.shape`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.peakPosition, 0, 1, `${name}.peakPosition`);
+  const register = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+    read.register,
+    `${name}.register`
+  );
+  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, register.low, `${name}.register.low`);
+  _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, register.high, `${name}.register.high`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, register.mean, 0, 127, `${name}.register.mean`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.onsetDensity, 0, Number.MAX_SAFE_INTEGER, `${name}.onsetDensity`);
+  const motifs = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.motifs, `${name}.motifs`);
+  for (let index = 0; index < motifs.length; index += 1) {
+    _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+      motifs[index],
+      `${name}.motifs[${index}]`,
+      0,
+      Math.max(motifCount - 1, 0)
+    );
+  }
+  return read;
+}
+function assertPlannedChord(value, name, keys) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  const keyIndex = _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.key, `${name}.key`, 0, Math.max(keys.length - 1, 0));
+  const roman = assertString(read.roman, `${name}.roman`);
+  try {
+    _chunkIFZDWIKMcjs.romanToChord.call(void 0, roman, keys[keyIndex]);
+  } catch (error) {
+    if (error instanceof _chunkS5BKZZGMcjs.InvalidInputError) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}.roman must be readable by romanToChord; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, roman)}: ${error.message}`
+      );
+    }
+    throw error;
+  }
+  return read;
+}
+function assertPlannedMotifRelation(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertOneOf.call(void 0, read.kind, _chunkIFZDWIKMcjs.MOTIF_RELATION_KINDS, `${name}.kind`);
+  _chunkS5BKZZGMcjs.assertFlag.call(void 0, read.sequence, `${name}.sequence`);
+  _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.semitones, `${name}.semitones`);
+  if (read.kind === "tonalTransposition") {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.degrees, `${name}.degrees`);
+  } else if (read.degrees !== void 0) {
+    _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.degrees, `${name}.degrees`);
+  }
+  const timeRatio = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.timeRatio, `${name}.timeRatio`);
+  if (timeRatio <= 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.timeRatio must be positive; received ${timeRatio}`);
+  }
+  return read;
+}
+function assertPlannedMotif(value, name, ownIndex, motifCount, phraseCount) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.phrase, `${name}.phrase`, 0, Math.max(phraseCount - 1, 0));
+  const startBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.startBeat, `${name}.startBeat`);
+  const endBeat = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, read.endBeat, `${name}.endBeat`);
+  assertSpanOrder(startBeat, endBeat, name);
+  _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, read.notes, `${name}.notes`);
+  const from = assertNullable(
+    read.from,
+    `${name}.from`,
+    (v, n) => _chunkS5BKZZGMcjs.assertInteger.call(void 0, v, n, 0, Math.max(motifCount - 1, 0))
+  );
+  if (from !== null && from >= ownIndex) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.from must be less than this motif's own index (${ownIndex}); received ${from}`
+    );
+  }
+  const relation = assertNullable(read.relation, `${name}.relation`, assertPlannedMotifRelation);
+  if (from === null && relation !== null) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.relation must be null for a root motif (from = null); received a relation`
+    );
+  }
+  const rhythm = assertNullable(read.rhythm, `${name}.rhythm`, (v, n) => _chunkS5BKZZGMcjs.assertArray.call(void 0, v, n));
+  if (rhythm !== null) {
+    if (from !== null) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.rhythm must be null for a derived statement`);
+    }
+    if (rhythm.length !== read.notes - 1) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}.rhythm must hold notes - 1 (${read.notes - 1}) gaps; received ${rhythm.length}`
+      );
+    }
+    let total = 0;
+    for (let index = 0; index < rhythm.length; index += 1) {
+      const gap = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, rhythm[index], `${name}.rhythm[${index}]`);
+      if (gap <= 0) {
+        throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.rhythm[${index}] must be positive; received ${gap}`);
+      }
+      total += gap;
+    }
+    if (total >= endBeat - startBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+        `${name}.rhythm must sum to less than the statement's length (${endBeat - startBeat}); received ${total}`
+      );
+    }
+  }
+  return read;
+}
+function assertPlannedRhythm(value, name) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  assertMassDistribution(read.onsetLevels, 6, `${name}.onsetLevels`);
+  assertMassDistribution(read.interOnsetShares, _chunkIFZDWIKMcjs.RHYTHM_IOI_BINS.length, `${name}.interOnsetShares`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, read.syncopation, 0, 1, `${name}.syncopation`);
+  return read;
+}
+function assertCompositionPlan(value, name = "composition plan") {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, name);
+  if (read.planVersion !== COMPOSITION_PLAN_VERSION) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `${name}.planVersion must be ${COMPOSITION_PLAN_VERSION}; received ${_chunkS5BKZZGMcjs.describeRejected.call(void 0, read.planVersion)}`
+    );
+  }
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, read.seed, `${name}.seed`, 0, 4294967295);
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, 
+    read.algorithmVersion,
+    `${name}.algorithmVersion`,
+    _chunkCGBADIO5cjs.MIN_ALGORITHM_VERSION,
+    _chunkCGBADIO5cjs.ALGORITHM_VERSION
+  );
+  const keys = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.keys, `${name}.keys`);
+  if (keys.length === 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`${name}.keys must hold at least one key; received an empty array`);
+  }
+  for (let index = 0; index < keys.length; index += 1) {
+    assertResolvedKeyField(keys[index], `${name}.keys[${index}]`);
+  }
+  _chunkS5BKZZGMcjs.assertMeterMap.call(void 0, read.meters, `${name}.meters`);
+  const span = _chunkS5BKZZGMcjs.assertRecord.call(void 0, 
+    read.span,
+    `${name}.span`
+  );
+  const spanStart = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, span.startBeat, `${name}.span.startBeat`);
+  const spanEnd = _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, span.endBeat, `${name}.span.endBeat`);
+  assertSpanOrder(spanStart, spanEnd, `${name}.span`);
+  _chunkS5BKZZGMcjs.assertRange.call(void 0, span.bars, 0, Number.MAX_SAFE_INTEGER, `${name}.span.bars`);
+  const sections = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.sections, `${name}.sections`);
+  for (let index = 0; index < sections.length; index += 1) {
+    assertPlannedSection(sections[index], `${name}.sections[${index}]`);
+  }
+  const phrases = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.phrases, `${name}.phrases`);
+  const motifs = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.motifs, `${name}.motifs`);
+  for (let index = 0; index < phrases.length; index += 1) {
+    assertPlannedPhrase(
+      phrases[index],
+      `${name}.phrases[${index}]`,
+      sections.length,
+      motifs.length
+    );
+  }
+  const harmony = _chunkS5BKZZGMcjs.assertArray.call(void 0, read.harmony, `${name}.harmony`);
+  for (let index = 0; index < harmony.length; index += 1) {
+    assertPlannedChord(harmony[index], `${name}.harmony[${index}]`, keys);
+  }
+  for (let index = 0; index < motifs.length; index += 1) {
+    assertPlannedMotif(
+      motifs[index],
+      `${name}.motifs[${index}]`,
+      index,
+      motifs.length,
+      phrases.length
+    );
+  }
+  assertPlannedRhythm(read.rhythm, `${name}.rhythm`);
+  return read;
+}
+
+// src/generate/plan/timeline.ts
+function planTimeline(plan) {
+  return planChordTimeline(assertCompositionPlan(plan));
+}
+function planChordTimeline(plan) {
+  const spans = plan.harmony.map((chord) => {
+    const key = plan.keys[chord.key];
+    return _chunk3R3QVKY5cjs.spanFromChord.call(void 0, _chunkIFZDWIKMcjs.romanToChord.call(void 0, chord.roman, key), chord.startBeat);
+  });
+  return _chunkIFZDWIKMcjs.chordTimelineFromChords.call(void 0, spans, plan.span.endBeat);
+}
+
+// src/generate/plan/harmony.ts
+var HARMONY_OK_KINDS = /* @__PURE__ */ new Set([
+  "chordTone",
+  "tension",
+  "suspension",
+  "appoggiatura",
+  "anticipation",
+  "passing",
+  "neighbor"
+]);
+var CADENCE_DEGREES = {
+  authentic: [1, 3],
+  plagal: [1, 3],
+  half: [2, 5, 7],
+  phrygian: [2, 5, 7],
+  modal: [1]
+};
+function planKeyAt(plan) {
+  const regions = [...plan.harmony].sort((a, b) => a.startBeat - b.startBeat).map((chord) => ({
+    startBeat: chord.startBeat,
+    endBeat: chord.endBeat,
+    key: plan.keys[chord.key],
+    confidence: 1
+  }));
+  return _chunkIFZDWIKMcjs.keyLookup.call(void 0, regions, plan.keys[0]);
+}
+function cadencePitchClasses(plan, timeline, cadence, beat) {
+  if (cadence === "deceptive") {
+    const chord = timeline.at(beat);
+    return chord === null ? null : _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord);
+  }
+  const entry = plan.harmony.find((chord) => beat >= chord.startBeat && beat < chord.endBeat);
+  const tones = _chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, _chunk3R3QVKY5cjs.scaleOf.call(void 0, plan.keys[_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _59 => _59.key]), () => ( 0))]));
+  return CADENCE_DEGREES[cadence].map((degree) => tones[degree - 1]).filter((pc) => pc !== void 0);
+}
+function planHarmonyMisfits(plan, timeline = planChordTimeline(plan)) {
+  const keyAt = planKeyAt(plan);
+  const scaleAt2 = (beat) => _chunk3R3QVKY5cjs.scaleOf.call(void 0, keyAt(beat));
+  return (line) => {
+    const analyzed = _chunkIFZDWIKMcjs.analyzeVoice.call(void 0, line, timeline.at, scaleAt2);
+    return line.map((note2, index) => {
+      const position = positionClass(note2.startBeat, plan.meters);
+      if (position === "off") {
+        return null;
+      }
+      const kinds = (_nullishCoalesce(_optionalChain([analyzed, 'access', _60 => _60[index], 'optionalAccess', _61 => _61.labels]), () => ( []))).map((label) => label.kind);
+      if (kinds.some((kind) => HARMONY_OK_KINDS.has(kind))) {
+        return null;
+      }
+      return position === "weak" && _chunk3R3QVKY5cjs.isScaleTone.call(void 0, note2.pitch, scaleAt2(note2.startBeat)) ? null : kinds;
+    });
+  };
+}
+
+// src/generate/melody/pitch-dp.ts
+var NO_LEAP = 0;
+var LEAP_UP = 1;
+var LEAP_DOWN = 2;
+var LEAP_STATES = 3;
+var SEARCH_LABEL = "melody pitch search";
+var WIDEST_THIRD = 4;
+var LEAP_CONTINUATION_COST = 0.5;
+function intervalCost(size) {
+  if (size === 0) {
+    return 0.2;
+  }
+  if (size <= 2) {
+    return 0;
+  }
+  if (size <= WIDEST_THIRD) {
+    return 0.3;
+  }
+  if (size <= 7) {
+    return 0.6;
+  }
+  return 1;
+}
+function leapOf(delta) {
+  if (Math.abs(delta) <= WIDEST_THIRD) {
+    return NO_LEAP;
+  }
+  return delta > 0 ? LEAP_UP : LEAP_DOWN;
+}
+function stepCost(from, to, leap, bothFixed) {
+  const delta = to - from;
+  const size = Math.abs(delta);
+  if (!bothFixed && _chunk3R3QVKY5cjs.isForbiddenMelodicLeap.call(void 0, from, to)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let cost = intervalCost(size);
+  if (leap === LEAP_UP && delta > 0 || leap === LEAP_DOWN && delta < 0) {
+    cost += LEAP_CONTINUATION_COST;
+  }
+  return cost;
+}
+function searchPitches(slots, budget, extra) {
+  const first = slots[0];
+  if (first === void 0) {
+    return [];
+  }
+  let previous = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 
+    first.candidates.length,
+    LEAP_STATES,
+    SEARCH_LABEL,
+    budget
+  ).fill(Number.POSITIVE_INFINITY);
+  for (let j = 0; j < first.candidates.length; j += 1) {
+    previous[j * LEAP_STATES + NO_LEAP] = first.cost(first.candidates[j]);
+  }
+  const backs = [];
+  for (let k = 1; k < slots.length; k += 1) {
+    const before = slots[k - 1];
+    const slot = slots[k];
+    const unary = slot.candidates.map((pitch) => slot.cost(pitch));
+    const current = _chunkS5BKZZGMcjs.allocateCandidateTable.call(void 0, 
+      slot.candidates.length,
+      LEAP_STATES,
+      SEARCH_LABEL,
+      budget
+    ).fill(Number.POSITIVE_INFINITY);
+    const back = _chunkS5BKZZGMcjs.allocateChoiceTable.call(void 0, 
+      slot.candidates.length,
+      LEAP_STATES,
+      SEARCH_LABEL,
+      budget
+    ).fill(-1);
+    const bothFixed = before.fixed && slot.fixed;
+    for (let state2 = 0; state2 < previous.length; state2 += 1) {
+      const reached = previous[state2];
+      if (reached === Number.POSITIVE_INFINITY) {
+        continue;
+      }
+      const from = before.candidates[Math.floor(state2 / LEAP_STATES)];
+      const leap = state2 % LEAP_STATES;
+      for (let j = 0; j < slot.candidates.length; j += 1) {
+        const to = slot.candidates[j];
+        const step = stepCost(from, to, leap, bothFixed);
+        if (step === Number.POSITIVE_INFINITY) {
+          continue;
+        }
+        const total = reached + step + unary[j] + (extra ? extra(k, from, to) : 0);
+        const index = j * LEAP_STATES + leapOf(to - from);
+        if (total < current[index]) {
+          current[index] = total;
+          back[index] = state2;
+        }
+      }
+    }
+    backs.push(back);
+    previous = current;
+  }
+  let best = -1;
+  for (let state2 = 0; state2 < previous.length; state2 += 1) {
+    if (previous[state2] < Number.POSITIVE_INFINITY && (best < 0 || previous[state2] < previous[best])) {
+      best = state2;
+    }
+  }
+  if (best < 0) {
+    return null;
+  }
+  const pitches = new Array(slots.length);
+  let state = best;
+  for (let k = slots.length - 1; k >= 0; k -= 1) {
+    pitches[k] = slots[k].candidates[Math.floor(state / LEAP_STATES)];
+    if (k > 0) {
+      state = backs[k - 1][state];
+    }
+  }
+  return pitches;
+}
+
+// src/generate/melody/derive.ts
+var VARIATION_STEP_COST = 0.2;
+var OCTAVE = 12;
+var LEVEL_TARGET_COST = 0.1;
+var LEVEL_PLAN_COST = 0.02;
+var LEVEL_REACH = 24;
+var TONAL_LEVEL_REACH = 14;
+function stretched(cell, timeRatio) {
+  return timeRatio === 1 ? cell : transformMotif(cell, "augment", timeRatio);
+}
+function shaped(cell, relation) {
+  switch (relation.kind) {
+    case "repetition":
+    case "tonalTransposition":
+      return cell;
+    case "transposition":
+      return stretched(cell, relation.timeRatio);
+    case "inversion":
+      return stretched(transformMotif(cell, "invert"), relation.timeRatio);
+    case "retrograde":
+      return transformMotif(cell, "retrograde");
+    case "retrogradeInversion":
+      return transformMotif(transformMotif(cell, "invert"), "retrograde");
+    case "augmentation":
+      return transformMotif(cell, "augment", relation.timeRatio);
+    case "diminution":
+      return transformMotif(cell, "diminish", 1 / relation.timeRatio);
+  }
+}
+function relationLevels(kind, low = -LEVEL_REACH, high = LEVEL_REACH) {
+  const between = (from, to, skipZero) => {
+    const levels = [];
+    for (let level = Math.ceil(from); level <= to; level += 1) {
+      if (!(skipZero && level === 0)) levels.push(level);
+    }
+    return levels;
+  };
+  switch (kind) {
+    case "repetition":
+    case "augmentation":
+    case "diminution":
+      return [-OCTAVE, 0, OCTAVE];
+    case "transposition":
+      return between(low, high, true);
+    case "tonalTransposition":
+      return between(-TONAL_LEVEL_REACH, TONAL_LEVEL_REACH, true);
+    case "inversion":
+    case "retrograde":
+    case "retrogradeInversion":
+      return between(low, high, false);
+  }
+}
+function replayAt(source, relation, level, startBeat, key) {
+  const head = source[0];
+  const cell = shaped({ notes: source.map((n) => ({ ...n })) }, relation);
+  const first = cell.notes[0];
+  const offset = startBeat - first.startBeat;
+  const shift = head.pitch + level - first.pitch;
+  return cell.notes.map((n) => ({
+    ...n,
+    pitch: relation.kind === "tonalTransposition" ? _chunk3R3QVKY5cjs.shiftByScaleDegrees.call(void 0, n.pitch, level, key) : n.pitch + shift,
+    startBeat: n.startBeat + offset
+  }));
+}
+function clipStatement(notes, endBeat) {
+  return notes.filter((n) => n.startBeat < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS).map((n) => ({ ...n, durationBeat: Math.min(n.durationBeat, endBeat - n.startBeat) }));
+}
+function outsideCount(notes, frame) {
+  return notes.filter((n) => n.pitch < frame.low || n.pitch > frame.high).length;
+}
+function nearerLevel(level, best, planned) {
+  const distance = Math.abs(level - planned);
+  const bestDistance = Math.abs(best - planned);
+  return distance < bestDistance || distance === bestDistance && level < best;
+}
+function repairStatement(notes, forced, frame) {
+  const slots = notes.map(
+    (n, index) => forced[index] ? {
+      candidates: frame.candidatesAt(n.startBeat),
+      cost: frame.costAt(n.startBeat),
+      fixed: false
+    } : { candidates: [n.pitch], cost: () => 0, fixed: true }
+  );
+  const pitches = searchPitches(slots, frame.budget);
+  if (pitches === null) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(
+      `no repair fits the statement into the register ${frame.low}..${frame.high}`,
+      { at: frame.at }
+    );
+  }
+  return notes.map((n, index) => ({ ...n, pitch: pitches[index] }));
+}
+function placeDerived(source, relation, startBeat, endBeat, key, frame, before) {
+  const planned = relation.kind === "tonalTransposition" ? _nullishCoalesce(relation.degrees, () => ( 0)) : relation.semitones;
+  const replay = (level) => clipStatement(replayAt(source, relation, level, startBeat, key), endBeat);
+  const base = replay(0).map((n) => n.pitch);
+  const levels = relationLevels(
+    relation.kind,
+    Math.max(-LEVEL_REACH, frame.low - Math.min(...base)),
+    Math.min(LEVEL_REACH, frame.high - Math.max(...base))
+  );
+  let best = null;
+  for (const level of levels) {
+    const notes2 = replay(level);
+    if (outsideCount(notes2, frame) > 0) {
+      continue;
+    }
+    const distance = notes2.reduce((sum, n) => sum + Math.abs(n.pitch - frame.targetAt(n.startBeat)), 0) / notes2.length;
+    const cost = frame.misfits(notes2, before) + LEVEL_TARGET_COST * distance + LEVEL_PLAN_COST * Math.abs(level - planned);
+    if (best === null || cost < best.cost || cost === best.cost && nearerLevel(level, best.level, planned)) {
+      best = { level, notes: notes2, cost };
+    }
+  }
+  if (best !== null) {
+    return best.notes;
+  }
+  let fallback = null;
+  for (const level of relationLevels(relation.kind)) {
+    const notes2 = replay(level);
+    const outside = outsideCount(notes2, frame);
+    if (fallback === null || outside < fallback.outside || outside === fallback.outside && nearerLevel(level, fallback.level, planned)) {
+      fallback = { level, notes: notes2, outside };
+    }
+  }
+  const notes = fallback.notes;
+  return repairStatement(
+    notes,
+    notes.map((n) => n.pitch < frame.low || n.pitch > frame.high),
+    frame
+  );
+}
+function varyStatement(source, startBeat, frame) {
+  const offset = startBeat - source[0].startBeat;
+  const last = source.length - 1;
+  const inside = (pitch) => pitch >= frame.low && pitch <= frame.high;
+  const outer = [source[0].pitch, source[last].pitch];
+  const shift = [0, OCTAVE, -OCTAVE].find((s) => outer.every((pitch) => inside(pitch + s)));
+  const notes = source.map((n) => ({ ...n, startBeat: n.startBeat + offset }));
+  const slots = notes.map(
+    (n, index) => (index === 0 || index === last) && shift !== void 0 ? { candidates: [n.pitch + shift], cost: () => 0, fixed: true } : {
+      candidates: frame.candidatesAt(n.startBeat),
+      cost: frame.costAt(n.startBeat),
+      fixed: false
+    }
+  );
+  const pitches = searchPitches(
+    slots,
+    frame.budget,
+    (index, from, to) => VARIATION_STEP_COST * Math.abs(
+      to - from - (source[index].pitch - source[index - 1].pitch)
+    )
+  );
+  if (pitches === null) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(`no variation line fits the register ${frame.low}..${frame.high}`, {
+      at: frame.at
+    });
+  }
+  return notes.map((n, index) => ({ ...n, pitch: pitches[index] }));
+}
+
+// src/generate/melody/index.ts
+var RHYTHM_SUBDIVISION = 4;
+var OFF_SCALE_COST = 1;
+var TARGET_COST = 0.1;
+var TIE_BREAK = 1e-6;
+var SEARCH_STATES_SQUARED = 9;
+function melodyContext(plan, input) {
+  const fromPlan = { seed: plan.seed, algorithmVersion: plan.algorithmVersion };
+  if (input === void 0) {
+    return resolveContext(fromPlan);
+  }
+  if (typeof input === "number") {
+    return resolveContext({ ...fromPlan, seed: input });
+  }
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, input, "ctx");
+  if (read.rng !== void 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      "ctx.rng cannot drive a melody: every onset and tie-break is drawn at an address of phrase and beat under a seed; pass a seed instead"
+    );
+  }
+  return resolveContext({
+    ...read,
+    seed: _nullishCoalesce(read.seed, () => ( plan.seed)),
+    algorithmVersion: _nullishCoalesce(read.algorithmVersion, () => ( plan.algorithmVersion))
+  });
+}
+function chordEntryAt(plan, beat) {
+  return plan.harmony.find((chord) => beat >= chord.startBeat && beat < chord.endBeat);
+}
+function scaleAt(scene, beat) {
+  return scene.scales[_nullishCoalesce(_optionalChain([chordEntryAt, 'call', _62 => _62(scene.plan, beat), 'optionalAccess', _63 => _63.key]), () => ( 0))];
+}
+function targetPitch(phrase, beat) {
+  const length = phrase.endBeat - phrase.startBeat;
+  const t = length > 0 ? Math.min(Math.max((beat - phrase.startBeat) / length, 0), 1) : 0;
+  const { low, high, mean } = phrase.register;
+  return mean + (high - low) / 2 * plannedContourAt(phrase.shape, phrase.peakPosition, t);
+}
+function registerPitches(phrase) {
+  const pitches = [];
+  for (let pitch = phrase.register.low; pitch <= phrase.register.high; pitch += 1) {
+    pitches.push(pitch);
+  }
+  return pitches;
+}
+function frameOf(scene, index) {
+  const phrase = scene.plan.phrases[index];
+  const { low, high } = phrase.register;
+  const register = registerPitches(phrase);
+  const draw = scene.ctx.part("melody");
+  return {
+    low,
+    high,
+    at: phrase.startBeat,
+    budget: scene.budget,
+    candidatesAt: (beat) => {
+      const position = positionClass(beat, scene.plan.meters);
+      const chord = scene.timeline.at(beat);
+      const tones = position === "strong" && chord !== null ? _chunk3R3QVKY5cjs.chordPitchClasses.call(void 0, chord) : null;
+      const scale = scaleAt(scene, beat);
+      const candidates = position === "off" ? register : tones !== null ? register.filter((pitch) => tones.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch))) : register.filter((pitch) => _chunk3R3QVKY5cjs.isScaleTone.call(void 0, pitch, scale));
+      if (candidates.length === 0) {
+        throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(
+          `no ${position} pitch at beat ${beat} fits the register ${low}..${high}`,
+          { at: phrase.startBeat }
+        );
+      }
+      return candidates;
+    },
+    costAt: (beat) => {
+      const off = positionClass(beat, scene.plan.meters) === "off";
+      const scale = scaleAt(scene, beat);
+      const target = targetPitch(phrase, beat);
+      return (pitch) => {
+        let cost = TARGET_COST * Math.abs(pitch - target);
+        if (off && !_chunk3R3QVKY5cjs.isScaleTone.call(void 0, pitch, scale)) {
+          cost += OFF_SCALE_COST;
+        }
+        return cost + draw.float(0, TIE_BREAK, index, "tie", beat, pitch);
+      };
+    },
+    targetAt: (beat) => targetPitch(phrase, beat),
+    misfits: (notes, before) => scene.harmonyMisfits([...before, ...notes]).slice(before.length).filter((kinds) => kinds !== null).length
+  };
+}
+function membersOf(plan) {
+  return plan.phrases.map((phrase, index) => {
+    const found = new Set(phrase.motifs);
+    plan.motifs.forEach((motif, m) => {
+      if (motif.phrase === index) {
+        found.add(m);
+      }
+    });
+    return [...found].sort(
+      (a, b) => (_nullishCoalesce(_optionalChain([plan, 'access', _64 => _64.motifs, 'access', _65 => _65[a], 'optionalAccess', _66 => _66.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([plan, 'access', _67 => _67.motifs, 'access', _68 => _68[b], 'optionalAccess', _69 => _69.startBeat]), () => ( 0))) || a - b
+    );
+  });
+}
+function segmentsOf(scene, index) {
+  const phrase = scene.plan.phrases[index];
+  const segments = [];
+  let cursor = phrase.startBeat;
+  for (const m of scene.members[index]) {
+    const motif = scene.plan.motifs[m];
+    if (motif === void 0) {
+      continue;
+    }
+    if (motif.startBeat > cursor + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      segments.push({ startBeat: cursor, endBeat: motif.startBeat, motif: null });
+    }
+    segments.push({ startBeat: motif.startBeat, endBeat: motif.endBeat, motif: m });
+    cursor = Math.max(cursor, motif.endBeat);
+  }
+  if (phrase.endBeat > cursor + _chunkS5BKZZGMcjs.BEAT_EPS) {
+    segments.push({ startBeat: cursor, endBeat: phrase.endBeat, motif: null });
+  }
+  return segments;
+}
+function notesAt(onsets, endBeat) {
+  return onsets.map((startBeat, i) => ({
+    pitch: 0,
+    startBeat,
+    durationBeat: (_nullishCoalesce(onsets[i + 1], () => ( endBeat))) - startBeat
+  }));
+}
+function onsetSlots(scene, startBeat, endBeat) {
+  const { meters } = scene.plan;
+  const slots = [startBeat];
+  let bar2 = _chunkS5BKZZGMcjs.barStartBeat.call(void 0, startBeat, meters);
+  while (bar2 < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    const barEnd = bar2 + _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, bar2, meters);
+    for (let k = 0; bar2 + k / RHYTHM_SUBDIVISION < barEnd - _chunkS5BKZZGMcjs.BEAT_EPS; k += 1) {
+      const beat = bar2 + k / RHYTHM_SUBDIVISION;
+      if (beat > startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && beat < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+        slots.push(beat);
+      }
+    }
+    bar2 = barEnd;
+  }
+  return slots;
+}
+function drawOnsets(scene, phraseIndex, startBeat, endBeat, count) {
+  const slots = onsetSlots(scene, startBeat, endBeat);
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, slots.length * Math.max(1, count - 1), "melody onset slots", scene.budget);
+  if (count - 1 > slots.length - 1) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(
+      `${count} onsets do not fit the sixteenth grid of beats ${startBeat}..${endBeat}`,
+      { at: scene.plan.phrases[phraseIndex].startBeat }
+    );
+  }
+  const levels = slots.map((beat) => _chunkIFZDWIKMcjs.rhythmLevel.call(void 0, beat, scene.plan.meters));
+  const perLevel = /* @__PURE__ */ new Map();
+  for (const level of levels) {
+    perLevel.set(level, (_nullishCoalesce(perLevel.get(level), () => ( 0))) + 1);
+  }
+  const levelWeight = levels.map(
+    (level) => (_nullishCoalesce(scene.plan.rhythm.onsetLevels[level], () => ( 0))) / perLevel.get(level)
+  );
+  const draw = scene.ctx.part("melody");
+  const onsets = [startBeat];
+  let current = 0;
+  for (let k = 1; k < count; k += 1) {
+    const last = slots.length - 1 - (count - 1 - k);
+    const candidates = [];
+    for (let j = current + 1; j <= last; j += 1) candidates.push(j);
+    const gapShare = (j) => _nullishCoalesce(scene.plan.rhythm.interOnsetShares[_chunkIFZDWIKMcjs.ioiBinIndex.call(void 0, slots[j] - slots[current])], () => ( 0));
+    let weights = candidates.map((j) => levelWeight[j] * gapShare(j));
+    if (!weights.some((w) => w > 0)) weights = candidates.map((j) => levelWeight[j]);
+    if (!weights.some((w) => w > 0)) weights = candidates.map(() => 1);
+    const total = weights.reduce((sum, w) => sum + w, 0);
+    let target = draw.float(0, 1, phraseIndex, "onset", startBeat, k) * total;
+    let pick = candidates.length - 1;
+    for (let c = 0; c < candidates.length; c += 1) {
+      target -= weights[c];
+      if (target < 0) {
+        pick = c;
+        break;
+      }
+    }
+    current = candidates[pick];
+    onsets.push(slots[current]);
+  }
+  return notesAt(onsets, endBeat);
+}
+function placeRhythm(scene, motif) {
+  const { rhythm, startBeat, endBeat, notes } = motif;
+  if (rhythm === null) {
+    return drawOnsets(scene, motif.phrase, startBeat, endBeat, notes);
+  }
+  const onsets = [startBeat];
+  for (const gap of rhythm) {
+    onsets.push(onsets.at(-1) + gap);
+  }
+  return notesAt(onsets, endBeat);
+}
+function searchedLine(rhythm, frame) {
+  const slots = rhythm.map((note2) => ({
+    candidates: frame.candidatesAt(note2.startBeat),
+    cost: frame.costAt(note2.startBeat),
+    fixed: false
+  }));
+  const pitches = searchPitches(slots, frame.budget);
+  if (pitches === null) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(`no pitch line fits the register ${frame.low}..${frame.high}`, {
+      at: frame.at
+    });
+  }
+  return rhythm.map((note2, i) => ({ ...note2, pitch: pitches[i] }));
+}
+function statementOf(scene, m) {
+  const known = scene.statements.get(m);
+  if (known !== void 0) {
+    return known;
+  }
+  scene.inProgress.add(m);
+  const motif = scene.plan.motifs[m];
+  const frame = scene.frames[motif.phrase];
+  let notes;
+  if (motif.from === null) {
+    if (motif.endBeat - motif.startBeat <= _chunkS5BKZZGMcjs.BEAT_EPS) {
+      throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(`root motif ${m} spans no time to place its notes in`, {
+        at: frame.at
+      });
+    }
+    notes = searchedLine(placeRhythm(scene, motif), frame);
+  } else {
+    const source = statementOf(scene, motif.from);
+    notes = motif.relation === null ? varyStatement(source, motif.startBeat, frame) : placeDerived(
+      source,
+      motif.relation,
+      motif.startBeat,
+      motif.endBeat,
+      scaleAt(scene, motif.startBeat),
+      frame,
+      lineBefore(scene, motif.phrase, motif.startBeat)
+    );
+  }
+  scene.inProgress.delete(m);
+  scene.statements.set(m, notes);
+  return notes;
+}
+function freeNoteCount(scene, index, segment) {
+  const phrase = scene.plan.phrases[index];
+  const bars = _chunkIFZDWIKMcjs.barSpanOf.call(void 0, segment.startBeat, segment.endBeat, scene.plan.meters);
+  return Math.max(1, Math.round(phrase.onsetDensity * bars));
+}
+function freeSpan(scene, index, segment) {
+  const key = `${index}:${segment.startBeat}`;
+  const known = scene.free.get(key);
+  if (known !== void 0) {
+    return known;
+  }
+  const rhythm = drawOnsets(
+    scene,
+    index,
+    segment.startBeat,
+    segment.endBeat,
+    freeNoteCount(scene, index, segment)
+  );
+  const notes = searchedLine(rhythm, scene.frames[index]);
+  scene.free.set(key, notes);
+  return notes;
+}
+function lineBefore(scene, index, beat) {
+  const line = [];
+  for (const segment of segmentsOf(scene, index)) {
+    if (segment.endBeat > beat + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      break;
+    }
+    if (segment.motif === null) {
+      line.push(...freeSpan(scene, index, segment));
+    } else if (!scene.inProgress.has(segment.motif)) {
+      line.push(...statementOf(scene, segment.motif));
+    }
+  }
+  return line.sort((a, b) => a.startBeat - b.startBeat);
+}
+function finalDownbeat(scene, index) {
+  const phrase = scene.plan.phrases[index];
+  const { meters } = scene.plan;
+  let downbeat = _chunkS5BKZZGMcjs.barStartBeat.call(void 0, phrase.startBeat, meters);
+  while (downbeat + _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, downbeat, meters) < phrase.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    downbeat += _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, downbeat, meters);
+  }
+  return Math.max(downbeat, phrase.startBeat);
+}
+function heldNoteIndex(scene, index, line, downbeat) {
+  const phrase = scene.plan.phrases[index];
+  const sounding2 = line.findIndex(
+    (note2) => note2.startBeat <= downbeat + _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat + note2.durationBeat > downbeat + _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+  return sounding2 >= 0 ? sounding2 : line.findIndex(
+    (note2) => note2.startBeat >= downbeat - _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat < phrase.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+}
+function repairCadence(scene, index, line, held) {
+  const phrase = scene.plan.phrases[index];
+  if (phrase.cadence === null) {
+    return;
+  }
+  let target = held;
+  for (let i = line.length - 1; target < 0 && i >= 0; i -= 1) {
+    if (positionClass(line[i].startBeat, scene.plan.meters) !== "off") {
+      target = i;
+    }
+  }
+  if (target < 0) {
+    return;
+  }
+  const note2 = line[target];
+  const allowed = cadencePitchClasses(scene.plan, scene.timeline, phrase.cadence, note2.startBeat);
+  if (allowed === null) {
+    return;
+  }
+  const frame = scene.frames[index];
+  const candidates = registerPitches(phrase).filter(
+    (pitch) => allowed.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, pitch))
+  );
+  if (candidates.length === 0) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(
+      `no pitch in the register ${frame.low}..${frame.high} can end the ${phrase.cadence} cadence`,
+      { at: frame.at }
+    );
+  }
+  if (allowed.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note2.pitch))) {
+    return;
+  }
+  const slots = line.map(
+    (n, i) => i === target ? { candidates, cost: frame.costAt(n.startBeat), fixed: false } : { candidates: [n.pitch], cost: () => 0, fixed: true }
+  );
+  const pitches = searchPitches(slots, frame.budget);
+  if (pitches === null) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(`no cadence pitch joins its neighbours without an augmented step`, {
+      at: frame.at
+    });
+  }
+  note2.pitch = pitches[target];
+}
+function repickCutOnset(scene, index, line, held) {
+  const note2 = line[held];
+  const derived = scene.plan.motifs.some(
+    (motif) => motif.from !== null && note2.startBeat >= motif.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat < motif.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+  if (scene.plan.phrases[index].cadence !== null || derived) {
+    return;
+  }
+  const frame = scene.frames[index];
+  const candidates = frame.candidatesAt(note2.startBeat);
+  if (candidates.includes(note2.pitch)) {
+    return;
+  }
+  const slots = line.map(
+    (n, i) => i === held ? { candidates, cost: frame.costAt(n.startBeat), fixed: false } : { candidates: [n.pitch], cost: () => 0, fixed: true }
+  );
+  const pitches = searchPitches(slots, frame.budget);
+  if (pitches === null) {
+    throw new (0, _chunkS5BKZZGMcjs.NoSolutionError)(`no pitch at the final downbeat joins its neighbours`, {
+      at: frame.at
+    });
+  }
+  line[held] = { ...note2, pitch: pitches[held] };
+}
+function phraseLine(scene, index) {
+  const line = [];
+  for (const segment of segmentsOf(scene, index)) {
+    line.push(
+      ...segment.motif === null ? freeSpan(scene, index, segment) : statementOf(scene, segment.motif)
+    );
+  }
+  return line.sort((a, b) => a.startBeat - b.startBeat);
+}
+function chargePitchSearch(scene) {
+  const { plan } = scene;
+  let estimate = 0;
+  plan.phrases.forEach((phrase, index) => {
+    let searched = 0;
+    for (const segment of segmentsOf(scene, index)) {
+      const motif = segment.motif === null ? void 0 : plan.motifs[segment.motif];
+      if (motif === void 0) {
+        searched += freeNoteCount(scene, index, segment);
+      } else if (motif.relation === null) {
+        searched += motif.notes;
+      } else {
+        estimate += motif.notes * relationLevels(motif.relation.kind).length;
+      }
+    }
+    const register = Math.max(0, phrase.register.high - phrase.register.low + 1);
+    estimate += searched * SEARCH_STATES_SQUARED * register * register;
+  });
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, estimate, "melody pitch search", scene.budget);
+}
+function generateMelody(plan, opts) {
+  assertCompositionPlan(plan);
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  if (asked.budget !== void 0) {
+    _chunkS5BKZZGMcjs.assertPositiveInt.call(void 0, asked.budget, "budget", Number.MAX_SAFE_INTEGER);
+  }
+  const timeline = planChordTimeline(plan);
+  const scene = {
+    plan,
+    ctx: melodyContext(plan, asked.ctx),
+    budget: asked.budget,
+    timeline,
+    harmonyMisfits: planHarmonyMisfits(plan, timeline),
+    scales: plan.keys.map((key) => _chunk3R3QVKY5cjs.scaleOf.call(void 0, key)),
+    members: membersOf(plan),
+    frames: [],
+    statements: /* @__PURE__ */ new Map(),
+    free: /* @__PURE__ */ new Map(),
+    inProgress: /* @__PURE__ */ new Set()
+  };
+  scene.frames = plan.phrases.map((_, index) => frameOf(scene, index));
+  chargePitchSearch(scene);
+  const melody = [];
+  plan.phrases.forEach((_, index) => {
+    const line = phraseLine(scene, index);
+    const downbeat = finalDownbeat(scene, index);
+    let held = heldNoteIndex(scene, index, line, downbeat);
+    if (held >= 0) {
+      line.length = held + 1;
+      const note2 = line[held];
+      if (note2.startBeat < downbeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+        const cut = downbeat - note2.startBeat;
+        line[held] = { ...note2, durationBeat: cut };
+        line.push({ ...note2, startBeat: downbeat, durationBeat: note2.durationBeat - cut });
+        held += 1;
+        repickCutOnset(scene, index, line, held);
+      }
+    }
+    repairCadence(scene, index, line, held);
+    if (held >= 0) {
+      const note2 = line[held];
+      const phraseEnd = plan.phrases[index].endBeat;
+      line[held] = { ...note2, durationBeat: phraseEnd - note2.startBeat };
+    }
+    melody.push(...line);
+  });
+  melody.sort((a, b) => a.startBeat - b.startBeat);
+  return motifToNoteEvents({ notes: melody });
+}
+
 // src/generate/ornament/index.ts
 var ORNAMENT_STYLES = Object.freeze(["ghost", "flam", "drag", "slide", "accent"]);
 var DEFAULT_TS5 = { numerator: 4, denominator: 4 };
@@ -4849,7 +5941,7 @@ var MIN_VELOCITY2 = 1;
 var MAX_VELOCITY2 = 127;
 var SLIDE_MIN_SEMITONES = 1;
 function eligible(style, note2, previous, next, ts) {
-  const strong = _chunkXKSO2V5Icjs.isStrongBeat.call(void 0, note2.startBeat, ts);
+  const strong = _chunkS5BKZZGMcjs.isStrongBeat.call(void 0, note2.startBeat, ts);
   switch (style) {
     case "ghost":
       return !strong;
@@ -4857,7 +5949,7 @@ function eligible(style, note2, previous, next, ts) {
     case "accent":
       return strong;
     case "drag":
-      return !strong && next !== void 0 && _chunkXKSO2V5Icjs.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;
   }
@@ -4882,18 +5974,18 @@ function clampVelocity(velocity) {
   return Math.min(MAX_VELOCITY2, Math.max(MIN_VELOCITY2, Math.round(velocity)));
 }
 function ornament(notes, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, notes, "ornament notes", { allowNonPositiveDuration: true });
-  const style = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, _nullishCoalesce(asked.style, () => ( DEFAULT_STYLE2)), ORNAMENT_STYLES, "ornament style");
-  const ts = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, _nullishCoalesce(asked.ts, () => ( DEFAULT_TS5)), "ts"));
-  _chunkXKSO2V5Icjs.assertTimeSignature.call(void 0, ts);
+  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) {
-    _chunkXKSO2V5Icjs.assertRange.call(void 0, asked.amount, 0, 1, "ornament amount");
+    _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 sounding2 = _chunkXKSO2V5Icjs.dropSilentNotes.call(void 0, notes);
+  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);
@@ -4961,6 +6053,878 @@ function strokeGaps(ordered) {
   return gaps;
 }
 
+// src/generate/plan/derive.ts
+var PRESERVE_ASPECTS = [
+  "form",
+  "phraseLengths",
+  "harmonicFunction",
+  "harmonicRhythm",
+  "motifRelations",
+  "registerShape",
+  "rhythm"
+];
+var NEUTRAL_SHAPE = "arch";
+var NEUTRAL_PEAK_POSITION = 0.6;
+var SHAPE_KEEP_THRESHOLD = 0.5;
+var NEUTRAL_ONSET_LEVELS = Object.freeze([0, 1, 2, 3, 4, 5].map((level) => level / 15));
+var FUNCTION_DEGREES = {
+  tonic: [1, 6, 3],
+  subdominant: [4, 2],
+  dominant: [5, 7]
+};
+var STRONG_WEIGHT2 = 2;
+var HEPTATONIC_DEGREES = 7;
+function mod12(value) {
+  return (value % 12 + 12) % 12;
+}
+function lerp(weight, reference, neutral) {
+  return weight * reference + (1 - weight) * neutral;
+}
+function readPreserve(value) {
+  const read = value === void 0 ? {} : _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, "opts.preserve");
+  const weights = {};
+  for (const aspect of PRESERVE_ASPECTS) {
+    const weight = read[aspect];
+    weights[aspect] = weight === void 0 ? 1 : _chunkS5BKZZGMcjs.assertRange.call(void 0, weight, 0, 1, `opts.preserve.${aspect}`);
+  }
+  return weights;
+}
+function readRegister(value) {
+  const read = _chunkS5BKZZGMcjs.assertRecord.call(void 0, value, "opts.register");
+  const low = _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, read.low, "opts.register.low");
+  const high = _chunkS5BKZZGMcjs.assertMidiPitch.call(void 0, read.high, "opts.register.high");
+  if (low > high) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `opts.register.low must not exceed opts.register.high; received ${low} > ${high}`
+    );
+  }
+  return { low, high };
+}
+function rejectSuppliedRng(ctx) {
+  if (typeof ctx === "object" && ctx !== null && ctx.rng !== void 0) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      "opts.ctx.rng is not accepted: a composition plan records its seed, not a source"
+    );
+  }
+}
+function plannedKeys(profile, requested) {
+  const regions = profile.harmony.keys.map(
+    ({ key }) => ({
+      scale: { ...key.scale },
+      tonic: { ...key.tonic },
+      variant: key.variant
+    })
+  );
+  const home = regions[0];
+  if (requested === void 0) {
+    return regions;
+  }
+  const target = _chunk3R3QVKY5cjs.resolveKey.call(void 0, requested);
+  if (target.variant !== home.variant || target.scale.modeMask12 !== home.scale.modeMask12) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      "opts.key must be in the same mode as the reference's home key; a key change moves the tonic only"
+    );
+  }
+  const step = _chunkS5BKZZGMcjs.spelledInterval.call(void 0, 
+    { letter: home.tonic.letter, alter: home.tonic.alter },
+    { letter: target.tonic.letter, alter: target.tonic.alter }
+  );
+  const moved = regions.map(
+    (key) => ({
+      scale: {
+        rootPc: mod12(key.scale.rootPc + step.semitones),
+        modeMask12: key.scale.modeMask12
+      },
+      tonic: _chunkS5BKZZGMcjs.transposeByInterval.call(void 0, { letter: key.tonic.letter, alter: key.tonic.alter }, step),
+      variant: key.variant
+    })
+  );
+  moved[0] = target;
+  return moved;
+}
+function nearestBoundary(beat, boundaries) {
+  let best = beat;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const boundary of boundaries) {
+    const distance = Math.abs(boundary - beat);
+    if (distance < bestDistance - _chunkS5BKZZGMcjs.BEAT_EPS) {
+      best = boundary;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function plannedSections(profile, weight, draw) {
+  const sections = profile.form.sections;
+  const boundaries = [profile.span.startBeat, profile.span.endBeat];
+  for (const phrase of profile.form.phrases) {
+    boundaries.push(phrase.startBeat, phrase.endBeat);
+  }
+  boundaries.sort((a, b) => a - b);
+  const planned = [];
+  sections.forEach((section, index) => {
+    const keep = sections.length < 2 || draw.prob(weight, "form", index);
+    const neighbour = index + 1 < sections.length ? index + 1 : index - 1;
+    const startBeat = nearestBoundary(section.startBeat, boundaries);
+    const endBeat = nearestBoundary(section.endBeat, boundaries);
+    if (endBeat - startBeat > _chunkS5BKZZGMcjs.BEAT_EPS) {
+      planned.push({
+        label: keep ? section.label : _nullishCoalesce(_optionalChain([sections, 'access', _70 => _70[neighbour], 'optionalAccess', _71 => _71.label]), () => ( section.label)),
+        startBeat,
+        endBeat
+      });
+    }
+  });
+  return planned;
+}
+function beatAfterBars(startBeat, bars, meters) {
+  let beat = startBeat;
+  let left = bars;
+  while (left > _chunkS5BKZZGMcjs.BEAT_EPS) {
+    const step = Math.min(1, left);
+    beat += step * _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, beat, meters);
+    left -= step;
+  }
+  return beat;
+}
+function barsBetween(startBeat, endBeat, meters) {
+  let beat = startBeat;
+  let bars = 0;
+  while (beat < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+    const barBeats = _chunkS5BKZZGMcjs.beatsPerBarAt.call(void 0, beat, meters);
+    const step = Math.min(_chunkS5BKZZGMcjs.barStartBeat.call(void 0, beat, meters) + barBeats, endBeat) - beat;
+    bars += step / barBeats;
+    beat += step;
+  }
+  return bars;
+}
+function spanSegments(profile, sections) {
+  const { startBeat, endBeat } = profile.span;
+  const cuts = [startBeat, endBeat];
+  for (const section of sections) {
+    for (const beat of [section.startBeat, section.endBeat]) {
+      if (beat > startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && beat < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) cuts.push(beat);
+    }
+  }
+  cuts.sort((a, b) => a - b);
+  const segments = [];
+  for (let index = 1; index < cuts.length; index += 1) {
+    const from = cuts[index - 1];
+    const to = cuts[index];
+    if (to - from > _chunkS5BKZZGMcjs.BEAT_EPS) segments.push([from, to]);
+  }
+  return segments;
+}
+function plannedPhraseSpans(profile, sections, weight, draw) {
+  const segments = spanSegments(profile, sections);
+  const pieces = profile.form.phrases.map((phrase, source) => ({
+    startBeat: phrase.startBeat,
+    endBeat: phrase.endBeat,
+    source,
+    cadence: _nullishCoalesce(_optionalChain([phrase, 'access', _72 => _72.cadence, 'optionalAccess', _73 => _73.type]), () => ( null))
+  }));
+  const replaced = pieces.map((_, index) => !draw.prob(weight, "phraseLengths", index));
+  const spans = [];
+  for (const [segmentStart, segmentEnd] of segments) {
+    const members = pieces.map((piece, index) => ({ piece, index })).filter(
+      ({ piece }) => piece.startBeat >= segmentStart - _chunkS5BKZZGMcjs.BEAT_EPS && piece.startBeat < segmentEnd - _chunkS5BKZZGMcjs.BEAT_EPS
+    );
+    const laid = [];
+    let cursor = segmentStart;
+    for (const { piece, index } of members) {
+      const lengths = [];
+      if (replaced[index]) {
+        const bars = barsBetween(piece.startBeat, piece.endBeat, profile.meters);
+        const rounded = 2 ** Math.round(Math.log2(bars));
+        const overflows = beatAfterBars(cursor, rounded, profile.meters) > segmentEnd + _chunkS5BKZZGMcjs.BEAT_EPS;
+        let partStart = cursor;
+        for (const part of overflows ? [rounded / 2, rounded / 2] : [rounded]) {
+          const partEnd = beatAfterBars(partStart, part, profile.meters);
+          lengths.push(partEnd - partStart);
+          partStart = partEnd;
+        }
+      } else {
+        lengths.push(piece.endBeat - piece.startBeat);
+      }
+      lengths.forEach((length, part) => {
+        if (cursor >= segmentEnd - _chunkS5BKZZGMcjs.BEAT_EPS) return;
+        const end = cursor + length;
+        laid.push({
+          startBeat: cursor,
+          endBeat: Math.min(end, segmentEnd),
+          source: piece.source,
+          cadence: part === lengths.length - 1 ? piece.cadence : null
+        });
+        cursor = end;
+      });
+    }
+    const last = laid.at(-1);
+    if (last) {
+      last.endBeat = segmentEnd;
+    } else {
+      laid.push({
+        startBeat: segmentStart,
+        endBeat: segmentEnd,
+        source: _nullishCoalesce(_optionalChain([spans, 'access', _74 => _74.at, 'call', _75 => _75(-1), 'optionalAccess', _76 => _76.source]), () => ( (profile.form.phrases.length > 0 ? 0 : -1))),
+        cadence: null
+      });
+    }
+    spans.push(...laid);
+  }
+  return spans;
+}
+function sectionAt(sections, beat) {
+  const index = sections.findIndex(
+    (section) => beat >= section.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && beat < section.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+  return index < 0 ? null : index;
+}
+function phraseHolding(phrases, startBeat, endBeat) {
+  return phrases.findIndex(
+    (phrase) => startBeat >= phrase.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && endBeat <= phrase.endBeat + _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+}
+function better(a, b) {
+  for (let field = 0; field < a.length; field += 1) {
+    if (a[field] !== b[field]) return a[field] > b[field];
+  }
+  return false;
+}
+function scheduleMotifs(candidates, meters) {
+  const order = [...candidates].sort((a, b) => a.startBeat - b.startBeat || a.node - b.node);
+  const count = order.length;
+  const firstFrom = (from, beat) => {
+    let low = from;
+    let high = count;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (order[mid].startBeat < beat - _chunkS5BKZZGMcjs.BEAT_EPS) low = mid + 1;
+      else high = mid;
+    }
+    return low;
+  };
+  const next = order.map((candidate, index2) => firstFrom(index2 + 1, candidate.endBeat));
+  const own = order.map(
+    (candidate) => [
+      candidate.notes,
+      _chunkS5BKZZGMcjs.metricWeight.call(void 0, candidate.startBeat, meters) < STRONG_WEIGHT2 ? -1 : 0,
+      1
+    ]
+  );
+  const taking = (index2) => {
+    const rest = best[next[index2]];
+    const mine = own[index2];
+    return [mine[0] + rest[0], mine[1] + rest[1], mine[2] + rest[2]];
+  };
+  const best = new Array(count + 1).fill([0, 0, 0]);
+  for (let index2 = count - 1; index2 >= 0; index2 -= 1) {
+    const taken = taking(index2);
+    const skipped = best[index2 + 1];
+    best[index2] = better(taken, skipped) ? taken : skipped;
+  }
+  const chosen = [];
+  let index = 0;
+  while (index < count) {
+    if (!better(best[index], taking(index))) {
+      chosen.push(order[index]);
+      index = next[index];
+    } else {
+      index += 1;
+    }
+  }
+  return chosen.sort((a, b) => a.node - b.node);
+}
+function selectedDerivation(graph, parentEdge, selectedAt, node) {
+  let plain = true;
+  let semitones = 0;
+  let steps = 0;
+  for (let edge = parentEdge.get(node); edge !== void 0; edge = parentEdge.get(edge.from)) {
+    const relation = edge.relation;
+    steps += 1;
+    plain &&= relation !== null && (relation.kind === "repetition" || relation.kind === "transposition" && Math.abs(relation.timeRatio - 1) <= _chunkS5BKZZGMcjs.BEAT_EPS);
+    semitones += _nullishCoalesce(_optionalChain([relation, 'optionalAccess', _77 => _77.semitones]), () => ( 0));
+    const from = selectedAt.get(edge.from);
+    if (from === void 0) continue;
+    if (steps === 1) {
+      return { from, relation: relation === null ? null : { ...relation } };
+    }
+    if (!plain) {
+      return { from: null, relation: null };
+    }
+    const gap = (_nullishCoalesce(_optionalChain([graph, 'access', _78 => _78.nodes, 'access', _79 => _79[node], 'optionalAccess', _80 => _80.startBeat]), () => ( 0))) - (_nullishCoalesce(_optionalChain([graph, 'access', _81 => _81.nodes, 'access', _82 => _82[edge.from], 'optionalAccess', _83 => _83.endBeat]), () => ( 0)));
+    return {
+      from,
+      relation: {
+        kind: semitones === 0 ? "repetition" : "transposition",
+        sequence: gap >= -_chunkIFZDWIKMcjs.HUMANIZE_ADJACENCY && gap <= _chunkIFZDWIKMcjs.HUMANIZE_ADJACENCY,
+        semitones,
+        timeRatio: 1
+      }
+    };
+  }
+  return { from: null, relation: null };
+}
+function functionCandidates(fn, key) {
+  if (_chunk3R3QVKY5cjs.scaleTonesInDegreeOrder.call(void 0, key).length !== HEPTATONIC_DEGREES) {
+    return null;
+  }
+  return FUNCTION_DEGREES[fn].map((degree) => _chunkIFZDWIKMcjs.chordToRoman.call(void 0, _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key), key));
+}
+function plannedHarmony(profile, keys, preserve, draw) {
+  const chords = profile.harmony.chords;
+  const romans = chords.map((chord, index) => {
+    if (chord.level !== "structural" || draw.prob(preserve.harmonicFunction, "harmonicFunction", index)) {
+      return chord.roman;
+    }
+    const candidates = functionCandidates(chord.function, keys[chord.key]);
+    if (candidates === null) {
+      return chord.roman;
+    }
+    const pick = draw.range(0, candidates.length - 1, "harmonicFunction", index, "pick");
+    return candidates[pick];
+  });
+  const starts = [];
+  chords.forEach((chord, index) => {
+    const keep = index === 0 || draw.prob(preserve.harmonicRhythm, "harmonicRhythm", index);
+    const start = keep ? chord.startBeat : _chunkS5BKZZGMcjs.barStartBeat.call(void 0, chord.startBeat, profile.meters);
+    starts.push(index === 0 ? start : Math.max(start, starts[index - 1]));
+  });
+  const planned = [];
+  chords.forEach((chord, index) => {
+    const next = chords[index + 1];
+    const nextStart = starts[index + 1];
+    let endBeat = chord.endBeat;
+    if (next !== void 0 && nextStart !== void 0) {
+      endBeat = Math.abs(chord.endBeat - next.startBeat) <= _chunkS5BKZZGMcjs.BEAT_EPS ? nextStart : Math.min(chord.endBeat, nextStart);
+    }
+    const startBeat = starts[index];
+    if (endBeat - startBeat > _chunkS5BKZZGMcjs.BEAT_EPS) {
+      planned.push({ startBeat, endBeat, key: chord.key, roman: romans[index] });
+    }
+  });
+  return planned;
+}
+function plannedRhythm(profile, weight) {
+  const reference = profile.melody.rhythm;
+  return {
+    onsetLevels: reference.onsetLevels.map(
+      (share, level) => lerp(weight, share, NEUTRAL_ONSET_LEVELS[level])
+    ),
+    interOnsetShares: [...reference.interOnsetShares],
+    syncopation: lerp(weight, reference.syncopation, 0)
+  };
+}
+function deriveCompositionPlan(reference, opts) {
+  const profile = _chunkIFZDWIKMcjs.assertReferenceProfile.call(void 0, reference, "reference");
+  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "opts");
+  const preserve = readPreserve(asked.preserve);
+  const requestedRegister = asked.register === void 0 ? void 0 : readRegister(asked.register);
+  rejectSuppliedRng(asked.ctx);
+  const ctx = resolveContext(asked.ctx);
+  const draw = ctx.part("plan");
+  const melodyRegister = profile.melody.register;
+  if (profile.melody.rhythm.onsets === 0 || melodyRegister === null) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)("reference must carry melody onsets to derive a plan from");
+  }
+  const keys = plannedKeys(profile, asked.key);
+  const homeShift = mod12(
+    keys[0].scale.rootPc - (_nullishCoalesce(_optionalChain([profile, 'access', _84 => _84.harmony, 'access', _85 => _85.keys, 'access', _86 => _86[0], 'optionalAccess', _87 => _87.key, 'access', _88 => _88.scale, 'access', _89 => _89.rootPc]), () => ( 0)))
+  );
+  const shift = homeShift >= 6 ? homeShift - 12 : homeShift;
+  const source = { low: melodyRegister.low + shift, high: melodyRegister.high + shift };
+  if (source.low < 0 || source.high > 127) {
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
+      `the reference melody range moved to the new key leaves the MIDI range; received ${source.low}..${source.high}`
+    );
+  }
+  const target = _nullishCoalesce(requestedRegister, () => ( source));
+  const scale = source.high === source.low ? 0 : (target.high - target.low) / (source.high - source.low);
+  const offset = source.high === source.low ? (target.low + target.high) / 2 : target.low - source.low * scale;
+  const mapPitch = (pitch) => (pitch + shift) * scale + offset;
+  const neutralRegister = {
+    low: target.low,
+    high: target.high,
+    mean: (target.low + target.high) / 2
+  };
+  const sections = plannedSections(profile, preserve.form, draw);
+  const shapeWeight = preserve.registerShape;
+  const spans = plannedPhraseSpans(profile, sections, preserve.phraseLengths, draw);
+  const phrases = spans.map((span) => {
+    const melody = _nullishCoalesce(_optionalChain([profile, 'access', _90 => _90.form, 'access', _91 => _91.phrases, 'access', _92 => _92[span.source], 'optionalAccess', _93 => _93.melody]), () => ( null));
+    const register = melody ? {
+      low: Math.round(lerp(shapeWeight, mapPitch(melody.low), neutralRegister.low)),
+      high: Math.round(lerp(shapeWeight, mapPitch(melody.high), neutralRegister.high)),
+      mean: lerp(shapeWeight, mapPitch(melody.mean), neutralRegister.mean)
+    } : { ...neutralRegister };
+    return {
+      startBeat: span.startBeat,
+      endBeat: span.endBeat,
+      section: sectionAt(sections, span.startBeat),
+      cadence: span.cadence,
+      shape: melody && shapeWeight >= SHAPE_KEEP_THRESHOLD ? melody.shape : NEUTRAL_SHAPE,
+      peakPosition: melody ? lerp(shapeWeight, melody.peakPosition, NEUTRAL_PEAK_POSITION) : NEUTRAL_PEAK_POSITION,
+      register,
+      onsetDensity: melody ? melody.onsetDensity : profile.melody.rhythm.onsetDensity,
+      motifs: []
+    };
+  });
+  const graph = profile.melody.graph;
+  const noteCount = (node) => (_nullishCoalesce(_optionalChain([profile, 'access', _94 => _94.melody, 'access', _95 => _95.motifs, 'access', _96 => _96[_nullishCoalesce(_optionalChain([graph, 'access', _97 => _97.nodes, 'access', _98 => _98[node], 'optionalAccess', _99 => _99.motif]), () => ( -1))], 'optionalAccess', _100 => _100.intervals, 'access', _101 => _101.length]), () => ( 0))) + 1;
+  _chunkS5BKZZGMcjs.assertGenerationBudget.call(void 0, graph.nodes.length * phrases.length, "plan motif selection", asked.budget);
+  const candidates = [];
+  graph.nodes.forEach((node, index) => {
+    const phrase = phraseHolding(phrases, node.startBeat, node.endBeat);
+    if (phrase >= 0) {
+      candidates.push({
+        node: index,
+        phrase,
+        startBeat: node.startBeat,
+        endBeat: node.endBeat,
+        notes: noteCount(index)
+      });
+    }
+  });
+  const selected = scheduleMotifs(candidates, profile.meters);
+  const selectedAt = new Map(selected.map((candidate, index) => [candidate.node, index]));
+  const parentEdge = new Map(graph.edges.map((edge) => [edge.to, edge]));
+  const motifs = selected.map((candidate, index) => {
+    const { from, relation } = selectedDerivation(graph, parentEdge, selectedAt, candidate.node);
+    const keepRelation = draw.prob(preserve.motifRelations, "motifRelations", index);
+    const keepRhythm = from === null && draw.prob(preserve.rhythm, "rhythm", index);
+    const cell = profile.melody.motifs[_nullishCoalesce(_optionalChain([graph, 'access', _102 => _102.nodes, 'access', _103 => _103[candidate.node], 'optionalAccess', _104 => _104.motif]), () => ( -1))];
+    _optionalChain([phrases, 'access', _105 => _105[candidate.phrase], 'optionalAccess', _106 => _106.motifs, 'access', _107 => _107.push, 'call', _108 => _108(index)]);
+    return {
+      phrase: candidate.phrase,
+      startBeat: candidate.startBeat,
+      endBeat: candidate.endBeat,
+      notes: candidate.notes,
+      rhythm: keepRhythm && cell !== void 0 ? cell.rhythm.map((ratio) => ratio * cell.unitBeats) : null,
+      from,
+      relation: keepRelation ? relation : null
+    };
+  });
+  return {
+    planVersion: COMPOSITION_PLAN_VERSION,
+    seed: ctx.seed,
+    algorithmVersion: ctx.algorithmVersion,
+    keys,
+    meters: profile.meters.map((entry) => ({
+      startBeat: entry.startBeat,
+      ts: entry.ts.grouping === void 0 ? { ...entry.ts } : { ...entry.ts, grouping: [...entry.ts.grouping] }
+    })),
+    span: { ...profile.span },
+    sections,
+    phrases,
+    harmony: plannedHarmony(profile, keys, preserve, draw),
+    motifs,
+    rhythm: plannedRhythm(profile, preserve.rhythm)
+  };
+}
+
+// src/generate/plan/evaluate.ts
+var PEAK_POSITION_TOLERANCE = 0.2;
+var OUTLINE_POINTS = 8;
+var HELD_NOTE_BEATS = 1;
+function interiorBoundaries(plan) {
+  const beats = /* @__PURE__ */ new Set();
+  for (const phrase of plan.phrases) {
+    for (const beat of [phrase.startBeat, phrase.endBeat]) {
+      if (beat > plan.span.startBeat + _chunkS5BKZZGMcjs.BEAT_EPS && beat < plan.span.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+        beats.add(beat);
+      }
+    }
+  }
+  return [...beats].sort((a, b) => a - b);
+}
+function restsOf(melody, plan) {
+  const rests = [];
+  let reach = plan.span.startBeat;
+  for (const note2 of [...melody].sort((a, b) => a.startBeat - b.startBeat)) {
+    if (note2.startBeat > reach + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      rests.push({ startBeat: reach, endBeat: note2.startBeat });
+    }
+    reach = Math.max(reach, note2.startBeat + note2.durationBeat);
+  }
+  if (plan.span.endBeat > reach + _chunkS5BKZZGMcjs.BEAT_EPS) {
+    rests.push({ startBeat: reach, endBeat: plan.span.endBeat });
+  }
+  return rests;
+}
+function phraseBoundaryViolations(melody, plan) {
+  const rests = restsOf(melody, plan);
+  const violations = [];
+  for (const beat of interiorBoundaries(plan)) {
+    const pulse2 = _chunkS5BKZZGMcjs.pulseBeats.call(void 0, _chunkS5BKZZGMcjs.meterAt.call(void 0, beat, plan.meters));
+    const held = melody.some(
+      (note2) => note2.durationBeat >= HELD_NOTE_BEATS - _chunkS5BKZZGMcjs.BEAT_EPS && Math.abs(note2.startBeat + note2.durationBeat - beat) <= pulse2 + _chunkS5BKZZGMcjs.BEAT_EPS
+    );
+    const rested = rests.some(
+      (rest) => rest.endBeat - rest.startBeat >= pulse2 - _chunkS5BKZZGMcjs.BEAT_EPS && rest.startBeat <= beat + pulse2 + _chunkS5BKZZGMcjs.BEAT_EPS && rest.endBeat >= beat - pulse2 - _chunkS5BKZZGMcjs.BEAT_EPS
+    );
+    if (!held && !rested) {
+      violations.push({
+        kind: "phraseBoundary",
+        severity: "error",
+        atBeat: beat,
+        expected: `a note of at least ${HELD_NOTE_BEATS} beat(s) ending, or a rest of at least ${pulse2} beat(s), within ${pulse2} beat(s)`,
+        actual: "neither",
+        rationale: `the plan places a phrase boundary at beat ${beat}, which the candidate does not mark`
+      });
+    }
+  }
+  return violations;
+}
+function spanViolation(melody, plan) {
+  const end = melody.reduce((max, note2) => Math.max(max, note2.startBeat + note2.durationBeat), 0);
+  if (end <= plan.span.endBeat + _chunkS5BKZZGMcjs.BEAT_EPS) {
+    return [];
+  }
+  return [
+    {
+      kind: "span",
+      severity: "error",
+      atBeat: plan.span.endBeat,
+      expected: `ending by beat ${plan.span.endBeat}`,
+      actual: `ending at beat ${end}`,
+      rationale: "the candidate's last note runs past the plan's span"
+    }
+  ];
+}
+function phraseLines(melody, plan) {
+  return plan.phrases.map(
+    (phrase) => melody.flatMap(
+      (note2, index) => note2.startBeat >= phrase.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat < phrase.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS ? [index] : []
+    )
+  );
+}
+function cadenceViolations(melody, plan, timeline, lines) {
+  const violations = [];
+  plan.phrases.forEach((phrase, index) => {
+    if (phrase.cadence === null) {
+      return;
+    }
+    const last = _optionalChain([lines, 'access', _109 => _109[index], 'optionalAccess', _110 => _110.at, 'call', _111 => _111(-1)]);
+    const note2 = last === void 0 ? void 0 : melody[last];
+    const allowed = note2 === void 0 ? [] : cadencePitchClasses(plan, timeline, phrase.cadence, note2.startBeat);
+    if (note2 !== void 0 && (allowed === null || allowed.includes(_chunkS5BKZZGMcjs.pitchClassOf.call(void 0, note2.pitch)))) {
+      return;
+    }
+    violations.push({
+      kind: "cadence",
+      severity: "error",
+      atBeat: phrase.endBeat,
+      expected: `a closing note on pitch class ${(_nullishCoalesce(allowed, () => ( []))).join(" or ")} for a ${phrase.cadence} cadence`,
+      actual: note2 === void 0 ? "no note" : `pitch ${note2.pitch}`,
+      rationale: `the phrase ending at beat ${phrase.endBeat} is planned to close on a ${phrase.cadence} cadence`
+    });
+  });
+  return violations;
+}
+function harmonyViolations(melody, plan, timeline, lines) {
+  const misfits = planHarmonyMisfits(plan, timeline);
+  const violations = [];
+  for (const line of lines) {
+    const read = misfits(line.map((index) => melody[index]));
+    read.forEach((kinds, at2) => {
+      if (kinds === null) {
+        return;
+      }
+      const note2 = melody[line[at2]];
+      const derived = plan.motifs.some(
+        (motif) => motif.from !== null && note2.startBeat >= motif.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat < motif.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+      );
+      const strong = positionClass(note2.startBeat, plan.meters) === "strong";
+      violations.push({
+        kind: "harmony",
+        severity: derived ? "warning" : "error",
+        atBeat: note2.startBeat,
+        expected: strong ? "a chord tone or an ornamental tone" : "a chord tone, an ornamental tone, or a scale tone",
+        actual: kinds.length === 0 ? "no harmonic label" : kinds.join(", "),
+        rationale: derived ? `the note at beat ${note2.startBeat} sits in a derived statement, whose transformation takes precedence over the harmony` : `the note at beat ${note2.startBeat} does not fit the planned harmony`
+      });
+    });
+  }
+  return violations;
+}
+function notesInRange(melody, startBeat, endBeat) {
+  return melody.filter(
+    (note2) => note2.startBeat >= startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && note2.startBeat < endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+}
+function replayLevel(source, derived, statement, sourceEnd, plan, key, closing) {
+  const relation = statement.relation;
+  const planned = relation.kind === "tonalTransposition" ? _nullishCoalesce(relation.degrees, () => ( 0)) : relation.semitones;
+  const { low, high } = plan.phrases[statement.phrase].register;
+  const outside = (pitch) => pitch < low || pitch > high;
+  const backward = relation.kind === "retrograde" || relation.kind === "retrogradeInversion";
+  const cell = clipStatement(
+    source.map((note2) => ({
+      pitch: note2.pitch,
+      startBeat: note2.startBeat,
+      durationBeat: note2.durationBeat
+    })),
+    sourceEnd
+  );
+  const replays = relationLevels(relation.kind).map((level) => {
+    const notes = clipStatement(
+      replayAt(cell, relation, level, statement.startBeat, key),
+      statement.endBeat
+    );
+    return { level, notes, outside: notes.filter((note2) => outside(note2.pitch)).length };
+  });
+  const fewestOutside = Math.min(...replays.map((replay) => replay.outside));
+  let best = null;
+  for (const { level, notes: expected, outside: away } of replays) {
+    if (expected.length !== derived.length) {
+      continue;
+    }
+    let forced = 0;
+    let holds = true;
+    for (let i = 0; holds && i < expected.length; i += 1) {
+      const want = expected[i];
+      const got = derived[i];
+      if (i > 0) {
+        const gap = got.startBeat - derived[i - 1].startBeat;
+        holds = Math.abs(gap - (want.startBeat - expected[i - 1].startBeat)) <= _chunkS5BKZZGMcjs.BEAT_EPS;
+      }
+      if (!holds || got.pitch === want.pitch) {
+        continue;
+      }
+      const origin = source[backward ? cell.length - 1 - i : i];
+      forced += 1;
+      holds = closing.has(got) || origin !== void 0 && closing.has(origin) || away === fewestOutside && outside(want.pitch);
+    }
+    const distance = Math.abs(level - planned);
+    const nearer = best === null || distance < Math.abs(best.level - planned) || distance === Math.abs(best.level - planned) && level < best.level;
+    if (holds && nearer) {
+      best = { level, forced };
+    }
+  }
+  return best;
+}
+function motifDerivationViolations(melody, plan, closing) {
+  const keyAt = planKeyAt(plan);
+  const errors = [];
+  const warnings = [];
+  for (const statement of plan.motifs) {
+    if (statement.from === null) {
+      continue;
+    }
+    const source = plan.motifs[statement.from];
+    const sourceNotes = notesInRange(melody, source.startBeat, source.endBeat);
+    const derivedNotes = notesInRange(melody, statement.startBeat, statement.endBeat);
+    const relation = statement.relation;
+    const rationale = `the statement at beat ${statement.startBeat} does not derive from its source the way the plan names`;
+    if (sourceNotes.length === 0 || derivedNotes.length === 0) {
+      errors.push({
+        kind: "motifDerivation",
+        severity: "error",
+        atBeat: statement.startBeat,
+        expected: relation === null ? "a variation" : relation.kind,
+        actual: "no notes to compare",
+        rationale
+      });
+      continue;
+    }
+    if (relation === null) {
+      const similarity = _chunkIFZDWIKMcjs.melodicSimilarity.call(void 0, sourceNotes, derivedNotes);
+      if (similarity < _chunkIFZDWIKMcjs.DEFAULT_VARIATION_THRESHOLD) {
+        errors.push({
+          kind: "motifDerivation",
+          severity: "error",
+          atBeat: statement.startBeat,
+          expected: `a variation (melodicSimilarity >= ${_chunkIFZDWIKMcjs.DEFAULT_VARIATION_THRESHOLD})`,
+          actual: `melodicSimilarity ${similarity.toFixed(3)}`,
+          rationale
+        });
+      }
+      continue;
+    }
+    const replay = replayLevel(
+      sourceNotes,
+      derivedNotes,
+      statement,
+      source.endBeat,
+      plan,
+      _chunk3R3QVKY5cjs.scaleOf.call(void 0, keyAt(statement.startBeat)),
+      closing
+    );
+    const planned = relation.kind === "tonalTransposition" ? _nullishCoalesce(relation.degrees, () => ( 0)) : relation.semitones;
+    if (replay === null) {
+      errors.push({
+        kind: "motifDerivation",
+        severity: "error",
+        atBeat: statement.startBeat,
+        expected: relation.kind,
+        actual: "no pitch level replays the source",
+        rationale
+      });
+    } else if (replay.level !== planned || replay.forced > 0) {
+      warnings.push({
+        kind: "motifDisplaced",
+        severity: "warning",
+        atBeat: statement.startBeat,
+        expected: `${relation.kind} at level ${planned} with every pitch replayed`,
+        actual: `level ${replay.level}, ${replay.forced} excused note(s)`,
+        rationale: `the statement at beat ${statement.startBeat} carries out its planned derivation at another pitch level or with notes excused`
+      });
+    }
+  }
+  return { errors, warnings };
+}
+function phraseAt(plan, beat) {
+  return plan.phrases.find(
+    (phrase) => beat >= phrase.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS && beat < phrase.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS
+  );
+}
+function registerViolations(melody, plan) {
+  const violations = [];
+  for (const note2 of melody) {
+    const phrase = phraseAt(plan, note2.startBeat);
+    if (phrase === void 0) {
+      continue;
+    }
+    if (note2.pitch < phrase.register.low || note2.pitch > phrase.register.high) {
+      violations.push({
+        kind: "register",
+        severity: "error",
+        atBeat: note2.startBeat,
+        expected: `a pitch within [${phrase.register.low}, ${phrase.register.high}]`,
+        actual: `pitch ${note2.pitch}`,
+        rationale: `the note at beat ${note2.startBeat} falls outside its phrase's planned register`
+      });
+    }
+  }
+  return violations;
+}
+function planOutline(phrase) {
+  const amplitude = (phrase.register.high - phrase.register.low) / 2;
+  const outline = [];
+  for (let k = 0; k < OUTLINE_POINTS; k += 1) {
+    const t = (k + 0.5) / OUTLINE_POINTS;
+    outline.push(
+      phrase.register.mean + plannedContourAt(phrase.shape, phrase.peakPosition, t) * amplitude
+    );
+  }
+  return outline;
+}
+function planContourPhrase(phrase) {
+  return {
+    shape: phrase.shape,
+    low: phrase.register.low,
+    high: phrase.register.high,
+    outline: planOutline(phrase)
+  };
+}
+function planRegisterPlan(plan) {
+  const phrases = plan.phrases.map((phrase) => ({
+    low: phrase.register.low,
+    high: phrase.register.high,
+    mean: phrase.register.mean,
+    peakPosition: phrase.peakPosition
+  }));
+  let weighted = 0;
+  let weight = 0;
+  for (const phrase of plan.phrases) {
+    const length = phrase.endBeat - phrase.startBeat;
+    weighted += phrase.register.mean * length;
+    weight += length;
+  }
+  return { phrases, mean: weight > 0 ? weighted / weight : null };
+}
+function planRhythmReading(plan) {
+  const hasOnsets = plan.rhythm.onsetLevels.some((share) => share > 0);
+  return {
+    onsets: hasOnsets ? 1 : 0,
+    onsetLevels: plan.rhythm.onsetLevels,
+    barPositions: [],
+    interOnsetShares: plan.rhythm.interOnsetShares,
+    syncopation: plan.rhythm.syncopation
+  };
+}
+function peakPositionWarnings(plan, readings) {
+  const violations = [];
+  plan.phrases.forEach((phrase, index) => {
+    const reading = readings[index];
+    if (reading == null) {
+      return;
+    }
+    const drift = Math.abs(reading.peakPosition - phrase.peakPosition);
+    if (drift > PEAK_POSITION_TOLERANCE) {
+      violations.push({
+        kind: "peakPosition",
+        severity: "warning",
+        atBeat: phrase.startBeat,
+        expected: `a peak position within ${PEAK_POSITION_TOLERANCE} of ${phrase.peakPosition}`,
+        actual: `${reading.peakPosition}`,
+        rationale: `the phrase starting at beat ${phrase.startBeat} places its melodic peak further from the planned position than the tolerance allows`
+      });
+    }
+  });
+  return violations;
+}
+function lineMeanOf(melody) {
+  let weighted = 0;
+  let total = 0;
+  for (const note2 of melody) {
+    weighted += note2.pitch * note2.durationBeat;
+    total += note2.durationBeat;
+  }
+  return total > 0 ? weighted / total : null;
+}
+function planDensity(plan) {
+  let weighted = 0;
+  let bars = 0;
+  for (const phrase of plan.phrases) {
+    const span = _chunkIFZDWIKMcjs.barSpanOf.call(void 0, phrase.startBeat, phrase.endBeat, plan.meters);
+    weighted += phrase.onsetDensity * span;
+    bars += span;
+  }
+  return { onsets: 1, onsetDensity: bars > 0 ? weighted / bars : 0 };
+}
+function evaluateComposition(melody, plan, opts) {
+  assertCompositionPlan(plan, "evaluated plan");
+  const { budget } = _chunkS5BKZZGMcjs.assertOptions.call(void 0, opts, "evaluate options");
+  const notes = [
+    ..._chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, melody, "evaluated melody", { budget, allowNonPositiveDuration: true })
+  ].sort((a, b) => a.startBeat - b.startBeat);
+  const timeline = planChordTimeline(plan);
+  const lines = phraseLines(notes, plan);
+  const closing = new Set(
+    lines.flatMap((line) => line.length === 0 ? [] : [notes[line.at(-1)]])
+  );
+  const derivations = motifDerivationViolations(notes, plan, closing);
+  const lineMean = lineMeanOf(notes);
+  const readings = plan.phrases.map(
+    (phrase) => _chunkIFZDWIKMcjs.phraseMelody.call(void 0, notes, phrase.startBeat, phrase.endBeat, _nullishCoalesce(lineMean, () => ( 0)), plan.meters, budget)
+  );
+  const violations = [
+    ...spanViolation(notes, plan),
+    ...phraseBoundaryViolations(notes, plan),
+    ...cadenceViolations(notes, plan, timeline, lines),
+    ...harmonyViolations(notes, plan, timeline, lines),
+    ...registerViolations(notes, plan),
+    ...derivations.errors,
+    ...derivations.warnings,
+    ...peakPositionWarnings(plan, readings)
+  ];
+  const rhythm = _chunkIFZDWIKMcjs.analyzeRhythm.call(void 0, notes, {
+    meters: plan.meters,
+    totalBeats: plan.span.endBeat,
+    budget
+  });
+  const target = planRhythmReading(plan);
+  const fit = {
+    contour: _chunkIFZDWIKMcjs.contourSimilarity.call(void 0, plan.phrases.map(planContourPhrase), readings),
+    register: _chunkIFZDWIKMcjs.registerSimilarity.call(void 0, planRegisterPlan(plan), { phrases: readings, mean: lineMean }),
+    onset: _chunkIFZDWIKMcjs.onsetSimilarity.call(void 0, target, rhythm),
+    duration: _chunkIFZDWIKMcjs.durationSimilarity.call(void 0, target, rhythm),
+    syncopation: _chunkIFZDWIKMcjs.syncopationSimilarity.call(void 0, target, rhythm),
+    density: _chunkIFZDWIKMcjs.densitySimilarity.call(void 0, planDensity(plan), rhythm)
+  };
+  return { violations, fit };
+}
+
 // src/generate/progression/index.ts
 var DEFAULT_TS6 = { numerator: 4, denominator: 4 };
 var PROG_STYLES = Object.freeze(["minimal", "dance", "idol", "rock"]);
@@ -5147,12 +7111,12 @@ function progressions() {
   return PRESETS.map((p) => ({ ...p, degrees: [...p.degrees], styles: [...p.styles] }));
 }
 function progressionsByStyle(style) {
-  const named = _chunkXKSO2V5Icjs.assertOneOf.call(void 0, style, PROG_STYLES, "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 = _chunkYPB3A3EYcjs.scaleTonesInDegreeOrder.call(void 0, _chunkYPB3A3EYcjs.heptatonicFrameOf.call(void 0, key));
+    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));
@@ -5160,10 +7124,10 @@ function degreeToRootPc(degree, key) {
 }
 function autoQuality(degree, key, harmonicDominant) {
   if (degree >= 1 && degree <= 7) {
-    if (harmonicDominant && _chunkQ6R3QAZDcjs.isMinorKey.call(void 0, key) && degree === 5) {
+    if (harmonicDominant && _chunkIFZDWIKMcjs.isMinorKey.call(void 0, key) && degree === 5) {
       return "maj";
     }
-    return _chunkYPB3A3EYcjs.diatonicTriad.call(void 0, degree, _chunkYPB3A3EYcjs.heptatonicFrameOf.call(void 0, key)).quality;
+    return _chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, _chunk3R3QVKY5cjs.heptatonicFrameOf.call(void 0, key)).quality;
   }
   if (degree === 14) {
     return "dim";
@@ -5192,39 +7156,39 @@ function pickProgressionPreset(style, ctx = 0) {
 function presetFor(style, ctx) {
   const pool = PRESETS.filter((preset) => preset.styles.includes(style));
   if (pool.length === 0) {
-    throw new (0, _chunkXKSO2V5Icjs.InvalidInputError)(`Unknown progression style: ${style}`);
+    throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Unknown progression style: ${style}`);
   }
   const index = ctx.part("progression").range(0, pool.length - 1, "preset");
   return _nullishCoalesce(pool[index], () => ( PRESETS[0]));
 }
 function tonicizableRootPcs(key) {
-  return new Set(_chunkYPB3A3EYcjs.tonicizableDegrees.call(void 0, key).map((degree) => degree.rootPc));
+  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 _chunkYPB3A3EYcjs.fifthPcOf.call(void 0, _chunkYPB3A3EYcjs.makeChord.call(void 0, span.rootPc, span.quality)) === (span.rootPc + 7) % 12;
+  return _chunk3R3QVKY5cjs.fifthPcOf.call(void 0, _chunk3R3QVKY5cjs.makeChord.call(void 0, span.rootPc, span.quality)) === (span.rootPc + 7) % 12;
 }
 function generateProgression(opts) {
-  _chunkXKSO2V5Icjs.assertRecord.call(void 0, opts, "progression options");
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, opts.bars, "progression bars");
-  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, opts.bars, "progression chords");
-  const key = _chunkYPB3A3EYcjs.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);
   let preset;
   if (opts.preset !== void 0) {
     if (opts.preset.degrees.length === 0) {
-      throw new (0, _chunkXKSO2V5Icjs.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) => {
-        _chunkXKSO2V5Icjs.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, _chunkXKSO2V5Icjs.InvalidInputError)(
+          throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(
             `progression preset degrees[${index}] is not a supported progression degree; received ${degree}`
           );
         }
@@ -5237,27 +7201,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, _chunkXKSO2V5Icjs.InvalidInputError)(`Unknown progression preset: ${opts.presetId}`);
+      throw new (0, _chunkS5BKZZGMcjs.InvalidInputError)(`Unknown progression preset: ${opts.presetId}`);
     }
   }
   preset ??= presetFor(opts.style, ctx);
-  const ext = opts.ext === void 0 ? "auto" : _chunkXKSO2V5Icjs.assertOneOf.call(void 0, opts.ext, ["auto", ..._chunkYPB3A3EYcjs.chordQualities.call(void 0, )], "progression extension");
+  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', _59 => _59.degrees]), () => ( [0])),
+    _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _112 => _112.degrees]), () => ( [0])),
     key,
     ext,
-    _optionalChain([preset, 'optionalAccess', _60 => _60.functional]) === "cadenceStrong"
+    _optionalChain([preset, 'optionalAccess', _113 => _113.functional]) === "cadenceStrong"
   );
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, _nullishCoalesce(opts.ts, () => ( DEFAULT_TS6)));
+  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', _61 => _61.rootPc]), () => ( 0)),
-      quality: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _62 => _62.quality]), () => ( "maj")),
+      rootPc: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _114 => _114.rootPc]), () => ( 0)),
+      quality: _nullishCoalesce(_optionalChain([step, 'optionalAccess', _115 => _115.quality]), () => ( "maj")),
       startBeat: bar2 * barBeats
     };
-    if (_optionalChain([step, 'optionalAccess', _63 => _63.degree]) !== void 0) {
+    if (_optionalChain([step, 'optionalAccess', _116 => _116.degree]) !== void 0) {
       chord.degree = step.degree;
     }
     chords.push(chord);
@@ -5278,7 +7242,7 @@ 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', _64 => _64[i - 1], 'optionalAccess', _65 => _65.secondaryDominant]) === true;
+      const isResolutionTarget = _optionalChain([chords, 'access', _117 => _117[i - 1], 'optionalAccess', _118 => _118.secondaryDominant]) === true;
       const takesNoDominant = !canBeTonicized(next, tonicizable);
       if (targetsTonic || isLastTonicStatement || alreadySecondary || isResolutionTarget || takesNoDominant) {
         continue;
@@ -5305,7 +7269,7 @@ function commonToneCount(a, b) {
   return a.filter((pc) => set.has(pc)).length;
 }
 function triadQualityOf(chord) {
-  const semis = new Set(chord.intervals.map((interval) => _chunkXKSO2V5Icjs.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;
@@ -5319,15 +7283,15 @@ function triadQualityOf(chord) {
   return hasThird;
 }
 function diatonicTriadsOf(key) {
-  const degrees = _chunkYPB3A3EYcjs.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(_chunkYPB3A3EYcjs.diatonicTriad.call(void 0, degree, key));
+    triads.push(_chunk3R3QVKY5cjs.diatonicTriad.call(void 0, degree, key));
   }
   return triads;
 }
 function sameChord(a, b) {
-  return _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, a.rootPc) === _chunkXKSO2V5Icjs.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 MAX_HINT_ALTER = 2;
@@ -5335,75 +7299,75 @@ function bareSpelling(note2) {
   return { letter: note2.letter, alter: note2.alter };
 }
 function spelledOnRoot(chord, root, tonic, key) {
-  const usable = _chunkXKSO2V5Icjs.noteToPitchClass.call(void 0, root) === _chunkXKSO2V5Icjs.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 : _chunkYPB3A3EYcjs.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(_chunkYPB3A3EYcjs.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, _chunkYPB3A3EYcjs.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 = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, dominant.rootPc + 6);
-  if (_chunkYPB3A3EYcjs.isScaleTone.call(void 0, substituteRootPc, key)) {
-    return _chunkYPB3A3EYcjs.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 = _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, dominant.rootPc + 5), tonic, key);
-  return _chunkXKSO2V5Icjs.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) {
-  _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  const source = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const { scale, tonic } = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
-  const originalTriad = _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, _chunkYPB3A3EYcjs.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 = [];
-  if (_chunkYPB3A3EYcjs.soundsDominantSeventh.call(void 0, source)) {
-    const substitute = _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.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 = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, triad.rootPc - source.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunkYPB3A3EYcjs.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 = _chunkQ6R3QAZDcjs.functionOf.call(void 0, source, scale);
-  const parallel = _chunkQ6R3QAZDcjs.parallelKey.call(void 0, scale);
+  const targetFunction = _chunkIFZDWIKMcjs.functionOf.call(void 0, source, scale);
+  const parallel = _chunkIFZDWIKMcjs.parallelKey.call(void 0, scale);
   for (const triad of diatonicTriadsOf(parallel)) {
-    if (_chunkQ6R3QAZDcjs.functionOf.call(void 0, triad, scale) === targetFunction && !_chunkQ6R3QAZDcjs.isDiatonic.call(void 0, triad, scale)) {
+    if (_chunkIFZDWIKMcjs.functionOf.call(void 0, triad, scale) === targetFunction && !_chunkIFZDWIKMcjs.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 = _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, source.rootPc + offset), quality);
-      if (commonToneCount(originalTriad, _chunkYPB3A3EYcjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkQ6R3QAZDcjs.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 && !_chunkIFZDWIKMcjs.isDiatonic.call(void 0, mediant, scale)) {
         candidates.push({ chord: spelledInKey(mediant, tonic, scale), type: "chromaticMediant" });
       }
     }
   }
-  const melodyPcs = _optionalChain([opts, 'optionalAccess', _66 => _66.melodyPcs, 'optionalAccess', _67 => _67.map, 'call', _68 => _68(_chunkXKSO2V5Icjs.pitchClassOf)]);
+  const melodyPcs = _optionalChain([opts, 'optionalAccess', _119 => _119.melodyPcs, 'optionalAccess', _120 => _120.map, 'call', _121 => _121(_chunkS5BKZZGMcjs.pitchClassOf)]);
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const candidate of candidates) {
     if (sameChord(candidate.chord, source)) {
       continue;
     }
-    const dedupeKey = `${_chunkXKSO2V5Icjs.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(_chunkYPB3A3EYcjs.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;
       }
@@ -5411,65 +7375,65 @@ function substituteChord(chord, key, opts) {
     results.push({
       chord: candidate.chord,
       type: candidate.type,
-      roman: _chunkQ6R3QAZDcjs.chordToRoman.call(void 0, candidate.chord, scale),
-      function: _chunkQ6R3QAZDcjs.functionOf.call(void 0, candidate.chord, scale)
+      roman: _chunkIFZDWIKMcjs.chordToRoman.call(void 0, candidate.chord, scale),
+      function: _chunkIFZDWIKMcjs.functionOf.call(void 0, candidate.chord, scale)
     });
   }
   return results;
 }
 function modalInterchangePalette(key) {
-  const { scale, tonic } = _chunkYPB3A3EYcjs.resolveKey.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 = `${_chunkXKSO2V5Icjs.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: _chunkQ6R3QAZDcjs.chordToRoman.call(void 0, chord, scale),
-      source: _chunkQ6R3QAZDcjs.borrowedSource.call(void 0, chord, scale)
+      roman: _chunkIFZDWIKMcjs.chordToRoman.call(void 0, chord, scale),
+      source: _chunkIFZDWIKMcjs.borrowedSource.call(void 0, chord, scale)
     });
   };
-  const parallel = _chunkQ6R3QAZDcjs.parallelKey.call(void 0, scale);
+  const parallel = _chunkIFZDWIKMcjs.parallelKey.call(void 0, scale);
   for (const triad of diatonicTriadsOf(parallel)) {
-    if (!_chunkQ6R3QAZDcjs.isDiatonic.call(void 0, triad, scale) && _chunkQ6R3QAZDcjs.borrowedSource.call(void 0, triad, scale) !== null) {
+    if (!_chunkIFZDWIKMcjs.isDiatonic.call(void 0, triad, scale) && _chunkIFZDWIKMcjs.borrowedSource.call(void 0, triad, scale) !== null) {
       add(spelledInKey(triad, tonic, parallel));
     }
   }
-  const neapolitan = _chunkYPB3A3EYcjs.makeChord.call(void 0, _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, scale.rootPc + 1), "maj");
-  if (!_chunkQ6R3QAZDcjs.isDiatonic.call(void 0, neapolitan, scale)) {
-    add(spelledOnRoot(neapolitan, _chunkXKSO2V5Icjs.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 (!_chunkIFZDWIKMcjs.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 = _chunkYPB3A3EYcjs.toChordData.call(void 0, chord);
-  const { scale, tonic } = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
-  const tonicPc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, scale.rootPc);
-  const mirror = (p) => _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, 2 * tonicPc + 7 - p);
-  const pcs = _chunkYPB3A3EYcjs.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, ...pcs.map((pc) => pc + 12)] : pcs;
-  const detected = _chunkQ6R3QAZDcjs.detectChordBest.call(void 0, pitches);
+  const detected = _chunkIFZDWIKMcjs.detectChordBest.call(void 0, pitches);
   if (detected) {
     if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return spelledInKey(_chunkYPB3A3EYcjs.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(_chunkYPB3A3EYcjs.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) {
-  _chunkXKSO2V5Icjs.assertMidiPitch.call(void 0, pitch, "pitch");
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, velocity, "velocity", 0, 127);
-  return _chunkXKSO2V5Icjs.assertArray.call(void 0, events, "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,
@@ -5480,7 +7444,7 @@ var DEFAULT_SUBDIVISION = 2;
 var DEFAULT_DENSITY = 0.5;
 var DEFAULT_BARS = 1;
 function onsetWeightCurve(weight) {
-  _chunkXKSO2V5Icjs.assertInteger.call(void 0, weight, "weight", 0, 3);
+  _chunkS5BKZZGMcjs.assertInteger.call(void 0, weight, "weight", 0, 3);
   switch (weight) {
     case 3:
       return 1;
@@ -5493,20 +7457,20 @@ function onsetWeightCurve(weight) {
   }
 }
 function generateRhythm(ts, opts = {}) {
-  const asked = _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
-  const meter = _chunkXKSO2V5Icjs.meterAt.call(void 0, 0, _chunkXKSO2V5Icjs.toMeterData.call(void 0, ts, "ts"));
+  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));
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, bars, "rhythm bars");
-  _chunkXKSO2V5Icjs.assertPositiveInt.call(void 0, subdivision, "rhythm subdivision");
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, meter);
+  _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;
-  _chunkXKSO2V5Icjs.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) {
@@ -5521,7 +7485,7 @@ function generateRhythm(ts, opts = {}) {
         positions.push(position);
         continue;
       }
-      const weight = _chunkXKSO2V5Icjs.metricWeight.call(void 0, position, meter);
+      const weight = _chunkS5BKZZGMcjs.metricWeight.call(void 0, position, meter);
       const probability = onsetWeightCurve(weight) * density;
       if (draw.prob(probability, "onset", bar2, slot)) {
         positions.push(position);
@@ -5537,13 +7501,13 @@ function generateRhythm(ts, opts = {}) {
   return events;
 }
 function rhythmDensity(events, ts) {
-  _chunkXKSO2V5Icjs.assertArray.call(void 0, events, "events");
-  const barBeats = _chunkXKSO2V5Icjs.beatsPerBar.call(void 0, 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', _69 => _69.position]), () => ( 0))) + (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _70 => _70.duration]), () => ( 0)));
+  const spanBeats = (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _122 => _122.position]), () => ( 0))) + (_nullishCoalesce(_optionalChain([last, 'optionalAccess', _123 => _123.duration]), () => ( 0)));
   const bars = spanBeats / barBeats;
   return bars > 0 ? events.length / bars : 0;
 }
@@ -5617,5 +7581,11 @@ 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.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-5KW7DNCJ.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.COMPOSITION_PLAN_VERSION = COMPOSITION_PLAN_VERSION; exports.assertCompositionPlan = assertCompositionPlan; exports.planTimeline = planTimeline; exports.generateMelody = generateMelody; exports.ORNAMENT_STYLES = ORNAMENT_STYLES; exports.ornament = ornament; exports.deriveCompositionPlan = deriveCompositionPlan; exports.evaluateComposition = evaluateComposition; 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-B2PW6EHN.cjs.map