@libraz/libcantus 0.9.4 → 0.9.5

package/dist/{chunk-RC6GBMCD.cjs → chunk-4VZ5MZAM.cjs}

@@ -4,17 +4,17 @@
 
 
 
-var _chunk36N73KZ3cjs = require('./chunk-36N73KZ3.cjs');
+var _chunk2A2QMA74cjs = require('./chunk-2A2QMA74.cjs');
 
 
 
 
 
+var _chunkKQN2ZYNDcjs = require('./chunk-KQN2ZYND.cjs');
 
-var _chunkCAN76NCUcjs = require('./chunk-CAN76NCU.cjs');
 
+var _chunkWFDXOLUBcjs = require('./chunk-WFDXOLUB.cjs');
 
-var _chunkQ6OP4U43cjs = require('./chunk-Q6OP4U43.cjs');
 
 
 
@@ -24,8 +24,8 @@ var _chunkQ6OP4U43cjs = require('./chunk-Q6OP4U43.cjs');
 
 
 
+var _chunkBSLTLGM3cjs = require('./chunk-BSLTLGM3.cjs');
 
-var _chunkFNDWXRRIcjs = require('./chunk-FNDWXRRI.cjs');
 
 
 
@@ -33,16 +33,15 @@ var _chunkFNDWXRRIcjs = require('./chunk-FNDWXRRI.cjs');
 
 
 
-
-var _chunk7MGZ7D62cjs = require('./chunk-7MGZ7D62.cjs');
+var _chunkPI3UXRWKcjs = require('./chunk-PI3UXRWK.cjs');
 
 // src/analyze/timeline/index.ts
 function chordTimelineFromChords(chords, totalBeats) {
-  _chunk7MGZ7D62cjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, chords.length, "timeline chords");
+  _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) {
-    _chunk7MGZ7D62cjs.assertRange.call(void 0, 
-      _nullishCoalesce(_optionalChain([chords, 'access', _2 => _2[index], 'optionalAccess', _3 => _3.startBeat]), () => ( Number.NaN)),
+    _chunkPI3UXRWKcjs.assertRange.call(void 0, 
+      _nullishCoalesce(_optionalChain([chords, 'access', _ => _[index], 'optionalAccess', _2 => _2.startBeat]), () => ( Number.NaN)),
       0,
       Number.MAX_SAFE_INTEGER,
       `chords[${index}].startBeat`
@@ -56,19 +55,19 @@ function chordTimelineFromChords(chords, totalBeats) {
     return {
       startBeat: gc.startBeat,
       endBeat,
-      chord: _chunkFNDWXRRIcjs.makeChord.call(void 0, gc.rootPc, gc.quality, gc.bassPc)
+      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) => {
-    _chunk7MGZ7D62cjs.assertFiniteNumber.call(void 0, beat, "timeline query 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', _4 => _4[middle], 'optionalAccess', _5 => _5.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+      if ((_nullishCoalesce(_optionalChain([segments, 'access', _3 => _3[middle], 'optionalAccess', _4 => _4.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
         low = middle + 1;
       } else {
         high = middle;
@@ -81,16 +80,15 @@ function segmentLookup(segments) {
 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 scoreMatch(match, weights, maxWeight, key) {
   const rootWeight = maxWeight > 0 ? (_nullishCoalesce(weights[match.rootPc], () => ( 0))) / maxWeight : 0;
-  const tones = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, match.rootPc, match.quality));
+  const tones = _chunkBSLTLGM3cjs.chordPitchClasses.call(void 0, _chunkBSLTLGM3cjs.makeChord.call(void 0, match.rootPc, match.quality));
   let score = rootWeight;
-  if (tones.every((pc) => _chunkFNDWXRRIcjs.isScaleTone.call(void 0, pc, key))) {
+  if (tones.every((pc) => _chunkBSLTLGM3cjs.isScaleTone.call(void 0, pc, key))) {
     score += DIATONIC_BONUS;
   }
   if (match.exact) {
@@ -100,7 +98,7 @@ function scoreMatch(match, weights, maxWeight, key) {
   return score;
 }
 function chordConfidence(chord, weights, totalWeight, exact) {
-  const tones = new Set(_chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord));
+  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)) {
@@ -122,8 +120,8 @@ 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 + _chunk36N73KZ3cjs.metricWeight.call(void 0, note.startBeat, ts) / 3 : 1;
-    const pc = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, note.pitch);
+    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;
@@ -140,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 = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, lowestPitch);
-  const anchorPc = selected.includes(bassPc) ? bassPc : _nullishCoalesce(selected[0], () => ( bassPc));
-  const detectionPitches = selected.map((pc) => pc === anchorPc ? pc : pc + 12);
-  const matches = _chunkCAN76NCUcjs.detectChord.call(void 0, detectionPitches);
+  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) {
@@ -154,47 +152,43 @@ function analyzeWindow(notes, windowStart, windowEnd, ts, key) {
     }
   }
   if (bestMatch) {
-    const chord = _chunkFNDWXRRIcjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
+    const chord = _chunkBSLTLGM3cjs.makeChord.call(void 0, bestMatch.rootPc, bestMatch.quality, bestMatch.bassPc);
     return { chord, confidence: chordConfidence(chord, weights, totalWeight, bestMatch.exact) };
   }
-  const fallback = _chunkCAN76NCUcjs.detectChordBest.call(void 0, 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 = _nullishCoalesce(opts.ts, () => ( _chunk36N73KZ3cjs.parseTimeSignature.call(void 0, "4/4")));
-  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
-  const harmonicRhythm = _nullishCoalesce(opts.harmonicRhythm, () => ( _chunk36N73KZ3cjs.beatsPerBar.call(void 0, ts)));
-  _chunk7MGZ7D62cjs.assertRange.call(void 0, harmonicRhythm, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "harmonic rhythm");
+  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;
-  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, notes, "timeline notes", { allowNonPositiveDuration: true, budget });
-  const soundingIndex = _chunk36N73KZ3cjs.createNoteEventIndex.call(void 0, 
+  _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));
-  _chunk7MGZ7D62cjs.assertRange.call(void 0, totalBeats, 0, Number.MAX_SAFE_INTEGER, "timeline totalBeats");
-  const key = _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkCAN76NCUcjs.detectKeyFromNotes.call(void 0, sounding), 'access', _6 => _6[0], 'optionalAccess', _7 => _7.key]))), () => ( _chunkFNDWXRRIcjs.majorKey.call(void 0, 0)));
+  _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));
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, windowCount, "timeline windows", budget);
+  _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);
-    _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, memberships, "timeline note-to-window memberships", budget);
+    _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, memberships, "timeline note-to-window memberships", budget);
     for (let window = first; window < lastExclusive; window += 1) {
-      _optionalChain([windowNotes, 'access', _8 => _8[window], 'optionalAccess', _9 => _9.push, 'call', _10 => _10(indexed.note)]);
+      _optionalChain([windowNotes, 'access', _7 => _7[window], 'optionalAccess', _8 => _8.push, 'call', _9 => _9(indexed.note)]);
     }
   }
   for (let i = 0; i < windowCount; i += 1) {
@@ -233,7 +227,7 @@ function detectCadences(timeline, key) {
     if (Math.abs(cur.startBeat - prev.endBeat) > EPS) {
       continue;
     }
-    const type = _chunkCAN76NCUcjs.detectCadence.call(void 0, prev.chord, cur.chord, key);
+    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 });
     }
@@ -270,12 +264,15 @@ function poolNotes(tracks, only) {
 }
 function splitIntoSubVoices(ordered) {
   const lanes = [];
-  for (const note of ordered) {
+  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) {
-      const last = _optionalChain([lanes, 'access', _11 => _11[lane], 'optionalAccess', _12 => _12[(_nullishCoalesce(_optionalChain([lanes, 'access', _13 => _13[lane], 'optionalAccess', _14 => _14.length]), () => ( 0))) - 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;
       }
@@ -294,10 +291,40 @@ function splitIntoSubVoices(ordered) {
       }
     }
     if (best >= 0) {
-      _optionalChain([lanes, 'access', _15 => _15[best], 'optionalAccess', _16 => _16.push, 'call', _17 => _17(note)]);
+      _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 {
-      lanes.push([note]);
+      const note = block[0];
+      if (note !== void 0 && !attachNearest(note)) {
+        lanes.push([note]);
+      }
     }
+    start = end;
   }
   return lanes;
 }
@@ -306,7 +333,7 @@ function lastStartingAtOrBefore(sounding, beat) {
   let high = sounding.length;
   while (low < high) {
     const middle = Math.floor((low + high) / 2);
-    if ((_nullishCoalesce(_optionalChain([sounding, 'access', _18 => _18[middle], 'optionalAccess', _19 => _19.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat + EPS2) {
+    if ((_nullishCoalesce(_optionalChain([sounding, 'access', _24 => _24[middle], 'optionalAccess', _25 => _25.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat + EPS2) {
       low = middle + 1;
     } else {
       high = middle;
@@ -325,7 +352,7 @@ function prepareTracks(tracks) {
         const contiguous = prevEnd !== void 0 && Math.abs(prevEnd - note.startBeat) <= EPS2;
         return {
           pitch: note.pitch,
-          prevPitch: contiguous ? _optionalChain([prev, 'optionalAccess', _20 => _20.pitch]) : void 0,
+          prevPitch: contiguous ? _optionalChain([prev, 'optionalAccess', _26 => _26.pitch]) : void 0,
           startBeat: note.startBeat,
           endBeat: note.startBeat + note.durationBeat
         };
@@ -362,19 +389,19 @@ function clamp01(value) {
   return Math.min(1, Math.max(0, value));
 }
 function tensionCurve(tracks, opts = {}) {
-  const ts = _nullishCoalesce(opts.ts, () => ( _chunk36N73KZ3cjs.parseTimeSignature.call(void 0, "4/4")));
-  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  const ts = _nullishCoalesce(opts.ts, () => ( _chunk2A2QMA74cjs.parseTimeSignature.call(void 0, "4/4")));
+  _chunkPI3UXRWKcjs.assertTimeSignature.call(void 0, ts);
   const budget = opts.budget;
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", budget);
   for (let index = 0; index < tracks.length; index += 1) {
-    _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, _nullishCoalesce(_optionalChain([tracks, 'access', _21 => _21[index], 'optionalAccess', _22 => _22.notes]), () => ( [])), `tracks[${index}].notes`, {
+    _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));
-  _chunk7MGZ7D62cjs.assertRange.call(void 0, step, Number.MIN_VALUE, Number.MAX_SAFE_INTEGER, "tension sampling step");
+  _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(
@@ -388,14 +415,18 @@ function tensionCurve(tracks, opts = {}) {
     budget
   }) : {
     timeline: opts.timeline,
-    key: _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkCAN76NCUcjs.detectKeyFromNotes.call(void 0, pooled), 'access', _23 => _23[0], 'optionalAccess', _24 => _24.key]))), () => ( _chunkFNDWXRRIcjs.majorKey.call(void 0, 0)))
+    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));
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, sampleCount, "tension samples", budget);
+  _chunkPI3UXRWKcjs.assertGenerationBudget.call(void 0, sampleCount, "tension samples", budget);
   const voiceCount = prepared.reduce((sum, track) => sum + track.voices.length, 0);
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, sampleCount * voiceCount, "tension sample-voice lookups", budget);
+  _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) });
@@ -427,24 +458,28 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
     return 0;
   }
   const chord = timeline.at(beat);
-  const functionScore = chord ? FUNCTION_TENSION[_chunkCAN76NCUcjs.functionOf.call(void 0, chord, key)] : 0;
-  const chordPcs = chord ? new Set(_chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord)) : null;
-  const strongBeat = _chunk36N73KZ3cjs.isStrongBeat.call(void 0, beat, ts);
+  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;
-  for (let i = 0; i < sounding.length; i += 1) {
-    const voice = sounding[i];
-    if (!voice) {
-      continue;
-    }
-    if (chordPcs && !chordPcs.has(_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, voice.pitch))) {
-      nonChord += 1;
+  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 = sounding.filter((_, j) => j !== i).map((s) => ({ pitch: s.pitch }));
-    const result = _chunkQ6OP4U43cjs.evaluateSafety.call(void 0, 
+    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: voice.pitch,
+        candidatePitch: pitch,
         chord,
         key,
         otherVoices: others,
@@ -453,7 +488,7 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
       { suggestions: false }
     );
     if (result.safety === 2 /* Dissonant */) {
-      dissonant += 1;
+      dissonant += count;
     }
   }
   const dissonanceScore = Math.max(nonChord, dissonant) / sounding.length;
@@ -473,7 +508,7 @@ function sampleTension(prepared, timeline, key, ts, profile, beat) {
 function toVoiceNotes(events) {
   return events.map((event, index) => ({ ...event, id: index, originalIndex: index }));
 }
-var EPS3 = 1e-9;
+var HUMANIZE_ADJACENCY = 0.05;
 function intervalAboveBass(pitch, others, chord) {
   let bass = Number.POSITIVE_INFINITY;
   for (const ov of others) {
@@ -483,7 +518,7 @@ function intervalAboveBass(pitch, others, chord) {
     return ((pitch - bass) % 12 + 12) % 12;
   }
   const ref = _nullishCoalesce(chord.bassPc, () => ( chord.rootPc));
-  return ((_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, pitch) - _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
+  return ((_chunkPI3UXRWKcjs.pitchClassOf.call(void 0, pitch) - _chunkPI3UXRWKcjs.pitchClassOf.call(void 0, ref)) % 12 + 12) % 12;
 }
 function tensionDegree(ic) {
   if (ic === 1 || ic === 2) {
@@ -518,14 +553,14 @@ function suspensionType(ic, delta) {
 }
 function stepResolution(pitch, chord) {
   for (let delta = 1; delta <= 2; delta += 1) {
-    if (_chunkFNDWXRRIcjs.isChordMember.call(void 0, pitch - delta, chord)) {
+    if (_chunkBSLTLGM3cjs.isChordMember.call(void 0, pitch - delta, chord)) {
       return pitch - delta;
     }
   }
   return void 0;
 }
 function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
-  _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, voice, "voice notes", { allowNonPositiveDuration: true });
+  _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];
@@ -536,29 +571,29 @@ 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 = _chunkFNDWXRRIcjs.isChordMember.call(void 0, note.pitch, chord);
+    const member = _chunkBSLTLGM3cjs.isChordMember.call(void 0, note.pitch, chord);
     let handled = false;
     if (chord && member) {
-      const role = _chunkFNDWXRRIcjs.chordToneRole.call(void 0, note.pitch, chord);
+      const role = _chunkBSLTLGM3cjs.chordToneRole.call(void 0, note.pitch, chord);
       if (role) {
         labels.push({ kind: "chordTone", role });
       } else {
-        const ic = _chunkFNDWXRRIcjs.intervalAboveRoot.call(void 0, note.pitch, chord);
+        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 && _chunkFNDWXRRIcjs.isChordMember.call(void 0, prev.pitch, prevChord);
+      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) => _chunkFNDWXRRIcjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
+        (ov) => _chunkBSLTLGM3cjs.createsVerticalDissonance.call(void 0, note.pitch, ov.pitch, true)
       );
       if (prepared && verticallyDissonant && resolves) {
         const ic = intervalAboveBass(note.pitch, others, chord);
@@ -570,8 +605,8 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && prev && next) {
-      const prevMember = _chunkFNDWXRRIcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = _chunkFNDWXRRIcjs.isChordMember.call(void 0, next.pitch, chordAtBeat(next.startBeat));
+      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;
@@ -580,20 +615,20 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
         handled = true;
       }
     }
-    if (!handled && chord && prev && next && !member && prev.pitch === next.pitch && _chunkFNDWXRRIcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat)) && isStep(note.pitch, prev.pitch)) {
+    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 (_chunkFNDWXRRIcjs.isChordMember.call(void 0, next.pitch, nextChord)) {
+      if (_chunkBSLTLGM3cjs.isChordMember.call(void 0, next.pitch, nextChord)) {
         labels.push({ kind: "anticipation" });
         handled = true;
       }
     }
     if (!handled && chord && prev && next && !member) {
-      const prevMember = _chunkFNDWXRRIcjs.isChordMember.call(void 0, prev.pitch, chordAtBeat(prev.startBeat));
-      const nextMember = _chunkFNDWXRRIcjs.isChordMember.call(void 0, next.pitch, chordAtBeat(next.startBeat));
+      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;
@@ -603,7 +638,7 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
       }
     }
     if (!handled && chord && !member) {
-      const ic = _chunkFNDWXRRIcjs.intervalAboveRoot.call(void 0, note.pitch, chord);
+      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) {
@@ -621,7 +656,7 @@ function analyzeVoice(voice, chordAtBeat, key, otherVoicesAtBeat = () => []) {
         }
       }
     }
-    if (next && _chunkFNDWXRRIcjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, key)) {
+    if (next && _chunkBSLTLGM3cjs.isLeadingToneResolution.call(void 0, note.pitch, next.pitch, key)) {
       labels.push({ kind: "leadingTone", resolveTo: next.pitch });
     }
     const analyzed = {
@@ -669,7 +704,7 @@ 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];
@@ -677,10 +712,7 @@ function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat) {
       continue;
     }
     for (let v = 0; v < track.voices.length; v += 1) {
-      if (t === excludeTrack && v === excludeVoice) {
-        continue;
-      }
-      const note = _optionalChain([track, 'access', _25 => _25.voices, 'access', _26 => _26[v], 'optionalAccess', _27 => _27.at, 'call', _28 => _28(beat)]);
+      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;
       }
@@ -689,17 +721,22 @@ function otherVoicesSounding(prepared, excludeTrack, excludeVoice, beat) {
       if (previous !== void 0) {
         snap.prevPitch = previous;
       }
-      out.push(snap);
+      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', _29 => _29.segments, 'access', _30 => _30[middle], 'optionalAccess', _31 => _31.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat + EPS2) {
+    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;
@@ -711,7 +748,7 @@ 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', _32 => _32.segments, 'access', _33 => _33[i], 'optionalAccess', _34 => _34.startBeat]);
+    const start = _optionalChain([timeline, 'access', _38 => _38.segments, 'access', _39 => _39[i], 'optionalAccess', _40 => _40.startBeat]);
     if (start === void 0 || start >= noteEnd - EPS2) {
       break;
     }
@@ -720,25 +757,25 @@ function evaluationBeats(note, timeline) {
   return beats;
 }
 function analyzeArrangement(tracks, opts = {}) {
-  const ts = _nullishCoalesce(opts.ts, () => ( _chunk36N73KZ3cjs.parseTimeSignature.call(void 0, "4/4")));
-  _chunk7MGZ7D62cjs.assertTimeSignature.call(void 0, ts);
+  const ts = _nullishCoalesce(opts.ts, () => ( _chunk2A2QMA74cjs.parseTimeSignature.call(void 0, "4/4")));
+  _chunkPI3UXRWKcjs.assertTimeSignature.call(void 0, ts);
   const budget = opts.budget;
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, tracks.length, "arrangement tracks", 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', _35 => _35[index], 'optionalAccess', _36 => _36.notes]);
+    const notes = _optionalChain([tracks, 'access', _41 => _41[index], 'optionalAccess', _42 => _42.notes]);
     if (!Array.isArray(notes)) {
-      throw new (0, _chunk7MGZ7D62cjs.InvalidInputError)(
+      throw new (0, _chunkPI3UXRWKcjs.InvalidInputError)(
         `tracks[${index}].notes must be an array; received ${typeof notes}`
       );
     }
-    _chunk7MGZ7D62cjs.assertNoteEvents.call(void 0, notes, `tracks[${index}].notes`, {
+    _chunkPI3UXRWKcjs.assertNoteEvents.call(void 0, notes, `tracks[${index}].notes`, {
       allowNonPositiveDuration: true,
       budget
     });
     noteCount += notes.length;
   }
-  _chunk7MGZ7D62cjs.assertGenerationBudget.call(void 0, noteCount, "arrangement notes", budget);
+  _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));
@@ -746,15 +783,20 @@ function analyzeArrangement(tracks, opts = {}) {
   const inferred = opts.timeline === void 0 ? chordTimelineFromNotes(pooled, {
     key: opts.key,
     ts,
-    harmonicRhythm: opts.harmonicRhythm
+    harmonicRhythm: opts.harmonicRhythm,
+    budget
   }) : {
     timeline: opts.timeline,
-    key: _nullishCoalesce(_nullishCoalesce(opts.key, () => ( _optionalChain([_chunkCAN76NCUcjs.detectKeyFromNotes.call(void 0, pooled), 'access', _37 => _37[0], 'optionalAccess', _38 => _38.key]))), () => ( _chunkFNDWXRRIcjs.majorKey.call(void 0, 0))),
-    segmentConfidence: opts.timeline.segments.map(() => 1)
+    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) {
@@ -776,7 +818,7 @@ function analyzeArrangement(tracks, opts = {}) {
         subVoice.voice,
         timeline.at,
         key,
-        (beat) => otherVoicesSounding(prepared, t, v, beat)
+        (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]));
@@ -788,16 +830,18 @@ function analyzeArrangement(tracks, opts = {}) {
         }
         for (const beat of evaluationBeats(note, timeline)) {
           const atOnset = Math.abs(beat - note.startBeat) <= EPS2;
-          const result = _chunkQ6OP4U43cjs.evaluateSafety.call(void 0, {
+          const safetyQuery = {
             profile,
             candidatePitch: note.pitch,
             prevPitch: atOnset ? preparedNote.prevPitch : note.pitch,
             chord: timeline.at(beat),
             key,
-            otherVoices: otherVoicesSounding(prepared, t, v, beat),
-            strongBeat: _chunk36N73KZ3cjs.isStrongBeat.call(void 0, beat, ts)
-          });
+            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,
@@ -842,4 +886,4 @@ function analyzeArrangement(tracks, opts = {}) {
 
 
 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-RC6GBMCD.cjs.map
+//# sourceMappingURL=chunk-4VZ5MZAM.cjs.map