@libraz/libcantus 0.9.5 → 1.0.0

package/dist/chunk-YUE6TJ4M.js

@@ -1,889 +0,0 @@
-import {
-  beatsPerBar,
-  createNoteEventIndex,
-  isStrongBeat,
-  metricWeight,
-  parseTimeSignature
-} from "./chunk-2PTFGVD7.js";
-import {
-  detectCadence,
-  detectChord,
-  detectKeyFromNotes,
-  functionOf
-} from "./chunk-NNB67XA2.js";
-import {
-  evaluateSafety
-} from "./chunk-DZMHIGI4.js";
-import {
-  chordPitchClasses,
-  chordToneRole,
-  createsVerticalDissonance,
-  intervalAboveRoot,
-  isChordMember,
-  isLeadingToneResolution,
-  isScaleTone,
-  majorKey,
-  makeChord
-} from "./chunk-KBTTEX7Q.js";
-import {
-  InvalidInputError,
-  assertFiniteNumber,
-  assertGenerationBudget,
-  assertNoteEvents,
-  assertRange,
-  assertTimeSignature,
-  pitchClassOf
-} from "./chunk-R2VVFAIN.js";
-
-// 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");
-    let low = 0;
-    let high = segments.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if ((segments[middle]?.startBeat ?? Number.POSITIVE_INFINITY) <= beat) {
-        low = middle + 1;
-      } else {
-        high = middle;
-      }
-    }
-    const candidate = segments[low - 1];
-    return candidate !== void 0 && beat >= candidate.startBeat && beat < candidate.endBeat ? candidate.chord : null;
-  };
-}
-var EPS = 1e-9;
-var NOISE_THRESHOLD_RATIO = 0.2;
-var MAX_DETECTION_PCS = 6;
-var INEXACT_CONFIDENCE_FACTOR = 0.85;
-var DIATONIC_BONUS = 0.5;
-var EXACT_BONUS = 0.5;
-var MISMATCH_PENALTY = 0.3;
-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 <= EPS) {
-      continue;
-    }
-    const velocityFactor = note.velocity !== void 0 ? note.velocity / 127 : 1;
-    const onsetInWindow = note.startBeat >= windowStart - EPS && note.startBeat < windowEnd - EPS;
-    const accent = onsetInWindow ? 1 + metricWeight(note.startBeat, ts) / 3 : 1;
-    const pc = pitchClassOf(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 <= EPS) {
-    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 = pitchClassOf(lowestPitch);
-  const hasBass = selected.includes(bassPc);
-  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
-  const matches = detectChord(detectionPitches, { input: hasBass ? "midi" : "pitchClass" });
-  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) };
-  }
-  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");
-  const budget = opts.budget;
-  assertNoteEvents(notes, "timeline notes", { allowNonPositiveDuration: true, budget });
-  const soundingIndex = createNoteEventIndex(
-    notes.filter((note) => note.durationBeat > 0),
-    { name: "timeline notes", budget }
-  );
-  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 ?? detectKeyFromNotes(sounding, { budget })[0]?.key ?? majorKey(0);
-  const segments = [];
-  const segmentConfidence = [];
-  const windowCount = Math.max(0, Math.ceil(totalBeats / harmonicRhythm - EPS));
-  assertGenerationBudget(windowCount, "timeline windows", budget);
-  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", budget);
-    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) < EPS) {
-      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) > EPS) {
-      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 EPS2 = 1e-9;
-var MAX_LANE_LEAP = 24;
-function covers(note, beat) {
-  return beat >= note.startBeat - EPS2 && beat < note.endBeat - EPS2;
-}
-function isPercussion(role) {
-  return role === "drums";
-}
-function poolNotes(tracks, only) {
-  const notes = [];
-  for (let index = 0; index < tracks.length; index += 1) {
-    const track = tracks[index];
-    if (track === void 0 || isPercussion(track.role)) {
-      continue;
-    }
-    if (only !== void 0 && !only.has(index)) {
-      continue;
-    }
-    for (const note of track.notes) {
-      if (note.durationBeat > 0) {
-        notes.push(note);
-      }
-    }
-  }
-  return notes;
-}
-function splitIntoSubVoices(ordered) {
-  const lanes = [];
-  const attachNearest = (note, excluded = /* @__PURE__ */ new Set()) => {
-    let best = -1;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    let bestEnd = Number.NEGATIVE_INFINITY;
-    for (let lane = 0; lane < lanes.length; lane += 1) {
-      if (excluded.has(lane)) {
-        continue;
-      }
-      const last = lanes[lane]?.[(lanes[lane]?.length ?? 0) - 1];
-      if (last === void 0) {
-        continue;
-      }
-      const end = last.startBeat + last.durationBeat;
-      if (end > note.startBeat + EPS2) {
-        continue;
-      }
-      const distance = Math.abs(last.pitch - note.pitch);
-      if (distance > MAX_LANE_LEAP) {
-        continue;
-      }
-      if (distance < bestDistance || distance === bestDistance && end > bestEnd) {
-        best = lane;
-        bestDistance = distance;
-        bestEnd = end;
-      }
-    }
-    if (best >= 0) {
-      lanes[best]?.push(note);
-      return true;
-    }
-    return false;
-  };
-  for (let start = 0; start < ordered.length; ) {
-    const onset = ordered[start]?.startBeat ?? 0;
-    let end = start + 1;
-    while (end < ordered.length && Math.abs((ordered[end]?.startBeat ?? 0) - onset) <= EPS2) {
-      end += 1;
-    }
-    const block = ordered.slice(start, end);
-    if (block.length > 1) {
-      const freeLanes = lanes.map((lane, index) => ({ index, last: lane[lane.length - 1] })).filter(
-        (entry) => entry.last !== void 0 && entry.last.startBeat + entry.last.durationBeat <= onset + EPS2
-      ).sort((a, b) => a.last.pitch - b.last.pitch);
-      const paired = /* @__PURE__ */ new Set();
-      for (let index = 0; index < block.length; index += 1) {
-        const note = block[index];
-        const lane = freeLanes[index];
-        if (note !== void 0 && lane !== void 0 && Math.abs(lane.last.pitch - note.pitch) <= MAX_LANE_LEAP) {
-          lanes[lane.index]?.push(note);
-          paired.add(lane.index);
-        } else if (note !== void 0 && !attachNearest(note, paired)) {
-          lanes.push([note]);
-        }
-      }
-    } else {
-      const note = block[0];
-      if (note !== void 0 && !attachNearest(note)) {
-        lanes.push([note]);
-      }
-    }
-    start = end;
-  }
-  return lanes;
-}
-function lastStartingAtOrBefore(sounding, beat) {
-  let low = 0;
-  let high = sounding.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((sounding[middle]?.startBeat ?? Number.POSITIVE_INFINITY) <= beat + EPS2) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low - 1;
-}
-function prepareTracks(tracks) {
-  let nextId = 0;
-  return tracks.map((track, index) => {
-    const ordered = track.notes.map((note, originalIndex) => ({ note, originalIndex })).filter(({ note }) => note.durationBeat > 0).sort((a, b) => a.note.startBeat - b.note.startBeat || a.note.pitch - b.note.pitch).map(({ note, originalIndex }) => ({ ...note, id: nextId++, originalIndex }));
-    const voices = splitIntoSubVoices(ordered).map((voice) => {
-      const 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) <= EPS2;
-        return {
-          pitch: note.pitch,
-          prevPitch: contiguous ? prev?.pitch : void 0,
-          startBeat: note.startBeat,
-          endBeat: note.startBeat + note.durationBeat
-        };
-      });
-      return {
-        voice,
-        sounding,
-        at: (beat) => {
-          const candidate = sounding[lastStartingAtOrBefore(sounding, beat)];
-          return candidate !== void 0 && covers(candidate, beat) ? candidate : void 0;
-        }
-      };
-    });
-    return {
-      name: track.name ?? `track ${index + 1}`,
-      role: track.role ?? "other",
-      trackIndex: index,
-      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 clamp01(value) {
-  return Math.min(1, Math.max(0, value));
-}
-function tensionCurve(tracks, opts = {}) {
-  const ts = opts.ts ?? parseTimeSignature("4/4");
-  assertTimeSignature(ts);
-  const budget = opts.budget;
-  assertGenerationBudget(tracks.length, "arrangement tracks", budget);
-  for (let index = 0; index < tracks.length; index += 1) {
-    assertNoteEvents(tracks[index]?.notes ?? [], `tracks[${index}].notes`, {
-      allowNonPositiveDuration: true,
-      budget
-    });
-  }
-  const profile = opts.profile ?? "pop";
-  const step = opts.step ?? 1;
-  assertRange(step, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "tension sampling step");
-  const harmonyTracks = opts.harmonyTracks === void 0 ? void 0 : new Set(opts.harmonyTracks.map(Math.trunc));
-  const pooled = poolNotes(tracks, harmonyTracks);
-  const totalBeats = poolNotes(tracks).reduce(
-    (end, n) => Math.max(end, n.startBeat + n.durationBeat),
-    0
-  );
-  const { timeline, key } = opts.timeline === void 0 ? chordTimelineFromNotes(pooled, {
-    key: opts.key,
-    ts,
-    harmonicRhythm: opts.harmonicRhythm,
-    budget
-  }) : {
-    timeline: opts.timeline,
-    key: opts.key ?? detectKeyFromNotes(pooled, { budget })[0]?.key ?? majorKey(0)
-  };
-  const prepared = prepareTracks(tracks);
-  const points = [];
-  const sampleCount = Math.max(0, Math.ceil(totalBeats / step - EPS2));
-  assertGenerationBudget(sampleCount, "tension samples", budget);
-  const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
-  assertGenerationBudget(
-    sampleCount * Math.min(128, voiceCount) * voiceCount,
-    "tension sample-voice comparisons",
-    budget
-  );
-  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 tensionCurveFrom(tracks, analysis, opts = {}) {
-  return tensionCurve(tracks, { ...opts, timeline: analysis.timeline, key: analysis.key });
-}
-function allSounding(prepared, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track || isPercussion(track.role)) {
-      continue;
-    }
-    for (const subVoice of track.voices) {
-      const note = subVoice.at(beat);
-      if (note !== void 0) {
-        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;
-  const pitches = /* @__PURE__ */ new Map();
-  for (const voice of sounding) {
-    pitches.set(voice.pitch, (pitches.get(voice.pitch) ?? 0) + 1);
-  }
-  for (const [pitch, count] of pitches) {
-    if (chordPcs && !chordPcs.has(pitchClassOf(pitch))) {
-      nonChord += count;
-    }
-    const others = [...pitches].flatMap(
-      ([otherPitch, otherCount]) => Array.from({ length: otherCount - (otherPitch === pitch ? 1 : 0) }, () => ({
-        pitch: otherPitch
-      }))
-    );
-    const result = evaluateSafety(
-      {
-        profile,
-        candidatePitch: pitch,
-        chord,
-        key,
-        otherVoices: others,
-        strongBeat
-      },
-      { suggestions: false }
-    );
-    if (result.safety === 2 /* Dissonant */) {
-      dissonant += count;
-    }
-  }
-  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
-function toVoiceNotes(events) {
-  return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
-}
-var HUMANIZE_ADJACENCY = 0.05;
-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 ((pitchClassOf(pitch) - pitchClassOf(ref)) % 12 + 12) % 12;
-}
-function tensionDegree(ic) {
-  if (ic === 1 || ic === 2) {
-    return 9;
-  }
-  if (ic === 5 || ic === 6) {
-    return 11;
-  }
-  return 13;
-}
-function isStep(a, b) {
-  const d = Math.abs(a - b);
-  return d === 1 || d === 2;
-}
-function suspensionType(ic, delta) {
-  if (delta > 0) {
-    return "sus2-3";
-  }
-  if (ic === 2) {
-    return "sus9-8";
-  }
-  if (ic === 10 || ic === 11) {
-    return "sus7-6";
-  }
-  if (ic === 5 || ic === 6) {
-    return "sus4-3";
-  }
-  if (ic === 8 || ic === 9) {
-    return "sus6-5";
-  }
-  return null;
-}
-function stepResolution(pitch, chord) {
-  for (let delta = 1; delta <= 2; delta += 1) {
-    if (isChordMember(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) <= HUMANIZE_ADJACENCY ? prevNote : void 0;
-    const next = nextNote !== void 0 && Math.abs(noteEnd - nextNote.startBeat) <= HUMANIZE_ADJACENCY ? nextNote : void 0;
-    const chord = chordAtBeat(note.startBeat);
-    const labels = [];
-    const member = isChordMember(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 = intervalAboveRoot(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 && isChordMember(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 type = suspensionType(ic, next.pitch - note.pitch);
-        if (type !== null) {
-          labels.push({ kind: "suspension", type, resolveTo: next.pitch });
-          handled = true;
-        }
-      }
-    }
-    if (!handled && chord && prev && next) {
-      const prevMember = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = isChordMember(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 && isChordMember(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 (isChordMember(next.pitch, nextChord)) {
-        labels.push({ kind: "anticipation" });
-        handled = true;
-      }
-    }
-    if (!handled && chord && prev && next && !member) {
-      const prevMember = isChordMember(prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = isChordMember(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 = intervalAboveRoot(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 = stepResolution(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 = stepResolution(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 });
-    }
-    const analyzed = {
-      noteId: note.id ?? i,
-      pitch: note.pitch,
-      startBeat: note.startBeat,
-      durationBeat: note.durationBeat,
-      labels,
-      rationale: describe(labels)
-    };
-    if (note.originalIndex !== void 0) {
-      analyzed.originalIndex = note.originalIndex;
-    }
-    result.push(analyzed);
-  }
-  return result;
-}
-function describe(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 soundingVoicesAt(prepared, beat) {
-  const out = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track || isPercussion(track.role)) {
-      continue;
-    }
-    for (let v = 0; v < track.voices.length; v += 1) {
-      const note = track.voices[v]?.at(beat);
-      if (note === void 0) {
-        continue;
-      }
-      const snap = { pitch: note.pitch };
-      const previous = Math.abs(note.startBeat - beat) <= EPS2 ? note.prevPitch : note.pitch;
-      if (previous !== void 0) {
-        snap.prevPitch = previous;
-      }
-      out.push({ track: t, voice: v, snapshot: snap });
-    }
-  }
-  return out;
-}
-function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat, cache) {
-  const sounding = cache.get(beat) ?? soundingVoicesAt(prepared, beat);
-  cache.set(beat, sounding);
-  return sounding.filter(({ track, voice }) => track !== excludeTrack || voice !== excludeVoice).map(({ snapshot }) => snapshot);
-}
-function firstSegmentAfter(timeline, beat) {
-  let low = 0;
-  let high = timeline.segments.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((timeline.segments[middle]?.startBeat ?? Number.POSITIVE_INFINITY) <= beat + EPS2) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low;
-}
-function evaluationBeats(note, timeline) {
-  const noteEnd = note.startBeat + note.durationBeat;
-  const beats = [note.startBeat];
-  for (let i = firstSegmentAfter(timeline, note.startBeat); i < timeline.segments.length; i += 1) {
-    const start = timeline.segments[i]?.startBeat;
-    if (start === void 0 || start >= noteEnd - EPS2) {
-      break;
-    }
-    beats.push(start);
-  }
-  return beats;
-}
-function analyzeArrangement(tracks, opts = {}) {
-  const ts = opts.ts ?? parseTimeSignature("4/4");
-  assertTimeSignature(ts);
-  const budget = opts.budget;
-  assertGenerationBudget(tracks.length, "arrangement tracks", budget);
-  let noteCount = 0;
-  for (let index = 0; index < tracks.length; index += 1) {
-    const notes = tracks[index]?.notes;
-    if (!Array.isArray(notes)) {
-      throw new InvalidInputError(
-        `tracks[${index}].notes must be an array; received ${typeof notes}`
-      );
-    }
-    assertNoteEvents(notes, `tracks[${index}].notes`, {
-      allowNonPositiveDuration: true,
-      budget
-    });
-    noteCount += notes.length;
-  }
-  assertGenerationBudget(noteCount, "arrangement notes", budget);
-  const profile = opts.profile ?? "pop";
-  const minSeverity = opts.minSeverity ?? 1 /* Warning */;
-  const harmonyTracks = opts.harmonyTracks === void 0 ? void 0 : new Set(opts.harmonyTracks.map(Math.trunc));
-  const pooled = poolNotes(tracks, harmonyTracks);
-  const inferred = opts.timeline === void 0 ? chordTimelineFromNotes(pooled, {
-    key: opts.key,
-    ts,
-    harmonicRhythm: opts.harmonicRhythm,
-    budget
-  }) : {
-    timeline: opts.timeline,
-    key: opts.key ?? detectKeyFromNotes(pooled, { budget })[0]?.key ?? majorKey(0),
-    // A caller-provided timeline was not inferred from these notes, so
-    // it has no measured confidence. Reporting 1 would turn confidence
-    // gates into unconditional passes.
-    segmentConfidence: opts.timeline.segments.map(() => 0)
-  };
-  const { timeline, key, segmentConfidence } = inferred;
-  const cadences = detectCadences(timeline, key);
-  const prepared = prepareTracks(tracks);
-  const soundingCache = /* @__PURE__ */ new Map();
-  const trackAnalyses = [];
-  const conflicts = [];
-  for (let t = 0; t < prepared.length; t += 1) {
-    const track = prepared[t];
-    if (!track) {
-      continue;
-    }
-    if (isPercussion(track.role)) {
-      trackAnalyses.push({ name: track.name, role: track.role, notes: [] });
-      continue;
-    }
-    const notes = [];
-    for (let v = 0; v < track.voices.length; v += 1) {
-      const subVoice = track.voices[v];
-      if (!subVoice) {
-        continue;
-      }
-      const analyzed = analyzeVoice(
-        subVoice.voice,
-        timeline.at,
-        key,
-        (beat) => otherVoicesSounding(prepared, t, v, beat, soundingCache)
-      );
-      notes.push(...analyzed.map((note) => ({ ...note, trackIndex: track.trackIndex })));
-      const labelsById = new Map(analyzed.map((note) => [note.noteId, note.labels]));
-      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) <= EPS2;
-          const safetyQuery = {
-            profile,
-            candidatePitch: note.pitch,
-            prevPitch: atOnset ? preparedNote.prevPitch : note.pitch,
-            chord: timeline.at(beat),
-            key,
-            otherVoices: otherVoicesSounding(prepared, t, v, beat, soundingCache),
-            strongBeat: isStrongBeat(beat, ts)
-          };
-          let result = evaluateSafety(safetyQuery, { suggestions: false });
-          if (result.safety !== 0 /* Safe */ && result.safety >= minSeverity) {
-            result = evaluateSafety(safetyQuery);
-            const conflict = {
-              beat,
-              trackName: track.name,
-              trackIndex: track.trackIndex,
-              noteId: note.id,
-              pitch: note.pitch,
-              labels: labelsById.get(note.id) ?? [],
-              safety: result.safety,
-              reasons: result.reasons
-            };
-            if (note.originalIndex !== void 0) {
-              conflict.originalIndex = note.originalIndex;
-            }
-            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 };
-}
-
-export {
-  chordTimelineFromChords,
-  chordTimelineFromNotes,
-  detectCadences,
-  tensionCurve,
-  tensionCurveFrom,
-  toVoiceNotes,
-  analyzeVoice,
-  analyzeArrangement
-};
-//# sourceMappingURL=chunk-YUE6TJ4M.js.map