@libraz/libcantus 0.9.5 → 1.0.0

package/dist/chunk-4VZ5MZAM.cjs

@@ -1,889 +0,0 @@
-"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