@libraz/libcantus 0.9.3 → 0.9.5

package/dist/analyze/index.cjs

@@ -1,1970 +1,62 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/analyze/index.ts
-var analyze_exports = {};
-__export(analyze_exports, {
-  analyzeArrangement: () => analyzeArrangement,
-  analyzeChord: () => analyzeChord,
-  analyzeVoice: () => analyzeVoice,
-  borrowedSource: () => borrowedSource,
-  chordTimelineFromChords: () => chordTimelineFromChords,
-  chordTimelineFromNotes: () => chordTimelineFromNotes,
-  chordToRoman: () => chordToRoman,
-  detectCadence: () => detectCadence,
-  detectCadences: () => detectCadences,
-  detectChord: () => detectChord,
-  detectChordBest: () => detectChordBest,
-  detectKey: () => detectKey,
-  functionOf: () => functionOf,
-  isBorrowedChord: () => isBorrowedChord,
-  isDiatonic: () => isDiatonic,
-  isMinorKey: () => isMinorKey,
-  parallelKey: () => parallelKey,
-  romanToChord: () => romanToChord,
-  secondaryDominant: () => secondaryDominant,
-  tensionCurve: () => tensionCurve
-});
-module.exports = __toCommonJS(analyze_exports);
 
-// src/core/validation/index.ts
-var DEFAULT_GENERATION_BUDGET = 1e6;
-function assertFiniteNumber(value, name) {
-  if (!Number.isFinite(value)) {
-    throw new RangeError(`${name} must be finite; received ${value}`);
-  }
-  return value;
-}
-function assertInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
-  assertFiniteNumber(value, name);
-  if (!Number.isSafeInteger(value) || value < min || value > max) {
-    throw new RangeError(`${name} must be an integer in [${min}, ${max}]; received ${value}`);
-  }
-  return value;
-}
-function assertPositiveInt(value, name, max = DEFAULT_GENERATION_BUDGET) {
-  return assertInteger(value, name, 1, max);
-}
-function assertRange(value, min, max, name) {
-  assertFiniteNumber(value, name);
-  if (value < min || value > max) {
-    throw new RangeError(`${name} must be in [${min}, ${max}]; received ${value}`);
-  }
-  return value;
-}
-function assertGenerationBudget(estimated, name, limit = DEFAULT_GENERATION_BUDGET) {
-  assertFiniteNumber(estimated, name);
-  assertPositiveInt(limit, `${name} limit`, Number.MAX_SAFE_INTEGER);
-  if (estimated < 0 || estimated > limit) {
-    throw new RangeError(`${name} exceeds the generation budget ${limit}; received ${estimated}`);
-  }
-  return estimated;
-}
-function assertTimeSignature(ts, name = "time signature") {
-  assertPositiveInt(ts.numerator, `${name}.numerator`);
-  assertPositiveInt(ts.denominator, `${name}.denominator`);
-  if (ts.grouping !== void 0) {
-    if (ts.grouping.length === 0) {
-      throw new RangeError(`${name}.grouping must not be empty`);
-    }
-    let sum = 0;
-    for (let index = 0; index < ts.grouping.length; index += 1) {
-      sum += assertPositiveInt(ts.grouping[index] ?? Number.NaN, `${name}.grouping[${index}]`);
-    }
-    const compound = ts.numerator % 3 === 0 && ts.numerator > 3;
-    const pulses = compound ? ts.numerator / 3 : ts.numerator;
-    if (sum !== pulses) {
-      throw new RangeError(`${name}.grouping must sum to ${pulses}; received ${sum}`);
-    }
-  }
-  return ts;
-}
-function assertNoteEvent(event, name = "note event", options = {}) {
-  assertFiniteNumber(event.pitch, `${name}.pitch`);
-  assertRange(event.startBeat, 0, Number.MAX_SAFE_INTEGER, `${name}.startBeat`);
-  assertRange(
-    event.durationBeat,
-    options.allowNonPositiveDuration ? -Number.MAX_SAFE_INTEGER : Number.MIN_VALUE,
-    Number.MAX_SAFE_INTEGER,
-    `${name}.durationBeat`
-  );
-  if (!options.allowNonPositiveDuration && event.durationBeat <= 0) {
-    throw new RangeError(`${name}.durationBeat must be positive; received ${event.durationBeat}`);
-  }
-  if (event.velocity !== void 0) {
-    assertRange(event.velocity, 0, 127, `${name}.velocity`);
-  }
-  return event;
-}
-function assertNoteEvents(events, name = "note events", options = {}) {
-  assertGenerationBudget(events.length, `${name} count`, options.budget);
-  for (let index = 0; index < events.length; index += 1) {
-    const event = events[index];
-    if (event !== void 0) {
-      assertNoteEvent(event, `${name}[${index}]`, options);
-    }
-  }
-  return events;
-}
 
-// src/core/meter/index.ts
-var EPS = 1e-9;
-function isMultiple(value, unit) {
-  if (unit === 0) {
-    return false;
-  }
-  const ratio = value / unit;
-  return Math.abs(ratio - Math.round(ratio)) < EPS;
-}
-function parseTimeSignature(text) {
-  const match = /^\s*(\d+)\s*\/\s*(\d+)\s*$/.exec(text);
-  if (!match) {
-    throw new Error(`Invalid time signature: ${text}`);
-  }
-  const numerator = Number.parseInt(match[1] ?? "", 10);
-  const denominator = Number.parseInt(match[2] ?? "", 10);
-  if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator) || numerator <= 0 || denominator <= 0) {
-    throw new Error(`Invalid time signature: ${text}`);
-  }
-  return { numerator, denominator };
-}
-function formatTimeSignature(ts) {
-  assertTimeSignature(ts);
-  return `${ts.numerator}/${ts.denominator}`;
-}
-function isCompound(ts) {
-  assertTimeSignature(ts);
-  return ts.numerator % 3 === 0 && ts.numerator > 3;
-}
-function unitBeats(ts) {
-  return 4 / ts.denominator;
-}
-function beatsPerBar(ts) {
-  assertTimeSignature(ts);
-  return ts.numerator * unitBeats(ts);
-}
-function pulseBeats(ts) {
-  return isCompound(ts) ? 3 * unitBeats(ts) : unitBeats(ts);
-}
-function pulsesPerBar(ts) {
-  return beatsPerBar(ts) / pulseBeats(ts);
-}
-function isValidGrouping(grouping, pulses) {
-  if (grouping.length === 0) {
-    return false;
-  }
-  let sum = 0;
-  for (const g of grouping) {
-    if (!Number.isInteger(g) || g <= 0) {
-      return false;
-    }
-    sum += g;
-  }
-  return sum === pulses;
-}
-function isGroupHead(grouping, pulseIndex) {
-  let acc = 0;
-  for (const g of grouping) {
-    if (acc === pulseIndex) {
-      return true;
-    }
-    acc += g;
-  }
-  return false;
-}
-function beatToBarPosition(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  const barLen = beatsPerBar(ts);
-  const bar = Math.floor(beatInQuarters / barLen);
-  return { bar, beat: beatInQuarters - bar * barLen };
-}
-function metricWeight(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  assertTimeSignature(ts);
-  const { beat } = beatToBarPosition(beatInQuarters, ts);
-  const pulse = pulseBeats(ts);
-  if (!isMultiple(beat, pulse)) {
-    return 0;
-  }
-  const pulses = pulsesPerBar(ts);
-  const pulseIndex = Math.round(beat / pulse) % pulses;
-  if (pulseIndex === 0) {
-    return 3;
-  }
-  const grouping = ts.grouping;
-  if (grouping !== void 0) {
-    if (!isValidGrouping(grouping, pulses)) {
-      throw new Error(
-        `Invalid grouping [${grouping.join(", ")}] for ${formatTimeSignature(ts)}: entries must be positive integers summing to ${pulses}`
-      );
-    }
-    return isGroupHead(grouping, pulseIndex) ? 2 : 1;
-  }
-  if (pulses % 2 === 0 && pulseIndex === pulses / 2) {
-    return 2;
-  }
-  return 1;
-}
-function isStrongBeat(beatInQuarters, ts) {
-  return metricWeight(beatInQuarters, ts) >= 2;
-}
 
-// src/theory/scale/degrees.ts
-function pitchClass(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function scaleOffset(pitch, key) {
-  return (pitchClass(pitch) - pitchClass(key.rootPc) + 12) % 12;
-}
-function isScaleTone(pitch, key) {
-  return (key.modeMask12 >> scaleOffset(pitch, key) & 1) === 1;
-}
-function scaleTonesInDegreeOrder(key) {
-  const root = pitchClass(key.rootPc);
-  const pcs = [];
-  for (let n = 0; n < 12; n += 1) {
-    if ((key.modeMask12 >> n & 1) === 1) {
-      pcs.push((root + n) % 12);
-    }
-  }
-  return pcs;
-}
 
-// src/theory/scale/masks.ts
-function maskFromOffsets(offsets) {
-  let mask = 1;
-  for (const offset of offsets) {
-    mask |= 1 << (offset % 12 + 12) % 12;
-  }
-  return mask;
-}
-var MAJOR_MASK = 2741;
-var NATURAL_MINOR_MASK = 1453;
-var HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);
-var MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);
-var DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);
-var PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);
-var LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);
-var MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);
-var LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);
-var MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);
-var MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);
-var BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);
-var WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);
-var OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);
-var OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);
 
-// src/theory/scale/key.ts
-function majorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: MAJOR_MASK };
-}
-function minorKey(rootPc) {
-  return { rootPc: (rootPc % 12 + 12) % 12, modeMask12: NATURAL_MINOR_MASK };
-}
 
-// src/theory/chord/index.ts
-var QUALITY_INTERVALS = {
-  maj: [0, 4, 7],
-  min: [0, 3, 7],
-  dim: [0, 3, 6],
-  aug: [0, 4, 8],
-  majb5: [0, 4, 6],
-  maj7: [0, 4, 7, 11],
-  min7: [0, 3, 7, 10],
-  dom7: [0, 4, 7, 10],
-  dim7: [0, 3, 6, 9],
-  m7b5: [0, 3, 6, 10],
-  minMaj7: [0, 3, 7, 11],
-  aug7: [0, 4, 8, 10],
-  augMaj7: [0, 4, 8, 11],
-  "6": [0, 4, 7, 9],
-  min6: [0, 3, 7, 9],
-  "6/9": [0, 4, 7, 9, 14],
-  sus2: [0, 2, 7],
-  sus4: [0, 5, 7],
-  add9: [0, 4, 7, 14],
-  add11: [0, 4, 7, 17],
-  maj9: [0, 4, 7, 11, 14],
-  min9: [0, 3, 7, 10, 14],
-  dom9: [0, 4, 7, 10, 14],
-  "7b9": [0, 4, 7, 10, 13],
-  "7#9": [0, 4, 7, 10, 15],
-  "7#11": [0, 4, 7, 10, 18],
-  "7b13": [0, 4, 7, 10, 20],
-  "11": [0, 7, 10, 14, 17],
-  "13": [0, 4, 7, 10, 14, 21],
-  "5": [0, 7]
-};
-function pitchClass2(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function chordQualities() {
-  return Object.keys(QUALITY_INTERVALS);
-}
-function makeChord(rootPc, quality, bassPc) {
-  const chord = {
-    rootPc: pitchClass2(rootPc),
-    quality,
-    intervals: [...QUALITY_INTERVALS[quality]]
-  };
-  if (bassPc !== void 0) {
-    chord.bassPc = pitchClass2(bassPc);
-  }
-  return chord;
-}
-function chordPitchClasses(chord) {
-  const set = /* @__PURE__ */ new Set();
-  for (const interval of chord.intervals) {
-    set.add(pitchClass2(chord.rootPc + interval));
-  }
-  return [...set].sort((a, b) => a - b);
-}
-function chordToneOffsets(chord) {
-  return new Set(chord.intervals.map((i) => (i % 12 + 12) % 12));
-}
-function chordToneRole(pitch, chord) {
-  const interval = (pitchClass2(pitch) - pitchClass2(chord.rootPc) + 12) % 12;
-  const tones = chordToneOffsets(chord);
-  if (interval === 0) {
-    return "root";
-  }
-  if (interval === 3 || interval === 4) {
-    return tones.has(interval) ? "third" : null;
-  }
-  if (interval === 7) {
-    return tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 6) {
-    return tones.has(6) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 8) {
-    return tones.has(8) && !tones.has(7) ? "fifth" : null;
-  }
-  if (interval === 9) {
-    const hasHigherSeventh = tones.has(10) || tones.has(11);
-    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;
-    if (isDiminishedSeventh) {
-      return "seventh";
-    }
-    if (tones.has(9) && !hasHigherSeventh) {
-      return "sixth";
-    }
-    return null;
-  }
-  if (interval === 10 || interval === 11) {
-    return tones.has(interval) ? "seventh" : null;
-  }
-  return null;
-}
 
-// src/core/interval/index.ts
-function simpleInterval(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isConsonantInterval(semitones, twoVoice = true) {
-  const pc = simpleInterval(semitones);
-  if (pc === 5) {
-    return !twoVoice;
-  }
-  return pc === 0 || pc === 3 || pc === 4 || pc === 7 || pc === 8 || pc === 9;
-}
+var _chunk4VZ5MZAMcjs = require('../chunk-4VZ5MZAM.cjs');
+require('../chunk-2A2QMA74.cjs');
 
-// src/theory/counterpoint/index.ts
-function pitchClass3(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function createsVerticalDissonance(a, b, twoVoice) {
-  return !isConsonantInterval(a - b, twoVoice);
-}
-function isForbiddenMelodicLeap(prev, cur) {
-  const semis = Math.abs(cur - prev);
-  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
-}
-function simpleClass(semitones) {
-  return Math.abs(semitones) % 12;
-}
-function isPerfectClass(cls) {
-  return cls === 0 || cls === 7;
-}
-function similarMotion(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
-}
-function bothVoicesMove(aMove, bMove) {
-  return aMove !== 0 && bMove !== 0;
-}
-function createsParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  return isPerfectClass(nowClass) && nowClass === prevClass;
-}
-function createsHiddenParallelPerfect(aPrev, aCur, bPrev, bCur) {
-  const aMove = aCur - aPrev;
-  const bMove = bCur - bPrev;
-  if (!similarMotion(aMove, bMove)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
-    return false;
-  }
-  const upperMove = aCur >= bCur ? aMove : bMove;
-  if (Math.abs(upperMove) <= 2) {
-    return false;
-  }
-  return true;
-}
-function isLeadingToneResolution(prev, cur, key) {
-  const tonic = pitchClass3(key.rootPc);
-  const leading = (tonic + 11) % 12;
-  if (pitchClass3(prev) !== leading || pitchClass3(cur) !== tonic) {
-    return false;
-  }
-  return cur > prev && cur - prev <= 2;
-}
 
-// src/theory/safety/index.ts
-var SUGGESTION_WINDOW = 12;
-var MAX_SUGGESTIONS = 3;
-var REASON_SEVERITY = [
-  [2 /* Tension */, 1 /* Warning */, 1 /* Warning */],
-  [4 /* AvoidNote */, 1 /* Warning */, 2 /* Dissonant */],
-  [8 /* ScaleTone */, 1 /* Warning */, 1 /* Warning */],
-  [16 /* NonScale */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32 /* OutOfRange */, 1 /* Warning */, 1 /* Warning */],
-  [64 /* Tritone */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [128 /* LargeLeap */, 1 /* Warning */, 2 /* Dissonant */],
-  [1024 /* VerticalDissonance */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [2048 /* ParallelPerfect */, 1 /* Warning */, 2 /* Dissonant */],
-  [4096 /* HiddenParallel */, 1 /* Warning */, 2 /* Dissonant */],
-  [8192 /* VoiceCrossing */, 1 /* Warning */, 2 /* Dissonant */],
-  [16384 /* Suspension */, 2 /* Dissonant */, 2 /* Dissonant */],
-  [32768 /* NeedsResolution */, 1 /* Warning */, 2 /* Dissonant */]
-];
-function minimumSafetyForReasons(reasons, profile) {
-  let minimum = 0 /* Safe */;
-  const severityIndex = profile === "strict" ? 2 : 1;
-  for (const entry of REASON_SEVERITY) {
-    if (reasons & entry[0]) {
-      minimum = Math.max(minimum, entry[severityIndex]);
-    }
-  }
-  return minimum;
-}
-function pitchClass4(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function intervalAboveRoot(pitch, chord) {
-  return ((pitchClass4(pitch) - pitchClass4(chord.rootPc)) % 12 + 12) % 12;
-}
-function isChordMember(pitch, chord) {
-  return chordPitchClasses(chord).includes(pitchClass4(pitch));
-}
-function avoidsFourth(chord) {
-  return chord.intervals.includes(4) && !chord.intervals.includes(5);
-}
-function avoidsMajorSeventh(chord) {
-  return chord.intervals.includes(4) && chord.intervals.includes(10);
-}
-function stepResolution(pitch, chord) {
-  for (let delta = 1; delta <= 2; delta += 1) {
-    if (isChordMember(pitch - delta, chord)) {
-      return pitch - delta;
-    }
-  }
-  return void 0;
-}
-function evaluateSafety(q) {
-  assertSafetyContext(q);
-  assertFiniteNumber(q.candidatePitch, "candidatePitch");
-  return evaluateInternal(q, true);
-}
-function assertSafetyContext(q) {
-  if (q.prevPitch !== void 0) assertFiniteNumber(q.prevPitch, "prevPitch");
-  if (q.vocalLow !== void 0) assertFiniteNumber(q.vocalLow, "vocalLow");
-  if (q.vocalHigh !== void 0) assertFiniteNumber(q.vocalHigh, "vocalHigh");
-  if (q.vocalLow !== void 0 && q.vocalHigh !== void 0 && q.vocalLow > q.vocalHigh) {
-    throw new RangeError("vocalLow must not exceed vocalHigh");
-  }
-  assertGenerationBudget(q.otherVoices.length, "other voices");
-  for (let index = 0; index < q.otherVoices.length; index += 1) {
-    const voice = q.otherVoices[index];
-    if (!voice) continue;
-    assertFiniteNumber(voice.pitch, `otherVoices[${index}].pitch`);
-    if (voice.prevPitch !== void 0) {
-      assertFiniteNumber(voice.prevPitch, `otherVoices[${index}].prevPitch`);
-    }
-  }
-}
-function evaluateInternal(q, collectSuggestions) {
-  let reasons = 0;
-  let level = 0 /* Safe */;
-  let resolveTo;
-  const raise = (l) => {
-    if (l > level) {
-      level = l;
-    }
-  };
-  const avoidSeverity = q.profile === "strict" ? 2 /* Dissonant */ : 1 /* Warning */;
-  const parallelSeverity = avoidSeverity;
-  const pitch = q.candidatePitch;
-  if (q.vocalLow !== void 0 && pitch < q.vocalLow || q.vocalHigh !== void 0 && pitch > q.vocalHigh) {
-    reasons |= 32 /* OutOfRange */;
-    raise(1 /* Warning */);
-  }
-  const inScale = isScaleTone(pitch, q.key);
-  const chord = q.chord;
-  if (chord && isChordMember(pitch, chord)) {
-    reasons |= 1 /* ChordTone */;
-  } else if (chord) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const isTension = ic === 2 || ic === 5 || ic === 9;
-    const avoid = ic === 5 && avoidsFourth(chord) || ic === 11 && avoidsMajorSeventh(chord);
-    if (avoid) {
-      reasons |= 4 /* AvoidNote */;
-      if (isTension) {
-        reasons |= 2 /* Tension */;
-      }
-      reasons |= 32768 /* NeedsResolution */;
-      resolveTo = stepResolution(pitch, chord);
-      raise(avoidSeverity);
-    } else if (isTension && inScale) {
-      reasons |= 2 /* Tension */;
-      raise(1 /* Warning */);
-    } else if (inScale) {
-      reasons |= 8 /* ScaleTone */;
-      raise(1 /* Warning */);
-    } else {
-      reasons |= 16 /* NonScale */;
-      raise(2 /* Dissonant */);
-    }
-  } else if (inScale) {
-    reasons |= 8 /* ScaleTone */;
-    raise(1 /* Warning */);
-  } else {
-    reasons |= 16 /* NonScale */;
-    raise(2 /* Dissonant */);
-  }
-  if (chord && !(chord.intervals.includes(4) && chord.intervals.includes(10))) {
-    const ic = intervalAboveRoot(pitch, chord);
-    const toneOffsets = chord.intervals.map((i) => (i % 12 + 12) % 12);
-    if (toneOffsets.some((t) => Math.abs(ic - t) === 6)) {
-      reasons |= 64 /* Tritone */;
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const pc = Math.abs(pitch - q.prevPitch) % 12;
-    if (pc === 6) {
-      reasons |= 64 /* Tritone */;
-      raise(2 /* Dissonant */);
-    }
-    if (isForbiddenMelodicLeap(q.prevPitch, pitch)) {
-      reasons |= 128 /* LargeLeap */;
-      raise(parallelSeverity);
-    }
-    if (pc === 1) {
-      reasons |= 256 /* MinorSecond */;
-    }
-    if (pc === 11) {
-      reasons |= 512 /* MajorSeventh */;
-    }
-  }
-  if (q.strongBeat) {
-    const twoVoice = q.otherVoices.length === 1;
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (!createsVerticalDissonance(pitch, ov.pitch, twoVoice)) {
-        continue;
-      }
-      reasons |= 1024 /* VerticalDissonance */;
-      raise(2 /* Dissonant */);
-      if (prev !== void 0 && pitch === prev && ov.prevPitch !== void 0 && !createsVerticalDissonance(prev, ov.prevPitch, twoVoice)) {
-        reasons |= 16384 /* Suspension */;
-      }
-    }
-  }
-  if (q.prevPitch !== void 0) {
-    const prev = q.prevPitch;
-    for (const ov of q.otherVoices) {
-      if (ov.prevPitch === void 0) {
-        continue;
-      }
-      if (createsParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 2048 /* ParallelPerfect */;
-        raise(parallelSeverity);
-      }
-      if (createsHiddenParallelPerfect(prev, pitch, ov.prevPitch, ov.pitch)) {
-        reasons |= 4096 /* HiddenParallel */;
-        raise(parallelSeverity);
-      }
-      const crossedNow = pitch - ov.pitch;
-      const crossedPrev = prev - ov.prevPitch;
-      if (crossedNow !== 0 && crossedPrev !== 0 && crossedNow > 0 !== crossedPrev > 0) {
-        reasons |= 8192 /* VoiceCrossing */;
-        raise(parallelSeverity);
-      }
-    }
-  }
-  raise(minimumSafetyForReasons(reasons, q.profile));
-  const result = { safety: level, reasons, rationale: describe(reasons, q) };
-  if (resolveTo !== void 0) {
-    result.resolveTo = resolveTo;
-  }
-  if (collectSuggestions && level !== 0 /* Safe */) {
-    const suggestions = findSafeNearby(q, pitch);
-    if (suggestions.length > 0) {
-      result.suggestions = suggestions;
-    }
-  }
-  return result;
-}
-function findSafeNearby(q, candidate) {
-  const out = [];
-  for (let d = 1; d <= SUGGESTION_WINDOW; d += 1) {
-    for (const p of [candidate - d, candidate + d]) {
-      if (evaluateInternal({ ...q, candidatePitch: p }, false).safety === 0 /* Safe */) {
-        out.push(p);
-        if (out.length >= MAX_SUGGESTIONS) {
-          return out;
-        }
-      }
-    }
-  }
-  return out;
-}
-function describe(reasons, q) {
-  if (reasons & 32 /* OutOfRange */) {
-    return "Outside the target vocal range";
-  }
-  if (reasons & 16384 /* Suspension */) {
-    return "Prepared suspension \u2014 a held consonance now dissonant, awaiting resolution";
-  }
-  if (reasons & 1024 /* VerticalDissonance */) {
-    return "Dissonant against a sounding voice on a strong beat";
-  }
-  if (reasons & 4 /* AvoidNote */) {
-    return "Avoid note \u2014 clashes with a chord tone a semitone away";
-  }
-  if (reasons & 2048 /* ParallelPerfect */) {
-    return "Parallel perfect interval with another voice";
-  }
-  if (reasons & 4096 /* HiddenParallel */) {
-    return "Hidden perfect interval by similar motion";
-  }
-  if (reasons & 8192 /* VoiceCrossing */) {
-    return "Crosses another voice";
-  }
-  if (reasons & 1 /* ChordTone */) {
-    return "Chord tone";
-  }
-  if (reasons & 2 /* Tension */) {
-    return "Chord tension";
-  }
-  if (reasons & 16 /* NonScale */) {
-    return "Outside the key";
-  }
-  if (reasons & 8 /* ScaleTone */) {
-    return "Scale tone, not in the chord";
-  }
-  return q.chord ? "Placeable" : "No chord context";
-}
 
-// src/analyze/functional/internal.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
-function degreeRootPc(degreeNumber, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  if (tones.length === 0) {
-    return mod12(key.rootPc);
-  }
-  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);
-}
-function isNeapolitan(chord, key) {
-  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === "maj";
-}
 
-// src/analyze/functional/roman.ts
-var ROMAN = ["I", "II", "III", "IV", "V", "VI", "VII"];
-var ROMAN_TO_DEGREE = {
-  I: 1,
-  II: 2,
-  III: 3,
-  IV: 4,
-  V: 5,
-  VI: 6,
-  VII: 7
-};
-var OFFSET_SPELLING = [
-  [1, ""],
-  [2, "b"],
-  [2, ""],
-  [3, "b"],
-  [3, ""],
-  [4, ""],
-  [4, "#"],
-  [5, ""],
-  [6, "b"],
-  [6, ""],
-  [7, "b"],
-  [7, ""]
-];
-function seventhQuality(base, halfDim) {
-  if (halfDim) {
-    return "m7b5";
-  }
-  if (base === "dim") {
-    return "dim7";
-  }
-  if (base === "aug") {
-    return "aug7";
-  }
-  return base === "maj" ? "dom7" : "min7";
-}
-var INVERSION_FIGURES = /* @__PURE__ */ new Set(["6", "64", "65", "43", "42", "2", "7"]);
-var ROMAN_STYLE = {
-  maj: { lower: false, suffix: "" },
-  min: { lower: true, suffix: "" },
-  dim: { lower: true, suffix: "o" },
-  aug: { lower: false, suffix: "+" },
-  maj7: { lower: false, suffix: "maj7" },
-  min7: { lower: true, suffix: "7" },
-  dom7: { lower: false, suffix: "7" },
-  dim7: { lower: true, suffix: "o7" },
-  m7b5: { lower: true, suffix: "\xF87" },
-  minMaj7: { lower: true, suffix: "maj7" },
-  aug7: { lower: false, suffix: "+7" },
-  augMaj7: { lower: false, suffix: "+maj7" },
-  majb5: { lower: false, suffix: "b5" },
-  "6": { lower: false, suffix: "add6" },
-  min6: { lower: true, suffix: "add6" },
-  "6/9": { lower: false, suffix: "69" },
-  sus2: { lower: false, suffix: "sus2" },
-  sus4: { lower: false, suffix: "sus4" },
-  add9: { lower: false, suffix: "add9" },
-  add11: { lower: false, suffix: "add11" },
-  maj9: { lower: false, suffix: "maj9" },
-  min9: { lower: true, suffix: "9" },
-  dom9: { lower: false, suffix: "9" },
-  "7b9": { lower: false, suffix: "7b9" },
-  "7#9": { lower: false, suffix: "7#9" },
-  "7#11": { lower: false, suffix: "7#11" },
-  "7b13": { lower: false, suffix: "7b13" },
-  "11": { lower: false, suffix: "11" },
-  "13": { lower: false, suffix: "13" },
-  "5": { lower: false, suffix: "5" }
-};
-var SUFFIX_QUALITY = new Map(
-  Object.entries(ROMAN_STYLE).map(
-    ([quality, style]) => [`${style.lower ? "l" : "u"}:${style.suffix}`, quality]
-  )
-);
-function parseInversion(figures) {
-  if (figures === "65") {
-    return { inversion: 1, seventh: true };
-  }
-  if (figures === "43") {
-    return { inversion: 2, seventh: true };
-  }
-  if (figures === "42" || figures === "2") {
-    return { inversion: 3, seventh: true };
-  }
-  if (figures === "7") {
-    return { inversion: 0, seventh: true };
-  }
-  if (figures === "64") {
-    return { inversion: 2, seventh: false };
-  }
-  if (figures === "6") {
-    return { inversion: 1, seventh: false };
-  }
-  return { inversion: 0, seventh: false };
-}
-function parseSimpleRoman(text, key) {
-  const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());
-  if (!match) {
-    throw new Error(`Invalid Roman numeral: ${text}`);
-  }
-  const accidental = match[1] === "b" ? -1 : match[1] === "#" ? 1 : 0;
-  const glyph = (match[2] ?? "").toUpperCase();
-  const degreeNumber = ROMAN_TO_DEGREE[glyph];
-  if (degreeNumber === void 0) {
-    throw new Error(`Invalid Roman numeral: ${text}`);
-  }
-  const isUpper = (match[2] ?? "")[0] === (match[2] ?? "")[0]?.toUpperCase();
-  const suffix = match[3] ?? "";
-  const rootPc = mod12(degreeRootPc(degreeNumber, key) + accidental);
-  const canonical = SUFFIX_QUALITY.get(`${isUpper ? "u" : "l"}:${suffix}`);
-  if (canonical !== void 0) {
-    return { rootPc, quality: canonical, inversion: 0 };
-  }
-  const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
-  if (!parsedSuffix) {
-    throw new Error(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
-  }
-  const qualityMarker = parsedSuffix[1] ?? "";
-  const isDim = qualityMarker === "o" || qualityMarker === "\xB0" || qualityMarker === "dim";
-  const isAug = qualityMarker === "+" || qualityMarker === "aug";
-  const isHalfDim = qualityMarker === "\xF8";
-  const explicitMaj7 = parsedSuffix[2] !== void 0;
-  const figures = parsedSuffix[3] ?? "";
-  if (figures !== "" && !INVERSION_FIGURES.has(figures)) {
-    throw new Error(`Unsupported figured-bass or extension "${figures}" in Roman numeral: ${text}`);
-  }
-  const { inversion, seventh } = parseInversion(figures);
-  const hasSeventh = explicitMaj7 || seventh || isHalfDim;
-  let base;
-  if (isDim || isHalfDim) {
-    base = "dim";
-  } else if (isAug) {
-    base = "aug";
-  } else {
-    base = isUpper ? "maj" : "min";
-  }
-  let quality;
-  if (explicitMaj7) {
-    quality = base === "min" ? "minMaj7" : base === "aug" ? "augMaj7" : "maj7";
-  } else if (hasSeventh) {
-    quality = seventhQuality(base, isHalfDim);
-  } else if (base === "dim") {
-    quality = "dim";
-  } else if (base === "aug") {
-    quality = "aug";
-  } else {
-    quality = base;
-  }
-  return { rootPc, quality, inversion };
-}
-function chordFromParsed(parsed) {
-  const chord = makeChord(parsed.rootPc, parsed.quality);
-  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {
-    chord.bassPc = mod12(parsed.rootPc + (chord.intervals[parsed.inversion] ?? 0));
-  }
-  return chord;
-}
-function romanToChord(text, key) {
-  const trimmed = text.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash >= 0) {
-    const applied = trimmed.slice(0, slash);
-    const target = trimmed.slice(slash + 1);
-    const targetRoot = parseSimpleRoman(target, key).rootPc;
-    const localKey = majorKey(targetRoot);
-    return chordFromParsed(parseSimpleRoman(applied, localKey));
-  }
-  return chordFromParsed(parseSimpleRoman(trimmed, key));
-}
-function romanStyle(quality) {
-  return ROMAN_STYLE[quality];
-}
-function romanSpelling(rootPc, key) {
-  const tones = scaleTonesInDegreeOrder(key);
-  const diatonic = tones.indexOf(mod12(rootPc));
-  if (diatonic >= 0) {
-    return { degreeNumber: diatonic + 1, accidental: "" };
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    const degreeNumber2 = i + 1;
-    if (degreeNumber2 === 1 || degreeNumber2 === 5) {
-      continue;
-    }
-    if (mod12((tones[i] ?? 0) - 1) === mod12(rootPc)) {
-      return { degreeNumber: degreeNumber2, accidental: "b" };
-    }
-  }
-  for (let i = 0; i < tones.length; i += 1) {
-    if (mod12((tones[i] ?? 0) + 1) === mod12(rootPc)) {
-      return { degreeNumber: i + 1, accidental: "#" };
-    }
-  }
-  const [degreeNumber, accidental] = OFFSET_SPELLING[mod12(rootPc - key.rootPc)] ?? [1, ""];
-  return { degreeNumber, accidental };
-}
-function baseMarker(quality) {
-  if (quality === "dim" || quality === "dim7") {
-    return "o";
-  }
-  if (quality === "m7b5") {
-    return "\xF8";
-  }
-  if (quality === "aug" || quality === "aug7") {
-    return "+";
-  }
-  if (quality === "augMaj7") {
-    return "+maj7";
-  }
-  if (quality === "maj7" || quality === "minMaj7") {
-    return "maj7";
-  }
-  return "";
-}
-var TRIAD_FIGURES = { 1: "6", 2: "64" };
-var SEVENTH_FIGURES = { 1: "65", 2: "43", 3: "42" };
-var TRIAD_FIGURE_QUALITIES = /* @__PURE__ */ new Set(["maj", "min", "dim", "aug"]);
-var SEVENTH_FIGURE_QUALITIES = /* @__PURE__ */ new Set([
-  "maj7",
-  "min7",
-  "dom7",
-  "dim7",
-  "m7b5",
-  "minMaj7",
-  "aug7",
-  "augMaj7"
-]);
-function chordToRoman(chord, key) {
-  const { degreeNumber, accidental } = romanSpelling(chord.rootPc, key);
-  const { lower, suffix } = romanStyle(chord.quality);
-  const numeral = ROMAN[degreeNumber - 1] ?? "I";
-  const cased = lower ? numeral.toLowerCase() : numeral;
-  let inversion = 0;
-  if (chord.bassPc !== void 0) {
-    const idx = chord.intervals.findIndex((iv) => mod12(chord.rootPc + iv) === chord.bassPc);
-    if (idx > 0) {
-      inversion = idx;
-    }
-  }
-  if (inversion > 0) {
-    const figure = SEVENTH_FIGURE_QUALITIES.has(chord.quality) ? SEVENTH_FIGURES[inversion] : TRIAD_FIGURE_QUALITIES.has(chord.quality) ? TRIAD_FIGURES[inversion] : void 0;
-    if (figure !== void 0) {
-      return `${accidental}${cased}${baseMarker(chord.quality)}${figure}`;
-    }
-  }
-  return `${accidental}${cased}${suffix}`;
-}
 
-// src/analyze/functional/function.ts
-var FUNCTION_BY_OFFSET = [
-  "tonic",
-  // 0  I
-  "subdominant",
-  // 1  bII (Neapolitan)
-  "subdominant",
-  // 2  ii
-  "tonic",
-  // 3  bIII
-  "tonic",
-  // 4  iii
-  "subdominant",
-  // 5  IV
-  "dominant",
-  // 6  #IV / bV
-  "dominant",
-  // 7  V
-  "subdominant",
-  // 8  bVI
-  "tonic",
-  // 9  vi
-  "subdominant",
-  // 10 bVII
-  "dominant"
-  // 11 vii
-];
-function isMinorKey(key) {
-  const hasMinorThird = key.modeMask12 >> 3 & 1;
-  const hasMajorThird2 = key.modeMask12 >> 4 & 1;
-  return Boolean(hasMinorThird) && !hasMajorThird2;
-}
-function functionOf(chord, key) {
-  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? "tonic";
-}
-function isDiatonic(chord, key) {
-  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
-}
-function parallelKey(key) {
-  return {
-    rootPc: mod12(key.rootPc),
-    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK
-  };
-}
-function isDiminishedQuality(quality) {
-  return quality === "dim" || quality === "dim7" || quality === "m7b5";
-}
-function hasMajorThird(chord) {
-  return chord.intervals.some((interval) => mod12(interval) === 4);
-}
-function qualityAwareFunction(chord, key) {
-  const offset = mod12(chord.rootPc - key.rootPc);
-  if (isDiminishedQuality(chord.quality) && (offset === 11 || offset === 6)) {
-    return "dominant";
-  }
-  if (isNeapolitan(chord, key)) {
-    return "subdominant";
-  }
-  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
-    return "subdominant";
-  }
-  return functionOf(chord, key);
-}
-function analyzeChord(chord, key) {
-  const source = borrowedSource(chord, key);
-  return {
-    function: qualityAwareFunction(chord, key),
-    borrowed: source !== null,
-    source,
-    roman: chordToRoman(chord, key)
-  };
-}
-function secondaryDominant(targetDegree, key) {
-  const targetRoot = degreeRootPc(targetDegree + 1, key);
-  return makeChord(mod12(targetRoot + 7), "dom7");
-}
 
-// src/analyze/functional/borrowed.ts
-function isHarmonicMinorAlteration(chord, key) {
-  return isMinorKey(key) && isDiatonic(chord, { rootPc: mod12(key.rootPc), modeMask12: HARMONIC_MINOR_MASK });
-}
-function isBorrowedChord(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return false;
-  }
-  if (isHarmonicMinorAlteration(chord, key)) {
-    return false;
-  }
-  return isDiatonic(chord, parallelKey(key));
-}
-function borrowedSource(chord, key) {
-  if (isDiatonic(chord, key)) {
-    return null;
-  }
-  if (isNeapolitan(chord, key)) {
-    return "neapolitan";
-  }
-  if (isBorrowedChord(chord, key)) {
-    return isMinorKey(key) ? "parallel-major" : "parallel-minor";
-  }
-  return null;
-}
 
-// src/analyze/functional/cadence.ts
-function detectCadence(from, to, key) {
-  const tonic = mod12(key.rootPc);
-  const fromOffset = mod12(from.rootPc - tonic);
-  const toOffset = mod12(to.rootPc - tonic);
-  const deceptiveTargets = isMinorKey(key) ? [8] : [8, 9];
-  if (fromOffset === 7 && toOffset === 0) {
-    return "authentic";
-  }
-  if (fromOffset === 5 && toOffset === 0) {
-    return "plagal";
-  }
-  if (fromOffset === 7 && deceptiveTargets.includes(toOffset)) {
-    return "deceptive";
-  }
-  if (toOffset === 7 && fromOffset !== 7) {
-    return "half";
-  }
-  return null;
-}
 
-// src/core/event-index/index.ts
-var EPS2 = 1e-9;
-function upperBound(values, beat) {
-  let low = 0;
-  let high = values.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((values[middle]?.note.startBeat ?? Number.POSITIVE_INFINITY) <= beat) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low;
-}
-function createNoteEventIndex(events, options = {}) {
-  assertNoteEvents(events, "note events", options);
-  const notes = events.map((note, originalIndex) => ({
-    note,
-    originalIndex,
-    endBeat: note.startBeat + note.durationBeat
-  })).sort((a, b) => a.note.startBeat - b.note.startBeat || a.originalIndex - b.originalIndex);
-  const prefixMaxEnd = [];
-  let maxEnd = Number.NEGATIVE_INFINITY;
-  for (const indexed of notes) {
-    maxEnd = Math.max(maxEnd, indexed.endBeat);
-    prefixMaxEnd.push(maxEnd);
-  }
-  return {
-    notes,
-    at(beat) {
-      let index = upperBound(notes, beat + EPS2) - 1;
-      while (index >= 0) {
-        if ((prefixMaxEnd[index] ?? Number.NEGATIVE_INFINITY) <= beat + EPS2) {
-          return void 0;
-        }
-        const indexed = notes[index];
-        if (indexed && indexed.note.durationBeat > 0 && indexed.note.startBeat - EPS2 <= beat && beat < indexed.endBeat - EPS2) {
-          return indexed;
-        }
-        index -= 1;
-      }
-      return void 0;
-    },
-    attacksAt(beat) {
-      const firstAfter = upperBound(notes, beat + EPS2);
-      const candidate = notes[firstAfter - 1];
-      return candidate !== void 0 && Math.abs(candidate.note.startBeat - beat) < EPS2;
-    },
-    onsetsBetween(startBeat, endBeat) {
-      const result = [];
-      let index = upperBound(notes, startBeat + EPS2);
-      while (index < notes.length) {
-        const onset = notes[index]?.note.startBeat;
-        if (onset === void 0 || onset >= endBeat - EPS2) {
-          break;
-        }
-        if (result[result.length - 1] !== onset) {
-          result.push(onset);
-        }
-        index += 1;
-      }
-      return result;
-    }
-  };
-}
 
-// src/analyze/detect/index.ts
-function pitchClass5(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function uniquePitchClasses(pitches) {
-  return [...new Set(pitches.map(pitchClass5))].sort((a, b) => a - b);
-}
-function assertPitches(pitches) {
-  assertGenerationBudget(pitches.length, "detection pitches");
-  for (let index = 0; index < pitches.length; index += 1) {
-    assertFiniteNumber(pitches[index] ?? Number.NaN, `pitches[${index}]`);
-  }
-}
-function detectChord(pitches, opts = {}) {
-  assertPitches(pitches);
-  if (opts.bassPc !== void 0) assertFiniteNumber(opts.bassPc, "bassPc");
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const inputKind = opts.input === void 0 || opts.input === "auto" ? pitches.every((pitch) => Number.isInteger(pitch) && pitch >= 0 && pitch <= 11) ? "pitchClass" : "midi" : opts.input;
-  const bassPc = opts.bassPc !== void 0 ? pitchClass5(opts.bassPc) : inputKind === "midi" ? pitchClass5(pitches.reduce((lowest, pitch) => Math.min(lowest, pitch), Infinity)) : void 0;
-  const inputSet = new Set(input);
-  const matches = [];
-  const qualities = chordQualities();
-  for (const rootPc of input) {
-    for (const quality of qualities) {
-      const chord = makeChord(rootPc, quality);
-      const tones = chordPitchClasses(chord);
-      const toneSet = new Set(tones);
-      const missingPcs = tones.filter((pc) => !inputSet.has(pc));
-      const fifthPc = pitchClass5(rootPc + 7);
-      if (missingPcs.length > 1 || missingPcs.length === 1 && missingPcs[0] !== fifthPc) {
-        continue;
-      }
-      const extraPcs = input.filter((pc) => !toneSet.has(pc));
-      const bassIndex = bassPc === void 0 ? -1 : chord.intervals.findIndex((iv) => pitchClass5(rootPc + iv) === bassPc);
-      const inversion = bassPc === void 0 ? null : bassIndex > 0 ? bassIndex : 0;
-      const match = {
-        rootPc,
-        quality,
-        missingPcs,
-        extraPcs,
-        exact: extraPcs.length === 0 && missingPcs.length === 0,
-        inversion
-      };
-      if (bassPc !== void 0 && bassPc !== rootPc) {
-        match.bassPc = bassPc;
-      }
-      matches.push(match);
-    }
-  }
-  matches.sort((a, b) => {
-    if (a.extraPcs.length !== b.extraPcs.length) {
-      return a.extraPcs.length - b.extraPcs.length;
-    }
-    if (a.missingPcs.length !== b.missingPcs.length) {
-      return a.missingPcs.length - b.missingPcs.length;
-    }
-    if (a.inversion === 0 !== (b.inversion === 0)) {
-      return a.inversion === 0 ? -1 : 1;
-    }
-    const aSize = chordPitchClasses(makeChord(a.rootPc, a.quality)).length;
-    const bSize = chordPitchClasses(makeChord(b.rootPc, b.quality)).length;
-    return bSize - aSize;
-  });
-  return matches;
-}
-function detectChordBest(pitches, opts = {}) {
-  const best = detectChord(pitches, opts)[0];
-  if (!best) {
-    return null;
-  }
-  return makeChord(best.rootPc, best.quality, best.bassPc);
-}
-var MINOR_MASK_VARIANTS = [NATURAL_MINOR_MASK, HARMONIC_MINOR_MASK, MELODIC_MINOR_MASK];
-function detectKey(pitches) {
-  assertPitches(pitches);
-  const input = uniquePitchClasses(pitches);
-  if (input.length === 0) {
-    return [];
-  }
-  const counts = /* @__PURE__ */ new Map();
-  for (const pc of pitches.map(pitchClass5)) {
-    counts.set(pc, (counts.get(pc) ?? 0) + 1);
-  }
-  const total = pitches.length;
-  const results = [];
-  for (let tonic = 0; tonic < 12; tonic += 1) {
-    for (const mode of ["major", "minor"]) {
-      const key = mode === "major" ? majorKey(tonic) : minorKey(tonic);
-      const masks = mode === "major" ? [MAJOR_MASK] : MINOR_MASK_VARIANTS;
-      let inScale = 0;
-      let weighted = Number.NEGATIVE_INFINITY;
-      for (const mask of masks) {
-        let variantInScale = 0;
-        let variantWeighted = 0;
-        for (const pc of input) {
-          const offset = (pc - tonic + 12) % 12;
-          if (mask >> offset & 1) {
-            variantInScale += 1;
-          }
-        }
-        for (const [pc, count] of counts) {
-          const offset = (pc - tonic + 12) % 12;
-          if (mask >> offset & 1) {
-            variantWeighted += count;
-          }
-        }
-        if (variantWeighted > weighted) {
-          weighted = variantWeighted;
-          inScale = variantInScale;
-        }
-      }
-      weighted += (counts.get(tonic) ?? 0) * 0.5;
-      results.push({
-        key,
-        mode,
-        fit: inScale / input.length,
-        score: weighted / total
-      });
-    }
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results.map(({ key, mode, fit }) => ({ key, mode, fit }));
-}
 
-// src/analyze/timeline/index.ts
-function chordTimelineFromChords(chords, totalBeats) {
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  assertGenerationBudget(chords.length, "timeline chords");
-  for (let index = 0; index < chords.length; index += 1) {
-    assertRange(
-      chords[index]?.startBeat ?? Number.NaN,
-      0,
-      Number.MAX_SAFE_INTEGER,
-      `chords[${index}].startBeat`
-    );
-  }
-  const sorted = [...chords].filter((chord) => chord.startBeat < totalBeats).sort((a, b) => a.startBeat - b.startBeat);
-  const segments = sorted.map((gc, i) => {
-    const next = sorted[i + 1];
-    const nextBeat = next ? next.startBeat : totalBeats;
-    const endBeat = Math.min(totalBeats, Math.max(gc.startBeat, nextBeat));
-    return {
-      startBeat: gc.startBeat,
-      endBeat,
-      chord: makeChord(gc.rootPc, gc.quality, gc.bassPc)
-    };
-  }).filter((seg) => seg.endBeat > seg.startBeat);
-  return { at: segmentLookup(segments), segments };
-}
-function segmentLookup(segments) {
-  return (beat) => {
-    assertFiniteNumber(beat, "timeline query beat");
-    for (const seg of segments) {
-      if (beat >= seg.startBeat && beat < seg.endBeat) {
-        return seg.chord;
-      }
-    }
-    return null;
-  };
-}
-var EPS3 = 1e-9;
-var NOISE_THRESHOLD_RATIO = 0.2;
-var MAX_DETECTION_PCS = 6;
-var FALLBACK_PCS = 3;
-var INEXACT_CONFIDENCE_FACTOR = 0.85;
-var DIATONIC_BONUS = 0.5;
-var EXACT_BONUS = 0.5;
-var MISMATCH_PENALTY = 0.3;
-function pitchClass6(value) {
-  return (Math.trunc(value) % 12 + 12) % 12;
-}
-function scoreMatch(match, weights, maxWeight, key) {
-  const rootWeight = maxWeight > 0 ? (weights[match.rootPc] ?? 0) / maxWeight : 0;
-  const tones = chordPitchClasses(makeChord(match.rootPc, match.quality));
-  let score = rootWeight;
-  if (tones.every((pc) => isScaleTone(pc, key))) {
-    score += DIATONIC_BONUS;
-  }
-  if (match.exact) {
-    score += EXACT_BONUS;
-  }
-  score -= MISMATCH_PENALTY * (match.extraPcs.length + match.missingPcs.length);
-  return score;
-}
-function chordConfidence(chord, weights, totalWeight, exact) {
-  const tones = new Set(chordPitchClasses(chord));
-  let chordWeight = 0;
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (tones.has(pc)) {
-      chordWeight += weights[pc] ?? 0;
-    }
-  }
-  const raw = totalWeight > 0 ? chordWeight / totalWeight : 0;
-  const confidence = Math.min(1, Math.max(0, raw));
-  return exact ? confidence : confidence * INEXACT_CONFIDENCE_FACTOR;
-}
-function analyzeWindow(notes, windowStart, windowEnd, ts, key) {
-  const weights = new Array(12).fill(0);
-  let lowestPitch = Number.POSITIVE_INFINITY;
-  for (const note of notes) {
-    const noteEnd = note.startBeat + note.durationBeat;
-    const overlap = Math.min(noteEnd, windowEnd) - Math.max(note.startBeat, windowStart);
-    if (overlap <= EPS3) {
-      continue;
-    }
-    const velocityFactor = note.velocity !== void 0 ? note.velocity / 127 : 1;
-    const onsetInWindow = note.startBeat >= windowStart - EPS3 && note.startBeat < windowEnd - EPS3;
-    const accent = onsetInWindow ? 1 + metricWeight(note.startBeat, ts) / 3 : 1;
-    const pc = pitchClass6(note.pitch);
-    weights[pc] = (weights[pc] ?? 0) + overlap * velocityFactor * accent;
-    if (note.pitch < lowestPitch) {
-      lowestPitch = note.pitch;
-    }
-  }
-  let totalWeight = 0;
-  let maxWeight = 0;
-  for (const w of weights) {
-    totalWeight += w;
-    maxWeight = Math.max(maxWeight, w);
-  }
-  if (totalWeight <= EPS3) {
-    return null;
-  }
-  const ranked = weights.map((weight, pc) => ({ pc, weight })).filter(({ weight }) => weight > 0).sort((a, b) => b.weight - a.weight || a.pc - b.pc);
-  const selected = ranked.filter(({ weight }) => weight >= maxWeight * NOISE_THRESHOLD_RATIO).slice(0, MAX_DETECTION_PCS).map(({ pc }) => pc);
-  const bassPc = pitchClass6(lowestPitch);
-  const anchorPc = selected.includes(bassPc) ? bassPc : selected[0] ?? bassPc;
-  const detectionPitches = selected.map((pc) => pc === anchorPc ? pc : pc + 12);
-  const matches = detectChord(detectionPitches);
-  let bestMatch = null;
-  let bestScore = Number.NEGATIVE_INFINITY;
-  for (const match of matches) {
-    const score = scoreMatch(match, weights, maxWeight, key);
-    if (score > bestScore) {
-      bestScore = score;
-      bestMatch = match;
-    }
-  }
-  if (bestMatch) {
-    const chord = makeChord(bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
-    return { chord, confidence: chordConfidence(chord, weights, totalWeight, bestMatch.exact) };
-  }
-  const fallback = detectChordBest(selected.slice(0, FALLBACK_PCS));
-  if (fallback) {
-    return { chord: fallback, confidence: chordConfidence(fallback, weights, totalWeight, false) };
-  }
-  return null;
-}
-function sameChord(a, b) {
-  return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc;
-}
-function chordTimelineFromNotes(notes, opts = {}) {
-  const ts = opts.ts ?? parseTimeSignature("4/4");
-  assertTimeSignature(ts);
-  const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBar(ts);
-  assertRange(harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
-  assertNoteEvents(notes, "timeline notes", { allowNonPositiveDuration: true });
-  const soundingIndex = createNoteEventIndex(notes.filter((note) => note.durationBeat > 0));
-  const sounding = soundingIndex.notes.map(({ note }) => note);
-  const lastNoteEnd = sounding.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const totalBeats = opts.totalBeats ?? lastNoteEnd;
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  const key = opts.key ?? detectKey(sounding.map((n) => n.pitch))[0]?.key ?? majorKey(0);
-  const segments = [];
-  const segmentConfidence = [];
-  const windowCount = Math.max(0, Math.ceil(totalBeats / harmonicRhythm - EPS3));
-  assertGenerationBudget(windowCount, "timeline windows");
-  const windowNotes = Array.from({ length: windowCount }, () => []);
-  let memberships = 0;
-  for (const indexed of soundingIndex.notes) {
-    const first = Math.max(0, Math.floor(indexed.note.startBeat / harmonicRhythm));
-    const lastExclusive = Math.min(windowCount, Math.ceil(indexed.endBeat / harmonicRhythm));
-    memberships += Math.max(0, lastExclusive - first);
-    assertGenerationBudget(memberships, "timeline note-to-window memberships");
-    for (let window = first; window < lastExclusive; window += 1) {
-      windowNotes[window]?.push(indexed.note);
-    }
-  }
-  for (let i = 0; i < windowCount; i += 1) {
-    const start = i * harmonicRhythm;
-    const end = Math.min(start + harmonicRhythm, totalBeats);
-    const inferred = analyzeWindow(windowNotes[i] ?? [], start, end, ts, key);
-    if (!inferred) {
-      continue;
-    }
-    const last = segments[segments.length - 1];
-    if (last && sameChord(last.chord, inferred.chord) && Math.abs(last.endBeat - start) < EPS3) {
-      const lastLength = last.endBeat - last.startBeat;
-      const length = end - start;
-      const lastConfidence = segmentConfidence[segmentConfidence.length - 1] ?? 0;
-      segmentConfidence[segmentConfidence.length - 1] = (lastConfidence * lastLength + inferred.confidence * length) / (lastLength + length);
-      last.endBeat = end;
-    } else {
-      segments.push({ startBeat: start, endBeat: end, chord: inferred.chord });
-      segmentConfidence.push(inferred.confidence);
-    }
-  }
-  return {
-    timeline: { at: segmentLookup(segments), segments },
-    key,
-    segmentConfidence
-  };
-}
-function detectCadences(timeline, key) {
-  const hits = [];
-  for (let i = 1; i < timeline.segments.length; i += 1) {
-    const prev = timeline.segments[i - 1];
-    const cur = timeline.segments[i];
-    if (!prev || !cur) {
-      continue;
-    }
-    if (Math.abs(cur.startBeat - prev.endBeat) > EPS3) {
-      continue;
-    }
-    const type = detectCadence(prev.chord, cur.chord, key);
-    if (type !== null) {
-      hits.push({ atBeat: cur.startBeat, type, from: prev.chord, to: cur.chord });
-    }
-  }
-  return hits;
-}
 
-// src/analyze/arrange/internal.ts
-var EPS4 = 1e-9;
-function covers(note, beat) {
-  return beat >= note.startBeat - EPS4 && beat < note.endBeat - EPS4;
-}
-function poolNotes(tracks) {
-  const notes = [];
-  for (const track of tracks) {
-    for (const note of track.notes) {
-      if (note.durationBeat > 0) {
-        notes.push(note);
-      }
-    }
-  }
-  return notes;
-}
-function splitIntoSubVoices(ordered) {
-  const lanes = [];
-  for (const note of ordered) {
-    const lane = lanes.find((candidate) => {
-      const last = candidate[candidate.length - 1];
-      return last !== void 0 && last.startBeat + last.durationBeat <= note.startBeat + EPS4;
-    });
-    if (lane) {
-      lane.push(note);
-    } else {
-      lanes.push([note]);
-    }
-  }
-  return lanes;
-}
-function prepareTracks(tracks) {
-  let nextId = 0;
-  return tracks.map((track, index) => {
-    const ordered = track.notes.filter((note) => note.durationBeat > 0).sort((a, b) => a.startBeat - b.startBeat || a.pitch - b.pitch).map((note) => ({ ...note, id: nextId++ }));
-    const voices = splitIntoSubVoices(ordered).map((voice) => ({
-      voice,
-      sounding: voice.map((note, i) => {
-        const prev = i > 0 ? voice[i - 1] : void 0;
-        const prevEnd = prev === void 0 ? void 0 : prev.startBeat + prev.durationBeat;
-        const contiguous = prevEnd !== void 0 && Math.abs(prevEnd - note.startBeat) <= EPS4;
-        return {
-          pitch: note.pitch,
-          prevPitch: contiguous ? prev?.pitch : void 0,
-          startBeat: note.startBeat,
-          endBeat: note.startBeat + note.durationBeat
-        };
-      })
-    }));
-    return {
-      name: track.name ?? `track ${index + 1}`,
-      role: track.role ?? "other",
-      voices
-    };
-  });
-}
 
-// src/analyze/arrange/tension.ts
-var FUNCTION_TENSION = {
-  tonic: 0,
-  subdominant: 0.5,
-  dominant: 1
-};
-var FUNCTION_WEIGHT = 0.5;
-var DISSONANCE_WEIGHT = 0.35;
-var SPAN_WEIGHT = 0.15;
-var SPAN_SATURATION = 24;
-function pitchClass7(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function clamp01(value) {
-  return Math.min(1, Math.max(0, value));
-}
-function tensionCurve(tracks, opts = {}) {
-  const ts = opts.ts ?? parseTimeSignature("4/4");
-  assertTimeSignature(ts);
-  assertGenerationBudget(tracks.length, "arrangement tracks");
-  for (let index = 0; index < tracks.length; index += 1) {
-    assertNoteEvents(tracks[index]?.notes ?? [], `tracks[${index}].notes`, {
-      allowNonPositiveDuration: true
-    });
-  }
-  const profile = opts.profile ?? "pop";
-  const step = opts.step ?? 1;
-  assertRange(step, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "tension sampling step");
-  const pooled = poolNotes(tracks);
-  const totalBeats = pooled.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const { timeline, key } = chordTimelineFromNotes(pooled, {
-    key: opts.key,
-    ts,
-    harmonicRhythm: opts.harmonicRhythm
-  });
-  const prepared = prepareTracks(tracks);
-  const points = [];
-  const sampleCount = Math.max(0, Math.ceil(totalBeats / step - EPS4));
-  assertGenerationBudget(sampleCount, "tension samples");
-  for (let i = 0; i < sampleCount; i += 1) {
-    const beat = i * step;
-    points.push({ beat, tension: sampleTension(prepared, timeline, key, ts, profile, beat) });
-  }
-  return points;
-}
-function allSounding(prepared, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track) {
-      continue;
-    }
-    for (const subVoice of track.voices) {
-      for (const note of subVoice.sounding) {
-        if (covers(note, beat)) {
-          out.push({ pitch: note.pitch, track: t });
-        }
-      }
-    }
-  }
-  return out;
-}
-function sampleTension(prepared, timeline, key, ts, profile, beat) {
-  const sounding = allSounding(prepared, beat);
-  if (sounding.length === 0) {
-    return 0;
-  }
-  const chord = timeline.at(beat);
-  const functionScore = chord ? FUNCTION_TENSION[functionOf(chord, key)] : 0;
-  const chordPcs = chord ? new Set(chordPitchClasses(chord)) : null;
-  const strongBeat = isStrongBeat(beat, ts);
-  let nonChord = 0;
-  let dissonant = 0;
-  for (let i = 0; i < sounding.length; i += 1) {
-    const voice = sounding[i];
-    if (!voice) {
-      continue;
-    }
-    if (chordPcs && !chordPcs.has(pitchClass7(voice.pitch))) {
-      nonChord += 1;
-    }
-    const others = sounding.filter((_, j) => j !== i).map((s) => ({ pitch: s.pitch }));
-    const result = evaluateSafety({
-      profile,
-      candidatePitch: voice.pitch,
-      chord,
-      key,
-      otherVoices: others,
-      strongBeat
-    });
-    if (result.safety === 2 /* Dissonant */) {
-      dissonant += 1;
-    }
-  }
-  const dissonanceScore = Math.max(nonChord, dissonant) / sounding.length;
-  let low = Number.POSITIVE_INFINITY;
-  let high = Number.NEGATIVE_INFINITY;
-  for (const voice of sounding) {
-    low = Math.min(low, voice.pitch);
-    high = Math.max(high, voice.pitch);
-  }
-  const spanScore = Math.min(1, (high - low) / SPAN_SATURATION);
-  return clamp01(
-    FUNCTION_WEIGHT * functionScore + DISSONANCE_WEIGHT * dissonanceScore + SPAN_WEIGHT * spanScore
-  );
-}
 
-// src/analyze/voice/index.ts
-var EPS5 = 1e-9;
-function pitchClass8(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function intervalAboveRoot2(pitch, chord) {
-  return ((pitchClass8(pitch) - pitchClass8(chord.rootPc)) % 12 + 12) % 12;
-}
-function intervalAboveBass(pitch, others, chord) {
-  let bass = Number.POSITIVE_INFINITY;
-  for (const ov of others) {
-    bass = Math.min(bass, ov.pitch);
-  }
-  if (Number.isFinite(bass) && bass < pitch) {
-    return ((pitch - bass) % 12 + 12) % 12;
-  }
-  const ref = chord.bassPc ?? chord.rootPc;
-  return ((pitchClass8(pitch) - pitchClass8(ref)) % 12 + 12) % 12;
-}
-function tensionDegree(ic) {
-  if (ic === 1 || ic === 2) {
-    return 9;
-  }
-  if (ic === 5 || ic === 6) {
-    return 11;
-  }
-  return 13;
-}
-function isChordMember2(pitch, chord) {
-  return chord ? chordPitchClasses(chord).includes(pitchClass8(pitch)) : false;
-}
-function isStep(a, b) {
-  const d = Math.abs(a - b);
-  return d === 1 || d === 2;
-}
-function suspensionType(ic, delta) {
-  let type;
-  if (delta > 0) {
-    type = "sus2-3";
-  } else if (ic === 2) {
-    type = "sus9-8";
-  } else if (ic === 10 || ic === 11) {
-    type = "sus7-6";
-  } else {
-    type = "sus4-3";
-  }
-  return { kind: "suspension", type, resolveTo: 0 };
-}
-function stepResolution2(pitch, chord) {
-  for (let delta = 1; delta <= 2; delta += 1) {
-    if (isChordMember2(pitch - delta, chord)) {
-      return pitch - delta;
-    }
-  }
-  return void 0;
-}
-function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
-  assertNoteEvents(voice, "voice notes", { allowNonPositiveDuration: true });
-  const result = [];
-  for (let i = 0; i < voice.length; i += 1) {
-    const note = voice[i];
-    if (!note) {
-      continue;
-    }
-    const prevNote = i > 0 ? voice[i - 1] : void 0;
-    const nextNote = i + 1 < voice.length ? voice[i + 1] : void 0;
-    const prevEnd = prevNote === void 0 ? Number.NEGATIVE_INFINITY : prevNote.startBeat + prevNote.durationBeat;
-    const noteEnd = note.startBeat + note.durationBeat;
-    const prev = prevNote !== void 0 && Math.abs(prevEnd - note.startBeat) <= EPS5 ? prevNote : void 0;
-    const next = nextNote !== void 0 && Math.abs(noteEnd - nextNote.startBeat) <= EPS5 ? nextNote : void 0;
-    const chord = chordAtBeat(note.startBeat);
-    const labels = [];
-    const member = isChordMember2(note.pitch, chord);
-    let handled = false;
-    if (chord && member) {
-      const role = chordToneRole(note.pitch, chord);
-      if (role) {
-        labels.push({ kind: "chordTone", role });
-      } else {
-        const ic = intervalAboveRoot2(note.pitch, chord);
-        labels.push({ kind: "tension", degree: tensionDegree(ic) });
-      }
-      handled = true;
-    }
-    if (!handled && chord && prev && next) {
-      const prevChord = chordAtBeat(prev.startBeat);
-      const prepared = prev.pitch === note.pitch && isChordMember2(prev.pitch, prevChord);
-      const resolves = isStep(next.pitch, note.pitch);
-      const others = otherVoicesAtBeat(note.startBeat);
-      const verticallyDissonant = others.some(
-        (ov) => createsVerticalDissonance(note.pitch, ov.pitch, true)
-      );
-      if (prepared && verticallyDissonant && resolves) {
-        const ic = intervalAboveBass(note.pitch, others, chord);
-        const sus = suspensionType(ic, next.pitch - note.pitch);
-        sus.resolveTo = next.pitch;
-        labels.push(sus);
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next) {
-      const prevMember = isChordMember2(prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = isChordMember2(next.pitch, chordAtBeat(next.startBeat));
-      const up = note.pitch - prev.pitch > 0;
-      const contInto = next.pitch - note.pitch > 0;
-      const sameDir = note.pitch !== prev.pitch && next.pitch !== note.pitch && up === contInto;
-      if (prevMember && nextMember && !member && isStep(note.pitch, prev.pitch) && isStep(next.pitch, note.pitch) && sameDir) {
-        labels.push({ kind: "passing" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && isChordMember2(prev.pitch, chordAtBeat(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
-      labels.push({ kind: "neighbor" });
-      handled = true;
-    }
-    if (!handled && chord && next && !member && note.pitch === next.pitch) {
-      const nextChord = chordAtBeat(next.startBeat);
-      if (isChordMember2(next.pitch, nextChord)) {
-        labels.push({ kind: "anticipation" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member) {
-      const prevMember = isChordMember2(prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = isChordMember2(next.pitch, chordAtBeat(next.startBeat));
-      const stepFromPrev = isStep(note.pitch, prev.pitch);
-      const leapToNext = Math.abs(next.pitch - note.pitch) >= 3;
-      const opposite = note.pitch - prev.pitch > 0 !== next.pitch - note.pitch > 0;
-      if (prevMember && nextMember && stepFromPrev && leapToNext && opposite) {
-        labels.push({ kind: "escape" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && !member) {
-      const ic = intervalAboveRoot2(note.pitch, chord);
-      const isTension = ic === 2 || ic === 5 || ic === 9;
-      const avoid = ic === 5 && chord.intervals.includes(4) && !chord.intervals.includes(5) || ic === 11 && chord.intervals.includes(4) && chord.intervals.includes(10);
-      if (avoid) {
-        labels.push({ kind: "avoid" });
-        const resolveTo = stepResolution2(note.pitch, chord);
-        if (resolveTo !== void 0) {
-          labels.push({ kind: "needsResolution", resolveTo });
-        }
-      } else if (isTension) {
-        labels.push({ kind: "tension", degree: tensionDegree(ic) });
-      } else {
-        const resolveTo = stepResolution2(note.pitch, chord);
-        if (resolveTo !== void 0) {
-          labels.push({ kind: "needsResolution", resolveTo });
-        }
-      }
-    }
-    if (next && isLeadingToneResolution(note.pitch, next.pitch, key)) {
-      labels.push({ kind: "leadingTone", resolveTo: next.pitch });
-    }
-    result.push({ noteId: note.id, labels, rationale: describe2(labels) });
-  }
-  return result;
-}
-function describe2(labels) {
-  const primary = labels[0];
-  if (!primary) {
-    return "Unclassified note";
-  }
-  switch (primary.kind) {
-    case "chordTone":
-      return `Chord ${primary.role}`;
-    case "tension":
-      return `${primary.degree}th tension`;
-    case "avoid":
-      return "Avoid note";
-    case "passing":
-      return "Passing tone between chord tones";
-    case "neighbor":
-      return "Neighbor tone";
-    case "suspension":
-      return `Suspension (${primary.type})`;
-    case "anticipation":
-      return "Anticipation of the next chord";
-    case "escape":
-      return "Escape tone";
-    case "needsResolution":
-      return "Unresolved dissonance";
-    case "leadingTone":
-      return "Leading tone resolving to the tonic";
-  }
-}
 
-// src/analyze/arrange/tracks.ts
-function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track) {
-      continue;
-    }
-    for (let v = 0; v < track.voices.length; v += 1) {
-      if (t === excludeTrack && v === excludeVoice) {
-        continue;
-      }
-      const subVoice = track.voices[v];
-      if (!subVoice) {
-        continue;
-      }
-      for (const note of subVoice.sounding) {
-        if (!covers(note, beat)) {
-          continue;
-        }
-        const snap = { pitch: note.pitch };
-        const previous = Math.abs(note.startBeat - beat) <= EPS4 ? note.prevPitch : note.pitch;
-        if (previous !== void 0) {
-          snap.prevPitch = previous;
-        }
-        out.push(snap);
-      }
-    }
-  }
-  return out;
-}
-function evaluationBeats(note, timeline) {
-  const noteEnd = note.startBeat + note.durationBeat;
-  const beats = [note.startBeat];
-  for (const segment of timeline.segments) {
-    if (segment.startBeat > note.startBeat + EPS4 && segment.startBeat < noteEnd - EPS4) {
-      beats.push(segment.startBeat);
-    }
-  }
-  return beats;
-}
-function analyzeArrangement(tracks, opts = {}) {
-  const ts = opts.ts ?? parseTimeSignature("4/4");
-  assertTimeSignature(ts);
-  assertGenerationBudget(tracks.length, "arrangement tracks");
-  for (let index = 0; index < tracks.length; index += 1) {
-    assertNoteEvents(tracks[index]?.notes ?? [], `tracks[${index}].notes`, {
-      allowNonPositiveDuration: true
-    });
-  }
-  const profile = opts.profile ?? "pop";
-  const pooled = poolNotes(tracks);
-  const { timeline, key, segmentConfidence } = chordTimelineFromNotes(pooled, {
-    key: opts.key,
-    ts,
-    harmonicRhythm: opts.harmonicRhythm
-  });
-  const cadences = detectCadences(timeline, key);
-  const prepared = prepareTracks(tracks);
-  const trackAnalyses = [];
-  const conflicts = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track) {
-      continue;
-    }
-    const notes = [];
-    for (let v = 0; v < track.voices.length; v += 1) {
-      const subVoice = track.voices[v];
-      if (!subVoice) {
-        continue;
-      }
-      notes.push(
-        ...analyzeVoice(
-          subVoice.voice,
-          timeline.at,
-          key,
-          (beat) => otherVoicesSounding(prepared, t, v, beat)
-        )
-      );
-      for (let noteIndex = 0; noteIndex < subVoice.voice.length; noteIndex += 1) {
-        const note = subVoice.voice[noteIndex];
-        const preparedNote = subVoice.sounding[noteIndex];
-        if (note === void 0 || preparedNote === void 0) {
-          continue;
-        }
-        for (const beat of evaluationBeats(note, timeline)) {
-          const atOnset = Math.abs(beat - note.startBeat) <= EPS4;
-          const result = evaluateSafety({
-            profile,
-            candidatePitch: note.pitch,
-            prevPitch: atOnset ? preparedNote.prevPitch : note.pitch,
-            chord: timeline.at(beat),
-            key,
-            otherVoices: otherVoicesSounding(prepared, t, v, beat),
-            strongBeat: isStrongBeat(beat, ts)
-          });
-          if (result.safety !== 0 /* Safe */) {
-            const conflict = {
-              beat,
-              trackName: track.name,
-              pitch: note.pitch,
-              safety: result.safety,
-              reasons: result.reasons
-            };
-            if (result.rationale !== void 0) {
-              conflict.rationale = result.rationale;
-            }
-            if (result.resolveTo !== void 0) {
-              conflict.resolveTo = result.resolveTo;
-            }
-            if (result.suggestions !== void 0) {
-              conflict.suggestions = [...result.suggestions];
-            }
-            conflicts.push(conflict);
-          }
-        }
-      }
-    }
-    notes.sort((a, b) => a.noteId - b.noteId);
-    trackAnalyses.push({ name: track.name, role: track.role, notes });
-  }
-  conflicts.sort((a, b) => b.safety - a.safety || a.beat - b.beat);
-  return { key, timeline, segmentConfidence, cadences, tracks: trackAnalyses, conflicts };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  analyzeArrangement,
-  analyzeChord,
-  analyzeVoice,
-  borrowedSource,
-  chordTimelineFromChords,
-  chordTimelineFromNotes,
-  chordToRoman,
-  detectCadence,
-  detectCadences,
-  detectChord,
-  detectChordBest,
-  detectKey,
-  functionOf,
-  isBorrowedChord,
-  isDiatonic,
-  isMinorKey,
-  parallelKey,
-  romanToChord,
-  secondaryDominant,
-  tensionCurve
-});
+
+
+
+var _chunkKQN2ZYNDcjs = require('../chunk-KQN2ZYND.cjs');
+
+
+var _chunkWFDXOLUBcjs = require('../chunk-WFDXOLUB.cjs');
+require('../chunk-BSLTLGM3.cjs');
+require('../chunk-PI3UXRWK.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.NoteSafety = _chunkWFDXOLUBcjs.NoteSafety; exports.analyzeArrangement = _chunk4VZ5MZAMcjs.analyzeArrangement; exports.analyzeChord = _chunkKQN2ZYNDcjs.analyzeChord; exports.analyzeVoice = _chunk4VZ5MZAMcjs.analyzeVoice; exports.borrowedSource = _chunkKQN2ZYNDcjs.borrowedSource; exports.chordTimelineFromChords = _chunk4VZ5MZAMcjs.chordTimelineFromChords; exports.chordTimelineFromNotes = _chunk4VZ5MZAMcjs.chordTimelineFromNotes; exports.chordToRoman = _chunkKQN2ZYNDcjs.chordToRoman; exports.detectCadence = _chunkKQN2ZYNDcjs.detectCadence; exports.detectCadences = _chunk4VZ5MZAMcjs.detectCadences; exports.detectChord = _chunkKQN2ZYNDcjs.detectChord; exports.detectChordBest = _chunkKQN2ZYNDcjs.detectChordBest; exports.detectKey = _chunkKQN2ZYNDcjs.detectKey; exports.detectKeyBest = _chunkKQN2ZYNDcjs.detectKeyBest; exports.detectKeyFromNotes = _chunkKQN2ZYNDcjs.detectKeyFromNotes; exports.functionOf = _chunkKQN2ZYNDcjs.functionOf; exports.isBorrowedChord = _chunkKQN2ZYNDcjs.isBorrowedChord; exports.isDiatonic = _chunkKQN2ZYNDcjs.isDiatonic; exports.isMinorKey = _chunkKQN2ZYNDcjs.isMinorKey; exports.parallelKey = _chunkKQN2ZYNDcjs.parallelKey; exports.romanToChord = _chunkKQN2ZYNDcjs.romanToChord; exports.secondaryDominant = _chunkKQN2ZYNDcjs.secondaryDominant; exports.tensionCurve = _chunk4VZ5MZAMcjs.tensionCurve; exports.tensionCurveFrom = _chunk4VZ5MZAMcjs.tensionCurveFrom; exports.toVoiceNotes = _chunk4VZ5MZAMcjs.toVoiceNotes;
 //# sourceMappingURL=index.cjs.map