@libraz/libcantus 0.9.0 → 0.9.2

package/dist/chunk-5HTNMQW4.js

@@ -0,0 +1,653 @@
+import {
+  beatsPerBar,
+  isStrongBeat,
+  metricWeight,
+  parseTimeSignature
+} from "./chunk-MSWFZF7J.js";
+import {
+  detectCadence,
+  detectChord,
+  detectChordBest,
+  detectKey,
+  functionOf
+} from "./chunk-LN7ZZMD2.js";
+import {
+  evaluateSafety
+} from "./chunk-A4532ZFR.js";
+import {
+  chordPitchClasses,
+  chordToneRole,
+  createsVerticalDissonance,
+  isLeadingToneResolution,
+  isScaleTone,
+  majorKey,
+  makeChord
+} from "./chunk-7Y7WF64D.js";
+
+// src/analyze/timeline/index.ts
+function chordTimelineFromChords(chords, totalBeats) {
+  const sorted = [...chords].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);
+    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) => {
+    for (const seg of segments) {
+      if (beat >= seg.startBeat && beat < seg.endBeat) {
+        return seg.chord;
+      }
+    }
+    return 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));
+  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 = pitchClass(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 = 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);
+  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");
+  const harmonicRhythm = opts.harmonicRhythm ?? beatsPerBar(ts);
+  if (!(harmonicRhythm > 0)) {
+    throw new Error(`Invalid harmonic rhythm: ${harmonicRhythm}`);
+  }
+  const sounding = notes.filter((note) => note.durationBeat > 0);
+  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);
+  const segments = [];
+  const segmentConfidence = [];
+  const windowCount = Math.max(0, Math.ceil(totalBeats / harmonicRhythm - EPS));
+  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);
+    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;
+function covers(note, beat) {
+  return beat >= note.startBeat - EPS2 && beat < note.endBeat - EPS2;
+}
+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 + EPS2;
+    });
+    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;
+        return {
+          pitch: note.pitch,
+          prevPitch: prev?.pitch,
+          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 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");
+  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, {
+    key: opts.key,
+    ts,
+    harmonicRhythm: opts.harmonicRhythm
+  });
+  const prepared = prepareTracks(tracks);
+  const points = [];
+  const sampleCount = Math.max(0, Math.ceil(totalBeats / step - EPS2));
+  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(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
+    });
+    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 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 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 ((pitchClass3(pitch) - pitchClass3(ref)) % 12 + 12) % 12;
+}
+function tensionDegree(ic) {
+  if (ic === 1 || ic === 2) {
+    return 9;
+  }
+  if (ic === 5 || ic === 6) {
+    return 11;
+  }
+  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 };
+}
+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) {
+  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 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 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 sus = suspensionType(ic, next.pitch - note.pitch);
+        sus.resolveTo = next.pitch;
+        labels.push(sus);
+        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 });
+    }
+    result.push({ noteId: note.id, labels, rationale: describe(labels) });
+  }
+  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 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 };
+        if (note.prevPitch !== void 0) {
+          snap.prevPitch = note.prevPitch;
+        }
+        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 + EPS2 && segment.startBeat < noteEnd - EPS2) {
+      beats.push(segment.startBeat);
+    }
+  }
+  return beats;
+}
+function analyzeArrangement(tracks, opts = {}) {
+  const ts = opts.ts ?? parseTimeSignature("4/4");
+  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 (const note of subVoice.voice) {
+        for (const beat of evaluationBeats(note, timeline)) {
+          const result = evaluateSafety({
+            profile,
+            candidatePitch: 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;
+            }
+            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,
+  analyzeVoice,
+  analyzeArrangement
+};
+//# sourceMappingURL=chunk-5HTNMQW4.js.map