@libraz/libcantus 0.9.3 → 0.9.5

package/dist/chunk-4VZ5MZAM.cjs

@@ -0,0 +1,889 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunk2A2QMA74cjs = require('./chunk-2A2QMA74.cjs');
+
+
+
+
+
+var _chunkKQN2ZYNDcjs = require('./chunk-KQN2ZYND.cjs');
+
+
+var _chunkWFDXOLUBcjs = require('./chunk-WFDXOLUB.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkBSLTLGM3cjs = require('./chunk-BSLTLGM3.cjs');
+
+
+
+
+
+
+
+
+var _chunkPI3UXRWKcjs = require('./chunk-PI3UXRWK.cjs');
+
+// src/analyze/timeline/index.ts
+function chordTimelineFromChords(chords, totalBeats) {
+  _chunkPI3UXRWKcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
+  for (let index = 0; index < chords.length; index += 1) {
+    _chunkPI3UXRWKcjs.assertRange.call(void 0, 
+      _nullishCoalesce(_optionalChain([chords, 'access', _ => _[index], 'optionalAccess', _2 => _2.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: _chunkBSLTLGM3cjs.makeChord.call(void 0, gc.rootPc, gc.quality, gc.bassPc)
+    };
+  }).filter((seg) => seg.endBeat > seg.startBeat);
+  return { at: segmentLookup(segments), segments };
+}
+function segmentLookup(segments) {
+  return (beat) => {
+    _chunkPI3UXRWKcjs.assertFiniteNumber.call(void 0, beat, "timeline query beat");
+    let low = 0;
+    let high = segments.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if ((_nullishCoalesce(_optionalChain([segments, 'access', _3 => _3[middle], 'optionalAccess', _4 => _4.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 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
+  const tones = _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, _chunkBSLTLGM3cjs.makeChord.call(void 0, match.rootPc, match.quality));
+  let score = rootWeight;
+  if (tones.every((pc) => _chunkBSLTLGM3cjs.isScaleTone.call(void 0, 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(_chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, chord));
+  let chordWeight = 0;
+  for (let pc = 0; pc < 12; pc += 1) {
+    if (tones.has(pc)) {
+      chordWeight += _nullishCoalesce(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 + _chunk2A2QMA74cjs.metricWeight.call(void 0, note.startBeat, ts) / 3 : 1;
+    const pc = _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, note.pitch);
+    weights[pc] = (_nullishCoalesce(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 = _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, lowestPitch);
+  const hasBass = selected.includes(bassPc);
+  const detectionPitches = hasBass ? selected.map((pc) => pc === bassPc ? pc : pc + 12) : selected;
+  const matches = _chunkKQN2ZYNDcjs.detectChord.call(void 0, 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 = _chunkBSLTLGM3cjs.makeChord.call(void 0, 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 = _nullishCoalesce(opts.ts, () => ( _chunk2A2QMA74cjs.parseTimeSignature.call(void 0, "4/4")));
+  _chunkPI3UXRWKcjs.assertTimeSignature.call(void 0, ts);
+  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunk2A2QMA74cjs.beatsPerBar.call(void 0, ts)));
+  _chunkPI3UXRWKcjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  const budget = opts.budget;
+  _chunkPI3UXRWKcjs.assertNoteEvents.call(void 0, notes, "timeline notes", { allowNonPositiveDuration: true, budget });
+  const soundingIndex = _chunk2A2QMA74cjs.createNoteEventIndex.call(void 0, 
+    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 = _nullishCoalesce(opts.totalBeats, () => ( lastNoteEnd));
+  _chunkPI3UXRWKcjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
+  const key = _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkKQN2ZYNDcjs.detectKeyFromNotes.call(void 0, sounding, { budget }), 'access', _5 => _5[0], 'optionalAccess', _6 => _6.key]))), () => ( _chunkBSLTLGM3cjs.majorKey.call(void 0, 0)));
+  const segments = [];
+  const segmentConfidence = [];
+  const windowCount = Math.max(0, Math.ceil(totalBeats / harmonicRhythm - EPS));
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, 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);
+    _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, memberships, "timeline note-to-window memberships", budget);
+    for (let window = first; window < lastExclusive; window += 1) {
+      _optionalChain([windowNotes, 'access', _7 => _7[window], 'optionalAccess', _8 => _8.push, 'call', _9 => _9(indexed.note)]);
+    }
+  }
+  for (let i = 0; i < windowCount; i += 1) {
+    const start = i * harmonicRhythm;
+    const end = Math.min(start + harmonicRhythm, totalBeats);
+    const inferred = analyzeWindow(_nullishCoalesce(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 = _nullishCoalesce(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 = _chunkKQN2ZYNDcjs.detectCadence.call(void 0, 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 = _optionalChain([lanes, 'access', _10 => _10[lane], 'optionalAccess', _11 => _11[(_nullishCoalesce(_optionalChain([lanes, 'access', _12 => _12[lane], 'optionalAccess', _13 => _13.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) {
+      _optionalChain([lanes, 'access', _14 => _14[best], 'optionalAccess', _15 => _15.push, 'call', _16 => _16(note)]);
+      return true;
+    }
+    return false;
+  };
+  for (let start = 0; start < ordered.length; ) {
+    const onset = _nullishCoalesce(_optionalChain([ordered, 'access', _17 => _17[start], 'optionalAccess', _18 => _18.startBeat]), () => ( 0));
+    let end = start + 1;
+    while (end < ordered.length && Math.abs((_nullishCoalesce(_optionalChain([ordered, 'access', _19 => _19[end], 'optionalAccess', _20 => _20.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) {
+          _optionalChain([lanes, 'access', _21 => _21[lane.index], 'optionalAccess', _22 => _22.push, 'call', _23 => _23(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 ((_nullishCoalesce(_optionalChain([sounding, 'access', _24 => _24[middle], 'optionalAccess', _25 => _25.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 ? _optionalChain([prev, 'optionalAccess', _26 => _26.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: _nullishCoalesce(track.name, () => ( `track ${index + 1}`)),
+      role: _nullishCoalesce(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 = _nullishCoalesce(opts.ts, () => ( _chunk2A2QMA74cjs.parseTimeSignature.call(void 0, "4/4")));
+  _chunkPI3UXRWKcjs.assertTimeSignature.call(void 0, ts);
+  const budget = opts.budget;
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
+  for (let index = 0; index < tracks.length; index += 1) {
+    _chunkPI3UXRWKcjs.assertNoteEvents.call(void 0, _nullishCoalesce(_optionalChain([tracks, 'access', _27 => _27[index], 'optionalAccess', _28 => _28.notes]), () => ( [])), `tracks[${index}].notes`, {
+      allowNonPositiveDuration: true,
+      budget
+    });
+  }
+  const profile = _nullishCoalesce(opts.profile, () => ( "pop"));
+  const step = _nullishCoalesce(opts.step, () => ( 1));
+  _chunkPI3UXRWKcjs.assertRange.call(void 0, 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: _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkKQN2ZYNDcjs.detectKeyFromNotes.call(void 0, pooled, { budget }), 'access', _29 => _29[0], 'optionalAccess', _30 => _30.key]))), () => ( _chunkBSLTLGM3cjs.majorKey.call(void 0, 0)))
+  };
+  const prepared = prepareTracks(tracks);
+  const points = [];
+  const sampleCount = Math.max(0, Math.ceil(totalBeats / step - EPS2));
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, sampleCount, "tension samples", budget);
+  const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, 
+    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[_chunkKQN2ZYNDcjs.functionOf.call(void 0, chord, key)] : 0;
+  const chordPcs = chord ? new Set(_chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, chord)) : null;
+  const strongBeat = _chunk2A2QMA74cjs.isStrongBeat.call(void 0, beat, ts);
+  let nonChord = 0;
+  let dissonant = 0;
+  const pitches = /* @__PURE__ */ new Map();
+  for (const voice of sounding) {
+    pitches.set(voice.pitch, (_nullishCoalesce(pitches.get(voice.pitch), () => ( 0))) + 1);
+  }
+  for (const [pitch, count] of pitches) {
+    if (chordPcs && !chordPcs.has(_chunkPI3UXRWKcjs.pitchClassOf.call(void 0, pitch))) {
+      nonChord += count;
+    }
+    const others = [...pitches].flatMap(
+      ([otherPitch, otherCount]) => Array.from({ length: otherCount - (otherPitch === pitch ? 1 : 0) }, () => ({
+        pitch: otherPitch
+      }))
+    );
+    const result = _chunkWFDXOLUBcjs.evaluateSafety.call(void 0, 
+      {
+        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 = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
+  return ((_chunkPI3UXRWKcjs.pitchClassOf.call(void 0, pitch) - _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, 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 (_chunkBSLTLGM3cjs.isChordMember.call(void 0, pitch - delta, chord)) {
+      return pitch - delta;
+    }
+  }
+  return void 0;
+}
+function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
+  _chunkPI3UXRWKcjs.assertNoteEvents.call(void 0, 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 = _chunkBSLTLGM3cjs.isChordMember.call(void 0, note.pitch, chord);
+    let handled = false;
+    if (chord && member) {
+      const role = _chunkBSLTLGM3cjs.chordToneRole.call(void 0, note.pitch, chord);
+      if (role) {
+        labels.push({ kind: "chordTone", role });
+      } else {
+        const ic = _chunkBSLTLGM3cjs.intervalAboveRoot.call(void 0, 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 && _chunkBSLTLGM3cjs.isChordMember.call(void 0, prev.pitch, prevChord);
+      const resolves = isStep(next.pitch, note.pitch);
+      const others = otherVoicesAtBeat(note.startBeat);
+      const verticallyDissonant = others.some(
+        (ov) => _chunkBSLTLGM3cjs.createsVerticalDissonance.call(void 0, 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 = _chunkBSLTLGM3cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
+      const nextMember = _chunkBSLTLGM3cjs.isChordMember.call(void 0, 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 && _chunkBSLTLGM3cjs.isChordMember.call(void 0, 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 (_chunkBSLTLGM3cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
+        labels.push({ kind: "anticipation" });
+        handled = true;
+      }
+    }
+    if (!handled && chord && prev && next && !member) {
+      const prevMember = _chunkBSLTLGM3cjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
+      const nextMember = _chunkBSLTLGM3cjs.isChordMember.call(void 0, 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 = _chunkBSLTLGM3cjs.intervalAboveRoot.call(void 0, 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 && _chunkBSLTLGM3cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, key)) {
+      labels.push({ kind: "leadingTone", resolveTo: next.pitch });
+    }
+    const analyzed = {
+      noteId: _nullishCoalesce(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 = _optionalChain([track, 'access', _31 => _31.voices, 'access', _32 => _32[v], 'optionalAccess', _33 => _33.at, 'call', _34 => _34(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 = _nullishCoalesce(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 ((_nullishCoalesce(_optionalChain([timeline, 'access', _35 => _35.segments, 'access', _36 => _36[middle], 'optionalAccess', _37 => _37.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 = _optionalChain([timeline, 'access', _38 => _38.segments, 'access', _39 => _39[i], 'optionalAccess', _40 => _40.startBeat]);
+    if (start === void 0 || start >= noteEnd - EPS2) {
+      break;
+    }
+    beats.push(start);
+  }
+  return beats;
+}
+function analyzeArrangement(tracks, opts = {}) {
+  const ts = _nullishCoalesce(opts.ts, () => ( _chunk2A2QMA74cjs.parseTimeSignature.call(void 0, "4/4")));
+  _chunkPI3UXRWKcjs.assertTimeSignature.call(void 0, ts);
+  const budget = opts.budget;
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
+  let noteCount = 0;
+  for (let index = 0; index < tracks.length; index += 1) {
+    const notes = _optionalChain([tracks, 'access', _41 => _41[index], 'optionalAccess', _42 => _42.notes]);
+    if (!Array.isArray(notes)) {
+      throw new (0, _chunkPI3UXRWKcjs.InvalidInputError)(
+        `tracks[${index}].notes must be an array; received ${typeof notes}`
+      );
+    }
+    _chunkPI3UXRWKcjs.assertNoteEvents.call(void 0, notes, `tracks[${index}].notes`, {
+      allowNonPositiveDuration: true,
+      budget
+    });
+    noteCount += notes.length;
+  }
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, noteCount, "arrangement notes", budget);
+  const profile = _nullishCoalesce(opts.profile, () => ( "pop"));
+  const minSeverity = _nullishCoalesce(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: _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkKQN2ZYNDcjs.detectKeyFromNotes.call(void 0, pooled, { budget }), 'access', _43 => _43[0], 'optionalAccess', _44 => _44.key]))), () => ( _chunkBSLTLGM3cjs.majorKey.call(void 0, 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: _chunk2A2QMA74cjs.isStrongBeat.call(void 0, beat, ts)
+          };
+          let result = _chunkWFDXOLUBcjs.evaluateSafety.call(void 0, safetyQuery, { suggestions: false });
+          if (result.safety !== 0 /* Safe */ && result.safety >= minSeverity) {
+            result = _chunkWFDXOLUBcjs.evaluateSafety.call(void 0, safetyQuery);
+            const conflict = {
+              beat,
+              trackName: track.name,
+              trackIndex: track.trackIndex,
+              noteId: note.id,
+              pitch: note.pitch,
+              labels: _nullishCoalesce(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 };
+}
+
+
+
+
+
+
+
+
+
+
+exports.chordTimelineFromChords = chordTimelineFromChords; exports.chordTimelineFromNotes = chordTimelineFromNotes; exports.detectCadences = detectCadences; exports.tensionCurve = tensionCurve; exports.tensionCurveFrom = tensionCurveFrom; exports.toVoiceNotes = toVoiceNotes; exports.analyzeVoice = analyzeVoice; exports.analyzeArrangement = analyzeArrangement;
+//# sourceMappingURL=chunk-4VZ5MZAM.cjs.map