@libraz/libcantus 0.9.2 → 0.9.4

package/dist/{chunk-5HTNMQW4.js → chunk-Q2XUP227.js}

@@ -1,35 +1,58 @@
 import {
   beatsPerBar,
+  createNoteEventIndex,
   isStrongBeat,
   metricWeight,
   parseTimeSignature
-} from "./chunk-MSWFZF7J.js";
+} from "./chunk-YLEMGEFH.js";
 import {
   detectCadence,
   detectChord,
   detectChordBest,
-  detectKey,
+  detectKeyFromNotes,
   functionOf
-} from "./chunk-LN7ZZMD2.js";
+} from "./chunk-KMHOICIY.js";
 import {
   evaluateSafety
-} from "./chunk-A4532ZFR.js";
+} from "./chunk-NYYWMV2C.js";
 import {
   chordPitchClasses,
   chordToneRole,
   createsVerticalDissonance,
+  intervalAboveRoot,
+  isChordMember,
   isLeadingToneResolution,
   isScaleTone,
   majorKey,
   makeChord
-} from "./chunk-7Y7WF64D.js";
+} from "./chunk-D2FAJBYL.js";
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  assertGenerationBudget,
+  assertNoteEvents,
+  assertRange,
+  assertTimeSignature,
+  pitchClassOf
+} from "./chunk-XEBG3G53.js";
 
 // src/analyze/timeline/index.ts
 function chordTimelineFromChords(chords, totalBeats) {
-  const sorted = [...chords].sort((a, b) => a.startBeat - b.startBeat);
+  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 endBeat = Math.max(gc.startBeat, next ? next.startBeat : totalBeats);
+    const nextBeat = next ? next.startBeat : totalBeats;
+    const endBeat = Math.min(totalBeats, Math.max(gc.startBeat, nextBeat));
     return {
       startBeat: gc.startBeat,
       endBeat,
@@ -40,12 +63,19 @@ function chordTimelineFromChords(chords, totalBeats) {
 }
 function segmentLookup(segments) {
   return (beat) => {
-    for (const seg of segments) {
-      if (beat >= seg.startBeat && beat < seg.endBeat) {
-        return seg.chord;
+    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;
       }
     }
-    return null;
+    const candidate = segments[low - 1];
+    return candidate !== void 0 && beat >= candidate.startBeat && beat < candidate.endBeat ? candidate.chord : null;
   };
 }
 var EPS = 1e-9;
@@ -56,9 +86,6 @@ 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));
@@ -96,7 +123,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;
@@ -113,7 +140,7 @@ 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 bassPc = pitchClassOf(lowestPitch);
   const anchorPc = selected.includes(bassPc) ? bassPc : selected[0] ?? bassPc;
   const detectionPitches = selected.map((pc) => pc === anchorPc ? pc : pc + 12);
   const matches = detectChord(detectionPitches);
@@ -141,21 +168,39 @@ function sameChord(a, b) {
 }
 function chordTimelineFromNotes(notes, opts = {}) {
   const ts = opts.ts ?? parseTimeSignature("4/4");
+  assertTimeSignature(ts);
   const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBar(ts);
-  if (!(harmonicRhythm > 0)) {
-    throw new Error(`Invalid harmonic rhythm: ${harmonicRhythm}`);
-  }
-  const sounding = notes.filter((note) => note.durationBeat > 0);
+  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;
-  const key = opts.key ?? detectKey(sounding.map((n) => n.pitch))[0]?.key ?? majorKey(0);
+  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  const key = opts.key ?? detectKeyFromNotes(sounding)[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(sounding, start, end, ts, key);
+    const inferred = analyzeWindow(windowNotes[i] ?? [], start, end, ts, key);
     if (!inferred) {
       continue;
     }
@@ -198,12 +243,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);
@@ -215,37 +271,78 @@ 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);
+    let best = -1;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    let bestEnd = Number.NEGATIVE_INFINITY;
+    for (let lane = 0; lane < lanes.length; lane += 1) {
+      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);
     } else {
       lanes.push([note]);
     }
   }
   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;
         return {
           pitch: note.pitch,
-          prevPitch: prev?.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
     };
   });
@@ -261,47 +358,64 @@ 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);
+  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;
-  if (!(step > 0)) {
-    throw new Error(`Invalid tension sampling step: ${step}`);
-  }
-  const pooled = poolNotes(tracks);
-  const totalBeats = pooled.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), 0);
-  const { timeline, key } = chordTimelineFromNotes(pooled, {
+  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
-  });
+    harmonicRhythm: opts.harmonicRhythm,
+    budget
+  }) : {
+    timeline: opts.timeline,
+    key: opts.key ?? detectKeyFromNotes(pooled)[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 * voiceCount, "tension sample-voice lookups", 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 });
       }
     }
   }
@@ -323,18 +437,21 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
     if (!voice) {
       continue;
     }
-    if (chordPcs && !chordPcs.has(pitchClass2(voice.pitch))) {
+    if (chordPcs && !chordPcs.has(pitchClassOf(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 result = evaluateSafety(
+      {
+        profile,
+        candidatePitch: voice.pitch,
+        chord,
+        key,
+        otherVoices: others,
+        strongBeat
+      },
+      { suggestions: false }
+    );
     if (result.safety === 2 /* Dissonant */) {
       dissonant += 1;
     }
@@ -353,13 +470,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 EPS3 = 1e-9;
 function intervalAboveBass(pitch, others, chord) {
   let bass = Number.POSITIVE_INFINITY;
   for (const ov of others) {
@@ -369,7 +483,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) {
@@ -380,25 +494,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 { kind: "suspension", type, resolveTo: 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) {
@@ -408,7 +524,8 @@ 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) {
     const note = voice[i];
@@ -417,8 +534,10 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat) {
     }
     const prevNote = i > 0 ? voice[i - 1] : void 0;
     const nextNote = i + 1 < voice.length ? voice[i + 1] : void 0;
-    const prev = prevNote !== void 0 && prevNote.startBeat < note.startBeat - EPS3 ? prevNote : void 0;
-    const next = nextNote !== void 0 && nextNote.startBeat > note.startBeat + EPS3 ? nextNote : 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 chord = chordAtBeat(note.startBeat);
     const labels = [];
     const member = isChordMember(note.pitch, chord);
@@ -443,10 +562,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) {
@@ -504,7 +624,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;
 }
@@ -542,50 +673,86 @@ function otherVoicesSounding(prepared, excludeTrack, excludeVoice, 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) {
         continue;
       }
-      const subVoice = track.voices[v];
-      if (!subVoice) {
+      const note = track.voices[v]?.at(beat);
+      if (note === void 0) {
         continue;
       }
-      for (const note of subVoice.sounding) {
-        if (!covers(note, beat)) {
-          continue;
-        }
-        const snap = { pitch: note.pitch };
-        if (note.prevPitch !== void 0) {
-          snap.prevPitch = note.prevPitch;
-        }
-        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(snap);
     }
   }
   return out;
 }
+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);
+  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 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
-  });
+  }) : {
+    timeline: opts.timeline,
+    key: opts.key ?? detectKeyFromNotes(pooled)[0]?.key ?? majorKey(0),
+    segmentConfidence: opts.timeline.segments.map(() => 1)
+  };
+  const { timeline, key, segmentConfidence } = inferred;
   const cadences = detectCadences(timeline, key);
   const prepared = prepareTracks(tracks);
   const trackAnalyses = [];
@@ -595,41 +762,64 @@ 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)
       );
-      for (const note of subVoice.voice) {
+      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 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 */) {
+          if (result.safety !== 0 /* Safe */ && result.safety >= minSeverity) {
             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);
           }
         }
@@ -647,7 +837,9 @@ export {
   chordTimelineFromNotes,
   detectCadences,
   tensionCurve,
+  tensionCurveFrom,
+  toVoiceNotes,
   analyzeVoice,
   analyzeArrangement
 };
-//# sourceMappingURL=chunk-5HTNMQW4.js.map
+//# sourceMappingURL=chunk-Q2XUP227.js.map