@libraz/libcantus 0.9.2 → 0.9.4

package/src/generate/countermelody/index.ts

@@ -1,379 +0,0 @@
-import type { TimeSignature } from '../../core/meter/index.js';
-import { isStrongBeat } from '../../core/meter/index.js';
-import type { Rng } from '../../core/random/index.js';
-import { createRng } from '../../core/random/index.js';
-import type { KeyScale, NoteEvent } from '../../core/types.js';
-import type { Chord } from '../../theory/chord/index.js';
-import { chordToneRole } from '../../theory/chord/index.js';
-import { createsParallelPerfect, isForbiddenMelodicLeap } from '../../theory/counterpoint/index.js';
-import type { VoiceSnapshot } from '../../theory/safety/index.js';
-import { enumerateSafePitches } from '../../theory/safety/index.js';
-import { nearestScaleTone } from '../../theory/scale/index.js';
-
-/**
- * Options controlling {@link generateCounterMelody}.
- *
- * @category Voicing & Counterpoint
- */
-export type CounterMelodyOptions = {
-  /** The lead line to write against, in ascending onset order. */
-  melody: NoteEvent[];
-  /** Chord sounding at an absolute beat position, or null when none applies. */
-  chordAt: (beat: number) => Chord | null;
-  /** Key/scale context for scale-tone decisions. */
-  key: KeyScale;
-  /**
-   * Meter used for strong-beat decisions.
-   *
-   * @defaultValue 4/4
-   */
-  ts?: TimeSignature;
-  /**
-   * Which side of the melody the counter line occupies.
-   *
-   * @defaultValue 'below'
-   */
-  register?: 'above' | 'below';
-  /**
-   * Onset strategy: `'complement'` moves where the melody holds or rests and
-   * reinforces some strong beats; `'follow'` mirrors melody onsets.
-   *
-   * @defaultValue 'complement'
-   */
-  rhythm?: 'complement' | 'follow';
-  /**
-   * Safety profile applied to candidate pitches.
-   *
-   * @defaultValue 'pop'
-   */
-  profile?: 'strict' | 'pop';
-  /** Lowest MIDI pitch the counter line may use (default derived from `register`). */
-  pitchLow?: number;
-  /** Highest MIDI pitch the counter line may use (default derived from `register`). */
-  pitchHigh?: number;
-  /**
-   * PRNG seed; the same seed always yields the same line.
-   *
-   * @defaultValue 0
-   */
-  seed?: number;
-};
-
-/** Meter assumed when none is supplied. */
-const DEFAULT_TS: TimeSignature = { numerator: 4, denominator: 4 };
-
-/** Tolerance for beat-position comparisons. */
-const EPS = 1e-9;
-
-/** Grid resolution, in quarter-note beats, scanned for complement onsets. */
-const GRID_STEP = 0.5;
-
-/** Minimum spacing between counter onsets, keeping the line uncluttered. */
-const MIN_ONSET_GAP = 1;
-
-/** Semitone offset of the counter register's centre from the melody's mean pitch. */
-const REGISTER_OFFSET = 12;
-
-/** Half-width, in semitones, of the default counter register. */
-const DEFAULT_HALF_RANGE = 10;
-
-/** Probability of moving on a whole beat while the melody sustains. */
-const HOLD_ON_BEAT_PROB = 0.55;
-
-/** Probability of moving on an off-beat subdivision while the melody sustains. */
-const HOLD_OFF_BEAT_PROB = 0.2;
-
-/** Probability of reinforcing a strong beat that the melody also attacks. */
-const REINFORCE_PROB = 0.35;
-
-/** Velocity assumed for melody notes that carry none. */
-const DEFAULT_MELODY_VELOCITY = 96;
-
-/** How far below the concurrent melody velocity the counter line sits. */
-const VELOCITY_DROP = 16;
-
-/** Whether a beat position falls on a whole quarter-note beat. */
-function isWholeBeat(beat: number): boolean {
-  return Math.abs(beat - Math.round(beat)) < EPS;
-}
-
-/** The melody note sounding at a beat (latest onset wins on overlaps). */
-function melodyNoteAt(melody: NoteEvent[], beat: number): NoteEvent | undefined {
-  let found: NoteEvent | undefined;
-  for (const note of melody) {
-    if (note.startBeat - EPS <= beat && beat < note.startBeat + note.durationBeat - EPS) {
-      if (!found || note.startBeat > found.startBeat) {
-        found = note;
-      }
-    }
-  }
-  return found;
-}
-
-/** Whether any melody note attacks exactly at a beat. */
-function melodyAttacksAt(melody: NoteEvent[], beat: number): boolean {
-  return melody.some((note) => Math.abs(note.startBeat - beat) < EPS);
-}
-
-/** Counter onsets mirroring the melody's own onsets, deduplicated and sorted. */
-function followOnsets(melody: NoteEvent[]): number[] {
-  return [...new Set(melody.map((note) => note.startBeat))].sort((a, b) => a - b);
-}
-
-/**
- * Counter onsets complementing the melody: whole beats inside rests are always
- * taken, positions where the melody sustains are taken probabilistically, and
- * strong beats the melody also attacks are occasionally reinforced. A minimum
- * gap between accepted onsets keeps the line sparse.
- */
-function complementOnsets(
-  melody: NoteEvent[],
-  ts: TimeSignature,
-  spanStart: number,
-  spanEnd: number,
-  rng: Rng,
-): number[] {
-  const onsets: number[] = [];
-  const gridStart = Math.floor(spanStart / GRID_STEP) * GRID_STEP;
-  let last = Number.NEGATIVE_INFINITY;
-  for (let beat = gridStart; beat < spanEnd - EPS; beat += GRID_STEP) {
-    const attacked = melodyAttacksAt(melody, beat);
-    const sounding = melodyNoteAt(melody, beat) !== undefined;
-    let place = false;
-    if (!attacked && !sounding) {
-      place = isWholeBeat(beat);
-    } else if (!attacked) {
-      place = rng.prob(isWholeBeat(beat) ? HOLD_ON_BEAT_PROB : HOLD_OFF_BEAT_PROB);
-    } else if (isStrongBeat(beat, ts)) {
-      place = rng.prob(REINFORCE_PROB);
-    }
-    if (place && beat - last >= MIN_ONSET_GAP - EPS) {
-      onsets.push(beat);
-      last = beat;
-    }
-  }
-  return onsets;
-}
-
-/**
- * Preference score for one candidate counter pitch. Rewards imperfect
- * consonance with the melody, chord-tone membership, contrary or oblique
- * motion, and stepwise movement; penalizes wide or forbidden leaps, weak-beat
- * clashes, and drifting from the register centre.
- */
-function scoreCandidate(
-  pitch: number,
-  melPitch: number | undefined,
-  melPrev: number | undefined,
-  prevPitch: number | undefined,
-  chord: Chord | null,
-  center: number,
-): number {
-  let score = 0;
-  if (melPitch !== undefined) {
-    const ic = Math.abs(pitch - melPitch) % 12;
-    if (ic === 3 || ic === 4 || ic === 8 || ic === 9) {
-      score += 2; // imperfect consonance: thirds and sixths
-    } else if (ic === 0 || ic === 7) {
-      score += 0.5; // perfect consonance: allowed but less colourful
-    } else if (ic === 1 || ic === 2 || ic === 6 || ic === 10 || ic === 11) {
-      score -= 2; // dissonant even on weak beats
-    }
-  }
-  if (chord && chordToneRole(pitch, chord) !== null) {
-    score += 1;
-  }
-  if (prevPitch !== undefined) {
-    const move = pitch - prevPitch;
-    const dist = Math.abs(move);
-    score -= dist * 0.3;
-    if (dist > 0 && dist <= 2) {
-      score += 1; // stepwise motion
-    }
-    if (isForbiddenMelodicLeap(prevPitch, pitch)) {
-      score -= 6;
-    }
-    if (melPitch !== undefined && melPrev !== undefined) {
-      const melMove = melPitch - melPrev;
-      if ((move > 0 && melMove < 0) || (move < 0 && melMove > 0)) {
-        score += 2; // contrary motion
-      } else if (move === 0 || melMove === 0) {
-        score += 1; // oblique motion
-      } else {
-        score -= 1; // similar motion
-      }
-    }
-  }
-  score -= Math.abs(pitch - center) * 0.02;
-  return score;
-}
-
-/**
- * Last-resort pitch when no safe candidate survives filtering: the scale tone
- * nearest the previous pitch (or the register centre), pushed onto the correct
- * side of the sounding melody note.
- */
-function fallbackPitch(
-  melPitch: number | undefined,
-  prevPitch: number | undefined,
-  center: number,
-  register: 'above' | 'below',
-  low: number,
-  high: number,
-  key: KeyScale,
-): number {
-  let target = prevPitch ?? Math.round(center);
-  if (melPitch !== undefined) {
-    if (register === 'below' && target >= melPitch) {
-      target = melPitch - 5;
-    } else if (register === 'above' && target <= melPitch) {
-      target = melPitch + 5;
-    }
-  }
-  target = Math.min(Math.max(target, low), high);
-  let pitch = nearestScaleTone(target, key);
-  // Push onto the requested side of the melody, but only by whole octaves that
-  // keep the pitch inside [low, high]; the declared range is a hard bound while
-  // the register side is a soft preference. A final clamp guarantees the range.
-  if (melPitch !== undefined) {
-    while (register === 'below' && pitch >= melPitch && pitch - 12 >= low) {
-      pitch -= 12;
-    }
-    while (register === 'above' && pitch <= melPitch && pitch + 12 <= high) {
-      pitch += 12;
-    }
-  }
-  return Math.min(Math.max(pitch, low), high);
-}
-
-/**
- * Generate a counter melody against a lead line.
- *
- * Onsets are chosen per `rhythm`: `'follow'` places one counter note on each
- * melody onset; `'complement'` fills melody rests and sustains and reinforces
- * an occasional strong beat, spaced at least a beat apart. Each onset's pitch
- * is picked from the safe pitches in the counter register (chord tones and
- * consonant tensions against the sounding melody note), rejecting candidates
- * that would form a parallel perfect interval with the melody or sit on the
- * wrong side of it, then scored to favour contrary or oblique motion, imperfect
- * consonance, and stepwise movement. Ties break toward the lower pitch, so a
- * given seed always yields the same line. Notes extend to the next counter
- * onset (the last to the melody's end) at a velocity slightly under the melody.
- *
- * @param opts The lead line, chord context callback, key, and generation knobs.
- * @returns The counter line as note events sorted by onset; `[]` for an empty melody.
- * @example
- * ```ts
- * import { generateCounterMelody, majorKey, parseChordSymbol } from '@libraz/libcantus';
- * const melody = [{ pitch: 72, startBeat: 0, durationBeat: 2 }];
- * const counter = generateCounterMelody({
- *   melody,
- *   chordAt: () => parseChordSymbol('C'),
- *   key: majorKey(0),
- * }); // note events below the melody, in onset order
- * ```
- * @category Voicing & Counterpoint
- */
-export function generateCounterMelody(opts: CounterMelodyOptions): NoteEvent[] {
-  const melody = [...opts.melody].sort((a, b) => a.startBeat - b.startBeat);
-  if (melody.length === 0) {
-    return [];
-  }
-  const ts = opts.ts ?? DEFAULT_TS;
-  const register = opts.register ?? 'below';
-  const rhythm = opts.rhythm ?? 'complement';
-  const profile = opts.profile ?? 'pop';
-  const rng = createRng(opts.seed ?? 0);
-
-  const spanStart = melody[0]?.startBeat ?? 0;
-  const spanEnd = melody.reduce((end, n) => Math.max(end, n.startBeat + n.durationBeat), spanStart);
-  const meanPitch = melody.reduce((sum, n) => sum + n.pitch, 0) / melody.length;
-  const defaultCenter =
-    register === 'below' ? meanPitch - REGISTER_OFFSET : meanPitch + REGISTER_OFFSET;
-  const low = opts.pitchLow ?? Math.round(defaultCenter) - DEFAULT_HALF_RANGE;
-  const high = opts.pitchHigh ?? Math.round(defaultCenter) + DEFAULT_HALF_RANGE;
-  const center = (low + high) / 2;
-
-  const onsets =
-    rhythm === 'follow'
-      ? followOnsets(melody)
-      : complementOnsets(melody, ts, spanStart, spanEnd, rng);
-
-  const out: NoteEvent[] = [];
-  let prevPitch: number | undefined;
-  let prevOnset: number | undefined;
-  for (const beat of onsets) {
-    const melNote = melodyNoteAt(melody, beat);
-    const melPitch = melNote?.pitch;
-    const melPrev = prevOnset !== undefined ? melodyNoteAt(melody, prevOnset)?.pitch : undefined;
-    const chord = opts.chordAt(beat);
-    const otherVoices: VoiceSnapshot[] =
-      melPitch !== undefined ? [{ pitch: melPitch, prevPitch: melPrev }] : [];
-
-    const candidates = enumerateSafePitches(
-      {
-        profile,
-        prevPitch,
-        chord,
-        key: opts.key,
-        otherVoices,
-        strongBeat: isStrongBeat(beat, ts),
-        vocalLow: low,
-        vocalHigh: high,
-      },
-      low,
-      high,
-    );
-
-    let bestPitch: number | undefined;
-    let bestScore = Number.NEGATIVE_INFINITY;
-    for (const candidate of candidates) {
-      if (melPitch !== undefined) {
-        if (register === 'below' && candidate >= melPitch) {
-          continue;
-        }
-        if (register === 'above' && candidate <= melPitch) {
-          continue;
-        }
-        if (
-          prevPitch !== undefined &&
-          melPrev !== undefined &&
-          // Parallel octaves are the perfect-class-zero case of this predicate,
-          // so a single check covers both parallel fifths and octaves.
-          createsParallelPerfect(prevPitch, candidate, melPrev, melPitch)
-        ) {
-          continue;
-        }
-      }
-      const score = scoreCandidate(candidate, melPitch, melPrev, prevPitch, chord, center);
-      const tie =
-        Math.abs(score - bestScore) <= EPS && candidate < (bestPitch ?? Number.POSITIVE_INFINITY);
-      if (score > bestScore + EPS || tie) {
-        bestScore = score;
-        bestPitch = candidate;
-      }
-    }
-
-    const pitch =
-      bestPitch ?? fallbackPitch(melPitch, prevPitch, center, register, low, high, opts.key);
-    const velocity = Math.max(
-      1,
-      Math.min(127, Math.round((melNote?.velocity ?? DEFAULT_MELODY_VELOCITY) - VELOCITY_DROP)),
-    );
-    out.push({ pitch, startBeat: beat, durationBeat: GRID_STEP, velocity });
-    prevPitch = pitch;
-    prevOnset = beat;
-  }
-
-  // Extend each note to the next counter onset; the last to the melody's end.
-  for (let i = 0; i < out.length; i += 1) {
-    const note = out[i];
-    if (!note) {
-      continue;
-    }
-    const next = out[i + 1];
-    const end = next ? next.startBeat : Math.max(spanEnd, note.startBeat + GRID_STEP);
-    note.durationBeat = end - note.startBeat;
-  }
-  return out;
-}

package/src/generate/drums/beat.ts

@@ -1,266 +0,0 @@
-import {
-  getGhostDensity,
-  getGhostProbabilityAtPosition,
-  getGhostVelocity,
-  selectGhostPositions,
-} from './ghost.js';
-import {
-  footHiHatVelocity,
-  type HiHatLevel,
-  hiHatNote,
-  hiHatTypeVelocityMultiplier,
-  hiHatVelocityMultiplier,
-  OHH_VEL_BOOST,
-  roleHiHatInstrument,
-  sectionHiHatType,
-  shouldAddOpenHHAccent,
-  shouldPlayHiHat,
-  shouldUseBridgeCrossStick,
-} from './hihat.js';
-import type { HitList } from './hit.js';
-import type { BackingDensity, DrumRole, DrumStyle, Feel, SectionType } from './internal.js';
-import { EIGHTH, GM, type MoodCategory, SIXTEENTH } from './internal.js';
-import type { KickPattern } from './kick.js';
-import type { DrumRng } from './rng.js';
-import { effectiveSwing, quantizeSwing } from './swing.js';
-
-/** Per-section drum state shared across the bars of a section. */
-export type SectionCtx = {
-  style: DrumStyle;
-  feel: Feel;
-  densityMult: number;
-  backingDensity: BackingDensity;
-  hhLevel: HiHatLevel;
-  useGhostNotes: boolean;
-  ghostBoost: boolean;
-  useRide: boolean;
-  useFootHh: boolean;
-  role: DrumRole;
-  ghostMood: MoodCategory;
-  snareBeat3: boolean;
-};
-
-/** Per-beat context passed to every beat processor. */
-export type BeatCtx = {
-  track: HitList;
-  beatTick: number;
-  beat: number;
-  velocity: number;
-  section: SectionType;
-  bpm: number;
-  bar: number;
-  sectionBars: number;
-  inPrechorusLift: boolean;
-  swingAmount: number;
-  barHasOpenHh: boolean;
-  openHhBeat: number;
-  rng: DrumRng;
-};
-
-function swing16(tick: number, feel: Feel, swingAmount: number): number {
-  return quantizeSwing(tick, effectiveSwing(feel, swingAmount), 'sixteenth');
-}
-
-function hatSwingFactor(style: DrumStyle): number {
-  if (style === 'trap') {
-    return 0;
-  }
-  if (style === 'latin') {
-    return 0.35;
-  }
-  return 0.5;
-}
-
-/** Emit the kick for one beat. */
-export function generateKickForBeat(ctx: BeatCtx, sec: SectionCtx, kick: KickPattern): void {
-  if (ctx.inPrechorusLift) {
-    return;
-  }
-  const on = [kick.beat1, kick.beat2, kick.beat3, kick.beat4][ctx.beat] ?? false;
-  const and = [kick.beat1and, kick.beat2and, kick.beat3and, kick.beat4and][ctx.beat] ?? false;
-
-  if (on) {
-    ctx.track.add(GM.BD, ctx.beatTick, EIGHTH, ctx.velocity);
-  }
-  if (and) {
-    const andTick = swing16(ctx.beatTick + EIGHTH, sec.feel, ctx.swingAmount);
-    ctx.track.add(GM.BD, andTick, EIGHTH, ctx.velocity * 0.85);
-  }
-}
-
-/** Emit the backbeat snare (or side-stick) for one beat. */
-export function generateSnareForBeat(ctx: BeatCtx, sec: SectionCtx, isIntroFirst: boolean): void {
-  if (ctx.inPrechorusLift) {
-    return;
-  }
-  const snareOn = sec.snareBeat3 ? ctx.beat === 2 : ctx.beat === 1 || ctx.beat === 3;
-  if (!snareOn || isIntroFirst) {
-    return;
-  }
-  if (sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat)) {
-    return;
-  }
-
-  const backbeatVel = Math.min(127, ctx.velocity + 16);
-  const promoteSparseChorus =
-    sec.style === 'sparse' && ctx.section === 'chorus' && sec.role === 'full';
-
-  if (promoteSparseChorus) {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  } else if (sec.style === 'sparse' || sec.role === 'ambient') {
-    if (sec.role !== 'fxOnly' && sec.role !== 'minimal') {
-      ctx.track.add(GM.SIDESTICK, ctx.beatTick, EIGHTH, ctx.velocity * 0.8);
-    }
-  } else {
-    ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, backbeatVel);
-  }
-}
-
-/** Emit ghost snares at the "e"/"a" 16ths of beats 1 and 3. */
-export function generateGhostNotesForBeat(ctx: BeatCtx, sec: SectionCtx): void {
-  if (ctx.beat !== 0 && ctx.beat !== 2) {
-    return;
-  }
-  const positions = selectGhostPositions(sec.ghostMood, ctx.rng);
-  let ghostProb = getGhostDensity(sec.ghostMood, ctx.section, sec.backingDensity, ctx.bpm);
-  if (sec.ghostBoost) {
-    ghostProb = Math.min(1, ghostProb * 1.4);
-  }
-
-  for (const pos of positions) {
-    const sixteenthInBeat = pos === 'e' ? 1 : 3;
-    const posProb = getGhostProbabilityAtPosition(ctx.beat, sixteenthInBeat);
-    if (!ctx.rng.prob(ghostProb * posProb)) {
-      continue;
-    }
-    const variation = ctx.rng.float(0.85, 1.15);
-    const ghostBase = getGhostVelocity(ctx.section, ctx.beat / 2, false);
-    let ghostVel = ctx.velocity * ghostBase * variation;
-    if (pos === 'a') {
-      ghostVel *= 0.9;
-    }
-    const offset = pos === 'e' ? SIXTEENTH : 3 * SIXTEENTH;
-    const tick = swing16(ctx.beatTick + offset, sec.feel, ctx.swingAmount);
-    ctx.track.add(GM.SD, tick, SIXTEENTH, ghostVel);
-  }
-}
-
-/** Emit the pre-chorus lift buildup for one beat. */
-export function generatePreChorusBuildup(
-  ctx: BeatCtx,
-  sec: SectionCtx,
-  isSectionLastBar: boolean,
-): void {
-  if (sec.style === 'sparse') {
-    if (isSectionLastBar && ctx.beat === 3) {
-      ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, Math.max(45, ctx.velocity * 0.75));
-      ctx.track.add(GM.CRASH, ctx.beatTick + EIGHTH + SIXTEENTH, SIXTEENTH, ctx.velocity * 0.9);
-    }
-    return;
-  }
-  const barsInLift = 2;
-  const barInLift = ctx.bar - (ctx.sectionBars - barsInLift);
-  const progress = (barInLift * 4 + ctx.beat) / (barsInLift * 4);
-  const buildupVel = ctx.velocity * (0.5 + 0.5 * progress);
-  ctx.track.add(GM.SD, ctx.beatTick, EIGHTH, buildupVel);
-  ctx.track.add(GM.SD, ctx.beatTick + EIGHTH, EIGHTH, buildupVel * 0.85);
-  if (isSectionLastBar && ctx.beat === 3) {
-    ctx.track.add(GM.CRASH, ctx.beatTick + EIGHTH + SIXTEENTH, SIXTEENTH, ctx.velocity * 1.1);
-  }
-}
-
-/** Emit the timekeeping hi-hat (or ride/foot) for one beat. */
-export function generateHiHatForBeat(ctx: BeatCtx, sec: SectionCtx): void {
-  if (!shouldPlayHiHat(sec.role)) {
-    if (sec.useFootHh && (ctx.beat === 0 || ctx.beat === 2)) {
-      ctx.track.add(GM.FHH, ctx.beatTick, EIGHTH, footHiHatVelocity(ctx.rng));
-    }
-    return;
-  }
-
-  const crossStick = sec.useRide && shouldUseBridgeCrossStick(ctx.section, ctx.beat);
-  const hhInstrument = crossStick ? GM.SIDESTICK : roleHiHatInstrument(sec.role, sec.useRide);
-  const hhType = sectionHiHatType(ctx.section, sec.role);
-  const typeMult = hiHatTypeVelocityMultiplier(hhType);
-  const isDynamicOpen = ctx.barHasOpenHh && ctx.beat === ctx.openHhBeat;
-  const dm = sec.densityMult;
-
-  if (sec.hhLevel === 'quarter') {
-    const introRest = ctx.section === 'intro' && ctx.beat !== 0;
-    if (!introRest) {
-      if (isDynamicOpen) {
-        ctx.track.add(
-          GM.OHH,
-          ctx.beatTick,
-          EIGHTH,
-          ctx.velocity * dm * 0.75 * typeMult + OHH_VEL_BOOST,
-        );
-      } else {
-        ctx.track.add(
-          hhInstrument,
-          ctx.beatTick,
-          EIGHTH,
-          Math.max(20, ctx.velocity * dm * 0.75 * typeMult),
-        );
-      }
-    } else if (sec.useFootHh) {
-      ctx.track.add(GM.FHH, ctx.beatTick, EIGHTH, footHiHatVelocity(ctx.rng));
-    }
-    return;
-  }
-
-  if (sec.hhLevel === 'eighth') {
-    for (let eighth = 0; eighth < 2; eighth += 1) {
-      let hhTick = ctx.beatTick + eighth * EIGHTH;
-      if (eighth === 1) {
-        hhTick = swing16(hhTick, sec.feel, ctx.swingAmount);
-      }
-      if (ctx.section === 'intro' && eighth === 1) {
-        if (sec.useFootHh && ctx.beat % 2 === 0) {
-          ctx.track.add(GM.FHH, hhTick, EIGHTH, footHiHatVelocity(ctx.rng));
-        }
-        continue;
-      }
-      const hhVel = Math.max(20, ctx.velocity * dm * typeMult * (eighth === 0 ? 0.9 : 0.65));
-      if (isDynamicOpen && eighth === 0) {
-        ctx.track.add(GM.OHH, hhTick, EIGHTH, hhVel + OHH_VEL_BOOST);
-        continue;
-      }
-      let useOpen = false;
-      if (sec.style === 'fourOnFloor' && eighth === 1) {
-        const openProb = Math.max(0.15, Math.min(0.8, 45 / ctx.bpm));
-        useOpen = (ctx.beat === 1 || ctx.beat === 3) && ctx.rng.prob(openProb);
-      } else if (eighth === 0) {
-        useOpen = shouldAddOpenHHAccent(ctx.section, ctx.beat, ctx.bar, ctx.rng);
-      }
-      if (useOpen) {
-        ctx.track.add(hiHatNote('open'), hhTick, EIGHTH, Math.max(20, hhVel * 1.1));
-      } else {
-        ctx.track.add(hhInstrument, hhTick, EIGHTH / 2, hhVel);
-      }
-    }
-    return;
-  }
-
-  for (let sixteenth = 0; sixteenth < 4; sixteenth += 1) {
-    let hhTick = ctx.beatTick + sixteenth * SIXTEENTH;
-    if (sixteenth === 1 || sixteenth === 3) {
-      const swung = effectiveSwing(sec.feel, ctx.swingAmount) * hatSwingFactor(sec.style);
-      hhTick = quantizeSwing(hhTick, swung, 'sixteenth');
-    }
-    const metricVel = hiHatVelocityMultiplier(sixteenth, ctx.rng);
-    const hhVel = Math.max(20, ctx.velocity * dm * typeMult * metricVel);
-    if (isDynamicOpen && sixteenth === 0) {
-      ctx.track.add(GM.OHH, hhTick, SIXTEENTH, hhVel + OHH_VEL_BOOST);
-      continue;
-    }
-    if (ctx.beat === 3 && sixteenth === 3) {
-      const openProb = Math.max(0.1, Math.min(0.4, 30 / ctx.bpm));
-      if (ctx.rng.prob(openProb)) {
-        ctx.track.add(GM.OHH, hhTick, SIXTEENTH, Math.max(20, hhVel * 1.2));
-        continue;
-      }
-    }
-    ctx.track.add(hhInstrument, hhTick, SIXTEENTH / 2, hhVel);
-  }
-}

package/src/generate/drums/euclid.ts

@@ -1,58 +0,0 @@
-/**
- * Generate a euclidean onset pattern (Bjorklund's algorithm), distributing
- * `pulses` as evenly as possible across `steps`, then rotating.
- *
- * @param pulses Number of onsets, clamped to [0, steps].
- * @param steps Total steps (>= 1).
- * @param rotation Steps to rotate onsets toward later positions.
- * @returns One boolean per step; true marks an onset.
- */
-export function euclideanRhythm(pulses: number, steps: number, rotation = 0): boolean[] {
-  if (steps < 1) {
-    return [];
-  }
-  const p = Math.max(0, Math.min(pulses, steps));
-  const base = bjorklund(p, steps);
-  const shift = ((rotation % steps) + steps) % steps;
-  if (shift === 0) {
-    return base;
-  }
-  return base.map((_, i) => base[(i - shift + steps) % steps] ?? false);
-}
-
-/** True when the 16-step bitmask has an onset at `step`. */
-export function hasHit(mask: number, step: number): boolean {
-  return ((mask >> step) & 1) === 1;
-}
-
-/** Convert a euclidean boolean pattern to a 16-step bitmask (LSB = step 0). */
-export function patternToMask(pattern: boolean[]): number {
-  let mask = 0;
-  for (let i = 0; i < pattern.length; i += 1) {
-    if (pattern[i]) {
-      mask |= 1 << i;
-    }
-  }
-  return mask;
-}
-
-function bjorklund(pulses: number, steps: number): boolean[] {
-  if (pulses === 0) {
-    return Array.from({ length: steps }, () => false);
-  }
-  if (pulses >= steps) {
-    return Array.from({ length: steps }, () => true);
-  }
-  let head: boolean[][] = Array.from({ length: pulses }, () => [true]);
-  let remainder: boolean[][] = Array.from({ length: steps - pulses }, () => [false]);
-  while (remainder.length > 1) {
-    const count = Math.min(head.length, remainder.length);
-    const next: boolean[][] = [];
-    for (let i = 0; i < count; i += 1) {
-      next.push([...(head[i] ?? []), ...(remainder[i] ?? [])]);
-    }
-    remainder = head.length > count ? head.slice(count) : remainder.slice(count);
-    head = next;
-  }
-  return [...head.flat(), ...remainder.flat()];
-}