@libraz/libcantus 1.0.0 → 1.1.0

package/dist/{chunk-MXO72PLY.cjs → chunk-QCXYKSZS.cjs}

@@ -4,8 +4,8 @@
 
 
 
+var _chunkYPB3A3EYcjs = require('./chunk-YPB3A3EY.cjs');
 
-var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
@@ -13,7 +13,7 @@ var _chunkUADYAYATcjs = require('./chunk-UADYAYAT.cjs');
 
 
 
-var _chunkQ2WGKJNNcjs = require('./chunk-Q2WGKJNN.cjs');
+var _chunkXKSO2V5Icjs = require('./chunk-XKSO2V5I.cjs');
 
 // src/analyze/spelling/index.ts
 var CHORD_MISMATCH = 64;
@@ -53,17 +53,17 @@ var CONVENTIONAL_LETTER_STEPS = [
   // major seventh
 ];
 function alterationFor(letter, pc) {
-  const distance = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pc - _chunkQ2WGKJNNcjs.naturalPitchClassOf.call(void 0, letter));
+  const distance = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pc - _chunkXKSO2V5Icjs.naturalPitchClassOf.call(void 0, letter));
   return distance > 6 ? distance - 12 : distance;
 }
 function octaveFor(pitch, letter, alter) {
-  return (pitch - _chunkQ2WGKJNNcjs.naturalPitchClassOf.call(void 0, letter) - alter) / 12 - 1;
+  return (pitch - _chunkXKSO2V5Icjs.naturalPitchClassOf.call(void 0, letter) - alter) / 12 - 1;
 }
 function sameSpelling(a, b) {
   return a.letter === b.letter && a.alter === b.alter;
 }
 function candidatesFor(pitch, preferred) {
-  const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch);
+  const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch);
   const rest = [];
   for (let letter = 0; letter < 7; letter += 1) {
     const alter = alterationFor(letter, pc);
@@ -83,23 +83,23 @@ function candidatesFor(pitch, preferred) {
   ];
 }
 function chordSpellingOf(pc, chord, tonic, key) {
-  for (const tone of _chunkUADYAYATcjs.spellChord.call(void 0, chord, tonic, key)) {
-    if (_chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _chunkQ2WGKJNNcjs.naturalPitchClassOf.call(void 0, tone.letter) + tone.alter) === pc) {
+  for (const tone of _chunkYPB3A3EYcjs.spellChord.call(void 0, chord, tonic, key)) {
+    if (_chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _chunkXKSO2V5Icjs.naturalPitchClassOf.call(void 0, tone.letter) + tone.alter) === pc) {
       return tone;
     }
   }
   const bass = chord.bassPc;
-  if (bass === void 0 || _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, bass) !== pc) {
+  if (bass === void 0 || _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, bass) !== pc) {
     return void 0;
   }
   const hint = chord.bassSpelling;
-  return hint !== void 0 && _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, _chunkQ2WGKJNNcjs.naturalPitchClassOf.call(void 0, hint.letter) + hint.alter) === pc ? { letter: _chunkQ2WGKJNNcjs.diatonicLetterOf.call(void 0, hint.letter), alter: hint.alter } : _chunkUADYAYATcjs.spellPitchClass.call(void 0, pc, tonic, key);
+  return hint !== void 0 && _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, _chunkXKSO2V5Icjs.naturalPitchClassOf.call(void 0, hint.letter) + hint.alter) === pc ? { letter: _chunkXKSO2V5Icjs.diatonicLetterOf.call(void 0, hint.letter), alter: hint.alter } : _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, pc, tonic, key);
 }
 function stateFor(pitch, chord, tonic, key) {
-  const pc = _chunkQ2WGKJNNcjs.pitchClassOf.call(void 0, pitch);
+  const pc = _chunkXKSO2V5Icjs.pitchClassOf.call(void 0, pitch);
   const fromChord = chord === null ? void 0 : chordSpellingOf(pc, chord, tonic, key);
-  const scaleTone = _chunkUADYAYATcjs.isScaleTone.call(void 0, pc, key);
-  const reference = _nullishCoalesce(fromChord, () => ( _chunkUADYAYATcjs.spellPitchClass.call(void 0, pc, tonic, key)));
+  const scaleTone = _chunkYPB3A3EYcjs.isScaleTone.call(void 0, pc, key);
+  const reference = _nullishCoalesce(fromChord, () => ( _chunkYPB3A3EYcjs.spellPitchClass.call(void 0, pc, tonic, key)));
   const mismatch = fromChord !== void 0 ? CHORD_MISMATCH : scaleTone ? SCALE_TONE_MISMATCH : KEY_MISMATCH;
   const candidates = candidatesFor(pitch, reference);
   return {
@@ -141,24 +141,26 @@ function transitionCost(from, source, to, target) {
   return letterStepCost(source, target, semitones) + directionCost(target, to.chromatic, semitones) + directionCost(source, from.chromatic, semitones);
 }
 function spellLine(notes, timeline, key, opts = {}) {
-  const scale = _chunkUADYAYATcjs.toKeyScale.call(void 0, key);
-  const given = opts.tonic === void 0 ? void 0 : _chunkQ2WGKJNNcjs.toNoteData.call(void 0, opts.tonic);
-  _chunkQ2WGKJNNcjs.assertNoteEvents.call(void 0, notes, "line notes", {
+  _chunkXKSO2V5Icjs.assertOptions.call(void 0, opts, "opts");
+  const resolved = _chunkYPB3A3EYcjs.resolveKey.call(void 0, key);
+  const scale = resolved.scale;
+  const given = opts.tonic === void 0 ? void 0 : _chunkXKSO2V5Icjs.toNoteData.call(void 0, opts.tonic);
+  _chunkXKSO2V5Icjs.assertNoteEvents.call(void 0, notes, "line notes", {
     allowNonPositiveDuration: true,
     budget: opts.budget
   });
-  _chunkQ2WGKJNNcjs.assertGenerationBudget.call(void 0, 
+  _chunkXKSO2V5Icjs.assertGenerationBudget.call(void 0, 
     notes.length * SPELLINGS_PER_PITCH * SPELLINGS_PER_PITCH,
     "line spelling states",
     opts.budget
   );
   if (given !== void 0) {
-    _chunkUADYAYATcjs.assertTonicOf.call(void 0, given, scale, "spellLine");
+    _chunkYPB3A3EYcjs.assertTonicOf.call(void 0, given, scale, "spellLine");
   }
   if (notes.length === 0) {
     return [];
   }
-  const tonic = _nullishCoalesce(given, () => ( _chunkUADYAYATcjs.spelledKeyOf.call(void 0, scale).tonic));
+  const tonic = _nullishCoalesce(given, () => ( resolved.tonic));
   const states = notes.map(
     (note) => stateFor(note.pitch, _nullishCoalesce(_optionalChain([timeline, 'optionalAccess', _ => _.at, 'call', _2 => _2(note.startBeat)]), () => ( null)), tonic, scale)
   );
@@ -208,4 +210,4 @@ function spellLine(notes, timeline, key, opts = {}) {
 
 
 exports.spellLine = spellLine;
-//# sourceMappingURL=chunk-MXO72PLY.cjs.map
+//# sourceMappingURL=chunk-QCXYKSZS.cjs.map

package/dist/chunk-QCXYKSZS.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-QCXYKSZS.cjs","../src/analyze/spelling/index.ts"],"names":[],"mappings":"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","file":"/home/runner/work/libcantus/libcantus/dist/chunk-QCXYKSZS.cjs","sourcesContent":[null,"/**\n * Line spelling: name every note of a melodic line in one pass.\n *\n * {@link spellPitch} decides one note from the key, the root of the chord under\n * it and its two immediate neighbours. That is enough for a single note, but a\n * line spelled note by note can zig-zag between the two readings of one idea —\n * a rising whole-tone figure comes out F# Ab Bb, with a diminished third in the\n * middle of it.\n *\n * This module solves the whole line at once. The theory layer's own judgment\n * becomes the cost of emitting a spelling, the melodic rules become the cost of\n * moving from one spelling to the next, and a dynamic program takes the\n * cheapest path across the line. Nothing here re-decides what\n * {@link spellPitchClass} and {@link spellChord} already decide: it only weighs\n * their answers against the shape of the line they sit in.\n */\n\nimport type { Note, NoteLike } from '../../core/pitch/index.js';\nimport {\n  diatonicLetterOf as mod7,\n  pitchClassOf as mod12,\n  naturalPitchClassOf as naturalPc,\n  toNoteData,\n} from '../../core/pitch/index.js';\nimport type { KeyScale, NoteEvent } from '../../core/types.js';\nimport {\n  assertGenerationBudget,\n  assertNoteEvents,\n  assertOptions,\n} from '../../core/validation/index.js';\nimport type { Chord } from '../../theory/chord/index.js';\nimport { isScaleTone, resolveKey, type SpelledKeyLike } from '../../theory/scale/index.js';\nimport { assertTonicOf, spellChord, spellPitchClass } from '../../theory/spelling/index.js';\nimport type { ChordTimeline } from '../timeline/index.js';\n\n/**\n * The four rules, and what happens where they pull against each other.\n *\n * The costs below are spread far enough apart that a rule can never be\n * outvoted by any number of the rules under it, which fixes the precedence:\n *\n * 1. **The sounding chord.** A note the chord names takes the chord's own\n *    spelling of that tone. This is the one place the line departs from\n *    {@link spellPitchClass}, which never respells a tone of the key: over a\n *    Db7 the seventh has to read Cb even in C major, where B is a scale tone,\n *    because a dominant seventh spelled as a sixth is not the chord that was\n *    played.\n * 2. **The key's scale.** Anything else the key itself spells — a scale tone,\n *    and the tonic — keeps that spelling, exactly as the note-by-note path\n *    keeps it. No amount of melodic pressure moves it.\n * 3. **The shape of the line, then its direction.** A chromatic note is spelled\n *    so the letters of the intervals around it match the intervals actually\n *    sounding, and a stepwise line then prefers sharps rising and flats\n *    falling. Shape outranks direction because a rising line spelled with\n *    sharps is still wrong if it spells a whole tone as a diminished third.\n * 4. **The key's chromatic convention, then the fewest accidentals.** What the\n *    key alone would have said, as the tiebreak it is: the direction rule beats\n *    it, which is why a chromatic ascent in C major spells C# D# G# A# rather\n *    than the flats the key prefers, but one-sided evidence — a chromatic note\n *    with only one stepwise neighbour — does not.\n */\n\n/** Emission cost for a spelling the chord sounding under the note does not name. */\nconst CHORD_MISMATCH = 64;\n\n/** Emission cost for respelling a tone the key's own scale already names. */\nconst SCALE_TONE_MISMATCH = 32;\n\n/** Transition cost per diatonic step an interval's letters miss its written size by. */\nconst LETTER_STEP_DEVIATION = 4;\n\n/**\n * How many steps of deviation are counted before the cost stops growing.\n *\n * Two letters out is already an interval no reading supports, and capping there\n * keeps the whole melodic term below {@link SCALE_TONE_MISMATCH}, so a badly\n * shaped line can never argue a scale tone out of its key spelling.\n */\nconst MAX_COUNTED_DEVIATION = 2;\n\n/** Transition cost for an accidental leaning against the direction of a stepwise line. */\nconst AGAINST_DIRECTION = 3;\n\n/** Emission cost for a chromatic spelling the key alone would not choose. */\nconst KEY_MISMATCH = 4;\n\n/** Emission cost per semitone of alteration: what minimises accidentals overall. */\nconst ACCIDENTAL = 1;\n\n/** Widest melodic interval still counted as a step, where the direction rule applies. */\nconst MAX_STEP = 2;\n\n/** Widest alteration a spelling may carry: a double accidental. */\nconst MAX_ALTER = 2;\n\n/**\n * Spellings each pitch class has within a double accidental.\n *\n * Always exactly three — a natural or its accidental, one letter above, one\n * letter below (C is C, B# and Dbb) — which is what bounds the work the dynamic\n * program is allowed to do.\n */\nconst SPELLINGS_PER_PITCH = 3;\n\n/**\n * The diatonic letter distances a melodic interval of a given size is\n * conventionally written with, indexed by its semitone class.\n *\n * Most sizes read only one way: a whole tone is a second, a minor third is a\n * third, so spelling one as anything else costs. Two sizes read two ways and\n * both are free — a semitone is either a chromatic inflection of one letter\n * (F to F#) or a diatonic step (E to F), and the tritone is either an augmented\n * fourth or a diminished fifth. Direction chooses between those.\n */\nconst CONVENTIONAL_LETTER_STEPS: readonly (readonly number[])[] = [\n  [0], // unison\n  [0, 1], // chromatic semitone or diatonic semitone\n  [1], // second\n  [2], // minor third\n  [2], // major third\n  [3], // fourth\n  [3, 4], // augmented fourth or diminished fifth\n  [4], // fifth\n  [5], // minor sixth\n  [5], // major sixth\n  [6], // minor seventh\n  [6], // major seventh\n];\n\n/**\n * Options for {@link spellLine}.\n *\n * @category Arrangement & Analysis\n */\nexport type SpellLineOptions = {\n  /**\n   * Tonic spelling to anchor the key, for a caller that already knows how the\n   * piece is written. It must sound the key's own root pitch class; anything\n   * else is rejected rather than spelled. Defaults to the conventional\n   * spelling the key itself is written with. Accepted as a note name, a MIDI\n   * number, note data, or a `Note`.\n   */\n  tonic?: NoteLike;\n  /** Upper bound on the work the line may cost; defaults to the generation budget. */\n  budget?: number;\n};\n\n/** Shortest signed alteration (in [-6, 6]) taking a letter's natural pc to `pc`. */\nfunction alterationFor(letter: number, pc: number): number {\n  const distance = mod12(pc - naturalPc(letter));\n  return distance > 6 ? distance - 12 : distance;\n}\n\n/** The octave that reproduces `pitch` from a letter and its alteration. */\nfunction octaveFor(pitch: number, letter: number, alter: number): number {\n  return (pitch - naturalPc(letter) - alter) / 12 - 1;\n}\n\n/** Whether two spellings name the same letter with the same alteration. */\nfunction sameSpelling(a: Note, b: Note): boolean {\n  return a.letter === b.letter && a.alter === b.alter;\n}\n\n/**\n * Every spelling of `pitch` within a double accidental, `preferred` first.\n *\n * The order is what settles a tie: two readings that cost the same are equally\n * defensible, and the one the theory layer would have chosen alone is then the\n * one that stands.\n */\nfunction candidatesFor(pitch: number, preferred: Note): Note[] {\n  const pc = mod12(pitch);\n  const rest: Note[] = [];\n  for (let letter = 0; letter < 7; letter += 1) {\n    const alter = alterationFor(letter, pc);\n    if (Math.abs(alter) > MAX_ALTER || letter === preferred.letter) {\n      continue;\n    }\n    rest.push({ letter, alter, octave: octaveFor(pitch, letter, alter) });\n  }\n  rest.sort((a, b) => Math.abs(a.alter) - Math.abs(b.alter) || a.letter - b.letter);\n  return [\n    {\n      letter: preferred.letter,\n      alter: preferred.alter,\n      octave: octaveFor(pitch, preferred.letter, preferred.alter),\n    },\n    ...rest,\n  ];\n}\n\n/**\n * The chord's own spelling of a pitch class, or undefined when the chord does\n * not sound it.\n *\n * The tones come from {@link spellChord}, so a chord carrying its own spellings\n * — a parsed symbol, an augmented sixth — is read by them; a slash bass outside\n * the chord's tones is spelled from its hint when it has one.\n */\nfunction chordSpellingOf(pc: number, chord: Chord, tonic: Note, key: KeyScale): Note | undefined {\n  for (const tone of spellChord(chord, tonic, key)) {\n    if (mod12(naturalPc(tone.letter) + tone.alter) === pc) {\n      return tone;\n    }\n  }\n  const bass = chord.bassPc;\n  if (bass === undefined || mod12(bass) !== pc) {\n    return undefined;\n  }\n  const hint = chord.bassSpelling;\n  return hint !== undefined && mod12(naturalPc(hint.letter) + hint.alter) === pc\n    ? { letter: mod7(hint.letter), alter: hint.alter }\n    : spellPitchClass(pc, tonic, key);\n}\n\n/** One note of the line, with the spellings open to it and what each costs. */\ntype LineState = {\n  pitch: number;\n  /** True when the key does not already spell this pitch, so direction may decide. */\n  chromatic: boolean;\n  candidates: Note[];\n  emissions: number[];\n  /** The spelling the note-by-note path would have chosen, used as the fallback. */\n  reference: Note;\n};\n\n/**\n * Weigh every spelling open to one note against what the chord and the key say\n * about it.\n *\n * The reference spelling is the theory layer's own answer — the chord's, when\n * the chord names the note, and the key's otherwise — and the cost of departing\n * from it is what ranks the three rules that do not depend on the neighbours.\n */\nfunction stateFor(pitch: number, chord: Chord | null, tonic: Note, key: KeyScale): LineState {\n  const pc = mod12(pitch);\n  const fromChord = chord === null ? undefined : chordSpellingOf(pc, chord, tonic, key);\n  const scaleTone = isScaleTone(pc, key);\n  const reference = fromChord ?? spellPitchClass(pc, tonic, key);\n  const mismatch =\n    fromChord !== undefined ? CHORD_MISMATCH : scaleTone ? SCALE_TONE_MISMATCH : KEY_MISMATCH;\n  const candidates = candidatesFor(pitch, reference);\n  return {\n    pitch,\n    chromatic: !scaleTone,\n    candidates,\n    emissions: candidates.map(\n      (candidate) =>\n        (sameSpelling(candidate, reference) ? 0 : mismatch) +\n        ACCIDENTAL * Math.abs(candidate.alter),\n    ),\n    reference,\n  };\n}\n\n/** A spelling's position on the diatonic ladder, octave included. */\nfunction diatonicIndex(note: Note): number {\n  return note.letter + 7 * (note.octave ?? 0);\n}\n\n/**\n * What the letters of a melodic interval cost when they do not match the\n * interval that actually sounds.\n *\n * Both notes are already spelled, so the sounding interval and the written one\n * are both known: a whole tone written F# to Ab is two letters apart where a\n * second is one, and pays for the difference.\n */\nfunction letterStepCost(from: Note, to: Note, semitones: number): number {\n  const written = diatonicIndex(to) - diatonicIndex(from);\n  const size = Math.abs(semitones);\n  const octaves = Math.floor(size / 12);\n  const direction = semitones < 0 ? -1 : 1;\n  let deviation = Number.POSITIVE_INFINITY;\n  for (const steps of CONVENTIONAL_LETTER_STEPS[size % 12] ?? []) {\n    deviation = Math.min(deviation, Math.abs(written - direction * (octaves * 7 + steps)));\n  }\n  if (!Number.isFinite(deviation)) {\n    return 0;\n  }\n  return LETTER_STEP_DEVIATION * Math.min(deviation, MAX_COUNTED_DEVIATION);\n}\n\n/**\n * What an accidental costs for leaning the wrong way in a stepwise line: a\n * rising line is written with sharps and a falling one with flats.\n *\n * Only steps are judged. The rule describes chromatic motion, and a leap onto a\n * flat says nothing about the flat — the key and the chord have the whole story\n * there.\n */\nfunction directionCost(note: Note, chromatic: boolean, semitones: number): number {\n  if (!chromatic || semitones === 0 || Math.abs(semitones) > MAX_STEP) {\n    return 0;\n  }\n  const rising = semitones > 0;\n  return (rising && note.alter < 0) || (!rising && note.alter > 0) ? AGAINST_DIRECTION : 0;\n}\n\n/**\n * The cost of following one spelling with another.\n *\n * Direction is charged to both notes: a chromatic note is judged by the step it\n * arrives on and by the step it leaves on, so a note inside a run collects the\n * rule twice and a note at the end of one collects it once.\n */\nfunction transitionCost(from: LineState, source: Note, to: LineState, target: Note): number {\n  const semitones = to.pitch - from.pitch;\n  return (\n    letterStepCost(source, target, semitones) +\n    directionCost(target, to.chromatic, semitones) +\n    directionCost(source, from.chromatic, semitones)\n  );\n}\n\n/**\n * Spell a whole melodic line at once, so its notes agree with each other.\n *\n * Every note is spelled together with the rest of the line rather than one at a\n * time: each pitch offers the three spellings a double accidental allows, the\n * chord and the key price them, the intervals between neighbours price the\n * pairs, and the cheapest reading of the whole line wins. Ties fall to the\n * spelling {@link spellPitchClass} would have chosen alone, so the answer never\n * drifts from the theory layer without a reason.\n *\n * Four rules decide, in this order:\n *\n * 1. A note the sounding chord names takes that chord's spelling of it, even\n *    when the key spells the pitch otherwise — the seventh of a Db7 reads Cb in\n *    C major, not B.\n * 2. Anything else the key's scale spells keeps its key spelling, exactly as\n *    the note-by-note path keeps it.\n * 3. A chromatic note is spelled so the written intervals around it match the\n *    sounding ones, and then so a rising step carries a sharp and a falling\n *    step a flat.\n * 4. Failing all of that, the key's own chromatic spelling stands, and the\n *    fewest accidentals win.\n *\n * Without a timeline — pass `null` — rules 2 to 4 still apply in full, so a\n * diatonic line and a chromatic run come out the same. What is lost is rule 1:\n * a chromatic chord can no longer name its own tones, so the tones of a\n * borrowed or altered chord fall back to the key's convention (that Cb becomes\n * B), and an enharmonically ambiguous tone under a chord that would have fixed\n * it is decided by the line's direction instead.\n *\n * @param notes The line, monophonic and in time order. Notes sharing an onset\n *   are read as consecutive, so split polyphonic material into voices first.\n * @param timeline The chords sounding under the line, or null when only the key\n *   is known. Each note is judged against the chord at its own onset.\n * @param key The key the line is written in, as a key name, a key/scale, or a\n *   `Key`.\n * @param opts Optional tonic spelling and work budget.\n * @returns One spelled note per input note, in input order, each carrying the\n *   octave that reproduces its pitch.\n * @throws If `opts.tonic` does not sound the key's root pitch class, if a note\n *   event is malformed, or if the line is longer than the budget allows.\n * @example\n * ```ts\n * import { chordTimelineFromChords, majorKey, noteNames, spellLine } from '@libraz/libcantus';\n * // A chromatic ascent spells with sharps, whatever the key would say alone.\n * const rising = [60, 61, 62, 63, 64].map((pitch, index) => ({\n *   pitch,\n *   startBeat: index,\n *   durationBeat: 1,\n * }));\n * noteNames(spellLine(rising, null, majorKey(0)));\n * // ['C4', 'C#4', 'D4', 'D#4', 'E4']\n * // Under a Db7 the same B sounds as the chord's seventh.\n * const timeline = chordTimelineFromChords([{ rootPc: 1, quality: 'dom7', startBeat: 0 }], 4);\n * noteNames(spellLine([{ pitch: 71, startBeat: 0, durationBeat: 1 }], timeline, majorKey(0)));\n * // ['Cb5']\n * ```\n * @category Arrangement & Analysis\n */\nexport function spellLine(\n  notes: readonly NoteEvent[],\n  timeline: ChordTimeline | null,\n  key: SpelledKeyLike,\n  opts: SpellLineOptions = {},\n): Note[] {\n  assertOptions(opts, 'opts');\n  // Read whole rather than reduced: a line in Ab minor is written on flats, and\n  // a key handed in spelled that way would otherwise have its spelling derived\n  // back from the pitch classes and come out in G# minor.\n  const resolved = resolveKey(key);\n  const scale = resolved.scale;\n  const given = opts.tonic === undefined ? undefined : toNoteData(opts.tonic);\n  assertNoteEvents(notes, 'line notes', {\n    allowNonPositiveDuration: true,\n    budget: opts.budget,\n  });\n  // The dynamic program compares every spelling of a note with every spelling\n  // of the one before it, so the work is bounded before any of it is done.\n  assertGenerationBudget(\n    notes.length * SPELLINGS_PER_PITCH * SPELLINGS_PER_PITCH,\n    'line spelling states',\n    opts.budget,\n  );\n  if (given !== undefined) {\n    assertTonicOf(given, scale, 'spellLine');\n  }\n  if (notes.length === 0) {\n    return [];\n  }\n  const tonic = given ?? resolved.tonic;\n  const states = notes.map((note) =>\n    stateFor(note.pitch, timeline?.at(note.startBeat) ?? null, tonic, scale),\n  );\n\n  // Viterbi across the line: `costs` holds the cheapest path reaching each\n  // spelling of the current note, and `back` remembers which spelling of the\n  // previous note that path came through.\n  let costs: number[] = [];\n  let previous: LineState | undefined;\n  const back: number[][] = [];\n  for (const current of states) {\n    if (previous === undefined) {\n      costs = [...current.emissions];\n      back.push(current.candidates.map(() => 0));\n      previous = current;\n      continue;\n    }\n    const reached: number[] = [];\n    const chosen: number[] = [];\n    for (const [target, candidate] of current.candidates.entries()) {\n      let best = Number.POSITIVE_INFINITY;\n      let bestSource = 0;\n      for (const [source, sourceNote] of previous.candidates.entries()) {\n        const total =\n          (costs[source] ?? Number.POSITIVE_INFINITY) +\n          transitionCost(previous, sourceNote, current, candidate);\n        if (total < best) {\n          best = total;\n          bestSource = source;\n        }\n      }\n      reached.push(best + (current.emissions[target] ?? 0));\n      chosen.push(bestSource);\n    }\n    costs = reached;\n    back.push(chosen);\n    previous = current;\n  }\n\n  let cursor = 0;\n  for (const [index, cost] of costs.entries()) {\n    if (cost < (costs[cursor] ?? Number.POSITIVE_INFINITY)) {\n      cursor = index;\n    }\n  }\n  const picked: number[] = new Array(states.length).fill(0);\n  for (let index = states.length - 1; index >= 0; index -= 1) {\n    picked[index] = cursor;\n    cursor = back[index]?.[cursor] ?? 0;\n  }\n  return states.map((state, index) => state.candidates[picked[index] ?? 0] ?? state.reference);\n}\n"]}