@libraz/libcantus 0.9.3 → 0.9.5

package/dist/{chunk-GOAW4VYL.js → chunk-YUE6TJ4M.js}

@@ -4,33 +4,36 @@ import {
   isStrongBeat,
   metricWeight,
   parseTimeSignature
-} from "./chunk-I5R7ZBJS.js";
+} from "./chunk-2PTFGVD7.js";
 import {
   detectCadence,
   detectChord,
-  detectChordBest,
-  detectKey,
+  detectKeyFromNotes,
   functionOf
-} from "./chunk-CHMXELDS.js";
+} from "./chunk-NNB67XA2.js";
 import {
   evaluateSafety
-} from "./chunk-EH6EM37U.js";
+} from "./chunk-DZMHIGI4.js";
 import {
   chordPitchClasses,
   chordToneRole,
   createsVerticalDissonance,
+  intervalAboveRoot,
+  isChordMember,
   isLeadingToneResolution,
   isScaleTone,
   majorKey,
   makeChord
-} from "./chunk-MIWO425M.js";
+} from "./chunk-KBTTEX7Q.js";
 import {
+  InvalidInputError,
   assertFiniteNumber,
   assertGenerationBudget,
   assertNoteEvents,
   assertRange,
-  assertTimeSignature
-} from "./chunk-FBQK3ZQN.js";
+  assertTimeSignature,
+  pitchClassOf
+} from "./chunk-R2VVFAIN.js";
 
 // src/analyze/timeline/index.ts
 function chordTimelineFromChords(chords, totalBeats) {
@@ -60,25 +63,27 @@ function chordTimelineFromChords(chords, totalBeats) {
 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;
+    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;
       }
     }
-    return null;
+    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 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 pitchClass(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));
@@ -116,7 +121,7 @@ function analyzeWindow(notes, windowStart, windowEnd, ts, key) {
     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 = pitchClass(note.pitch);
+    const pc = pitchClassOf(note.pitch);
     weights[pc] = (weights[pc] ?? 0) + overlap * velocityFactor * accent;
     if (note.pitch < lowestPitch) {
       lowestPitch = note.pitch;
@@ -133,10 +138,10 @@ function analyzeWindow(notes, windowStart, windowEnd, ts, key) {
   }
   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 = pitchClass(lowestPitch);
-  const anchorPc = selected.includes(bassPc) ? bassPc : selected[0] ?? bassPc;
-  const detectionPitches = selected.map((pc) => pc === anchorPc ? pc : pc + 12);
-  const matches = detectChord(detectionPitches);
+  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) {
@@ -150,10 +155,6 @@ function analyzeWindow(notes, windowStart, windowEnd, ts, key) {
     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) {
@@ -164,24 +165,28 @@ function chordTimelineFromNotes(notes, opts = {}) {
   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 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 ?? detectKey(sounding.map((n) => n.pitch))[0]?.key ?? majorKey(0);
+  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");
+  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");
+    assertGenerationBudget(memberships, "timeline note-to-window memberships", budget);
     for (let window = first; window < lastExclusive; window += 1) {
       windowNotes[window]?.push(indexed.note);
     }
@@ -232,12 +237,23 @@ function detectCadences(timeline, key) {
 
 // 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 poolNotes(tracks) {
+function isPercussion(role) {
+  return role === "drums";
+}
+function poolNotes(tracks, only) {
   const notes = [];
-  for (const track of tracks) {
+  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);
@@ -248,26 +264,89 @@ function poolNotes(tracks) {
 }
 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 + EPS2;
-    });
-    if (lane) {
-      lane.push(note);
+  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 {
-      lanes.push([note]);
+      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.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 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;
@@ -277,11 +356,20 @@ function prepareTracks(tracks) {
           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
     };
   });
@@ -297,53 +385,68 @@ var FUNCTION_WEIGHT = 0.5;
 var DISSONANCE_WEIGHT = 0.35;
 var SPAN_WEIGHT = 0.15;
 var SPAN_SATURATION = 24;
-function pitchClass2(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");
+  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
+      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 pooled = poolNotes(tracks);
-  const totalBeats = pooled.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const { timeline, key } = chordTimelineFromNotes(pooled, {
+  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
-  });
+    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");
+  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) {
+    if (!track || isPercussion(track.role)) {
       continue;
     }
     for (const subVoice of track.voices) {
-      for (const note of subVoice.sounding) {
-        if (covers(note, beat)) {
-          out.push({ pitch: note.pitch, track: t });
-        }
+      const note = subVoice.at(beat);
+      if (note !== void 0) {
+        out.push({ pitch: note.pitch, track: t });
       }
     }
   }
@@ -360,25 +463,32 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
   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;
+  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;
     }
-    if (chordPcs && !chordPcs.has(pitchClass2(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
-    });
+    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 += 1;
+      dissonant += count;
     }
   }
   const dissonanceScore = Math.max(nonChord, dissonant) / sounding.length;
@@ -395,13 +505,10 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
 }
 
 // src/analyze/voice/index.ts
-var EPS3 = 1e-9;
-function pitchClass3(pitch) {
-  return (Math.trunc(pitch) % 12 + 12) % 12;
-}
-function intervalAboveRoot(pitch, chord) {
-  return ((pitchClass3(pitch) - pitchClass3(chord.rootPc)) % 12 + 12) % 12;
+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) {
@@ -411,7 +518,7 @@ function intervalAboveBass(pitch, others, chord) {
     return ((pitch - bass) % 12 + 12) % 12;
   }
   const ref = chord.bassPc ?? chord.rootPc;
-  return ((pitchClass3(pitch) - pitchClass3(ref)) % 12 + 12) % 12;
+  return ((pitchClassOf(pitch) - pitchClassOf(ref)) % 12 + 12) % 12;
 }
 function tensionDegree(ic) {
   if (ic === 1 || ic === 2) {
@@ -422,25 +529,27 @@ function tensionDegree(ic) {
   }
   return 13;
 }
-function isChordMember(pitch, chord) {
-  return chord ? chordPitchClasses(chord).includes(pitchClass3(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 "sus2-3";
+  }
+  if (ic === 2) {
+    return "sus9-8";
   }
-  return { kind: "suspension", type, resolveTo: 0 };
+  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) {
@@ -450,7 +559,7 @@ function stepResolution(pitch, chord) {
   }
   return void 0;
 }
-function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
+function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
   assertNoteEvents(voice, "voice notes", { allowNonPositiveDuration: true });
   const result = [];
   for (let i = 0; i < voice.length; i += 1) {
@@ -462,8 +571,8 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
     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) <= EPS3 ? prevNote : void 0;
-    const next = nextNote !== void 0 && Math.abs(noteEnd - nextNote.startBeat) <= EPS3 ? nextNote : void 0;
+    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);
@@ -488,10 +597,11 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
       );
       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;
+        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) {
@@ -549,7 +659,18 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
     if (next && isLeadingToneResolution(note.pitch, next.pitch, key)) {
       labels.push({ kind: "leadingTone", resolveTo: next.pitch });
     }
-    result.push({ noteId: note.id, labels, rationale: describe(labels) });
+    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;
 }
@@ -583,64 +704,99 @@ function describe(labels) {
 }
 
 // src/analyze/arrange/tracks.ts
-function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat) {
+function soundingVoicesAt(prepared, beat) {
   const out = [];
   for (let t = 0; t < prepared.length; t += 1) {
     const track = prepared[t];
-    if (!track) {
+    if (!track || isPercussion(track.role)) {
       continue;
     }
     for (let v = 0; v < track.voices.length; v += 1) {
-      if (t === excludeTrack && v === excludeVoice) {
+      const note = track.voices[v]?.at(beat);
+      if (note === void 0) {
         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) <= EPS2 ? note.prevPitch : note.pitch;
-        if (previous !== void 0) {
-          snap.prevPitch = previous;
-        }
-        out.push(snap);
+      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 (const segment of timeline.segments) {
-    if (segment.startBeat > note.startBeat + EPS2 && segment.startBeat < noteEnd - EPS2) {
-      beats.push(segment.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);
-  assertGenerationBudget(tracks.length, "arrangement tracks");
+  const budget = opts.budget;
+  assertGenerationBudget(tracks.length, "arrangement tracks", budget);
+  let noteCount = 0;
   for (let index = 0; index < tracks.length; index += 1) {
-    assertNoteEvents(tracks[index]?.notes ?? [], `tracks[${index}].notes`, {
-      allowNonPositiveDuration: true
+    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 pooled = poolNotes(tracks);
-  const { timeline, key, segmentConfidence } = chordTimelineFromNotes(pooled, {
+  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
-  });
+    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) {
@@ -648,20 +804,24 @@ function analyzeArrangement(tracks, opts = {}) {
     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;
       }
-      notes.push(
-        ...analyzeVoice(
-          subVoice.voice,
-          timeline.at,
-          key,
-          (beat) => otherVoicesSounding(prepared, t, v, beat)
-        )
+      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];
@@ -670,23 +830,31 @@ function analyzeArrangement(tracks, opts = {}) {
         }
         for (const beat of evaluationBeats(note, timeline)) {
           const atOnset = Math.abs(beat - note.startBeat) <= EPS2;
-          const result = evaluateSafety({
+          const safetyQuery = {
             profile,
             candidatePitch: note.pitch,
             prevPitch: atOnset ? preparedNote.prevPitch : note.pitch,
             chord: timeline.at(beat),
             key,
-            otherVoices: otherVoicesSounding(prepared, t, v, beat),
+            otherVoices: otherVoicesSounding(prepared, t, v, beat, soundingCache),
             strongBeat: isStrongBeat(beat, ts)
-          });
-          if (result.safety !== 0 /* Safe */) {
+          };
+          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;
             }
@@ -713,7 +881,9 @@ export {
   chordTimelineFromNotes,
   detectCadences,
   tensionCurve,
+  tensionCurveFrom,
+  toVoiceNotes,
   analyzeVoice,
   analyzeArrangement
 };
-//# sourceMappingURL=chunk-GOAW4VYL.js.map
+//# sourceMappingURL=chunk-YUE6TJ4M.js.map