@libraz/libcantus 0.9.0 → 0.9.2

package/src/{pitch → core/pitch}/index.ts

@@ -24,6 +24,8 @@ const LETTER_NAMES = ['C', 'D', 'E', 'F', 'G', 'A', 'B'] as const;
  *   0 natural, +1 sharp, +2 double-sharp.
  * - `octave` follows scientific pitch notation (middle C = C4 = MIDI 60). When
  *   absent, the note denotes a bare pitch class.
+ *
+ * @category Pitch & Intervals
  */
 export type Note = {
   letter: number;
@@ -31,7 +33,11 @@ export type Note = {
   octave?: number;
 };
 
-/** A spelled interval: a diatonic number, a quality label, and its semitone span. */
+/**
+ * A spelled interval: a diatonic number, a quality label, and its semitone span.
+ *
+ * @category Pitch & Intervals
+ */
 export type SpelledInterval = {
   /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */
   number: number;
@@ -62,6 +68,13 @@ function mod7(n: number): number {
  * @param text The note text.
  * @returns The parsed note.
  * @throws If the text is not a valid note.
+ * @example
+ * ```ts
+ * import { parseNote, noteToMidi } from '@libraz/libcantus';
+ * const n = parseNote('C#4');
+ * noteToMidi(n); // 61
+ * ```
+ * @category Pitch & Intervals
  */
 export function parseNote(text: string): Note {
   const match = /^([A-Ga-g])([#x]*|b*)(-?\d+)?$/.exec(text.trim());
@@ -103,6 +116,12 @@ function formatAlter(alter: number): string {
  *
  * @param note The note to format.
  * @returns The note text, including the octave when present.
+ * @example
+ * ```ts
+ * import { formatNote, parseNote } from '@libraz/libcantus';
+ * formatNote(parseNote('C#4')); // 'C#4'
+ * ```
+ * @category Pitch & Intervals
  */
 export function formatNote(note: Note): string {
   const glyph = LETTER_NAMES[mod7(note.letter)] ?? 'C';
@@ -115,6 +134,12 @@ export function formatNote(note: Note): string {
  *
  * @param note The note.
  * @returns The pitch class.
+ * @example
+ * ```ts
+ * import { noteToPitchClass, parseNote } from '@libraz/libcantus';
+ * noteToPitchClass(parseNote('Db')); // 1
+ * ```
+ * @category Pitch & Intervals
  */
 export function noteToPitchClass(note: Note): number {
   const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;
@@ -127,6 +152,12 @@ export function noteToPitchClass(note: Note): number {
  * @param note The note; must carry an octave.
  * @returns The MIDI number.
  * @throws If the note has no octave.
+ * @example
+ * ```ts
+ * import { noteToMidi, parseNote } from '@libraz/libcantus';
+ * noteToMidi(parseNote('A4')); // 69
+ * ```
+ * @category Pitch & Intervals
  */
 export function noteToMidi(note: Note): number {
   if (note.octave === undefined) {
@@ -170,9 +201,20 @@ const FLAT_SPELLING: readonly [number, number][] = [
 /**
  * Name a MIDI number as a {@link Note}, choosing sharp or flat spelling.
  *
+ * The input is rounded to the nearest integer but is not clamped to the MIDI
+ * range 0..127: out-of-range values extrapolate linearly (e.g. `-1` -> `B-2`,
+ * `128` -> `G#9`) and remain an exact inverse of {@link noteToMidi}.
+ *
  * @param midi The MIDI number.
  * @param spelling Whether to prefer sharps or flats for black keys.
  * @returns The spelled note, with octave.
+ * @example
+ * ```ts
+ * import { midiToNote, formatNote } from '@libraz/libcantus';
+ * formatNote(midiToNote(61)); // 'C#4'
+ * formatNote(midiToNote(61, 'flat')); // 'Db4'
+ * ```
+ * @category Pitch & Intervals
  */
 export function midiToNote(midi: number, spelling: 'sharp' | 'flat' = 'sharp'): Note {
   const rounded = Math.round(midi);
@@ -227,6 +269,13 @@ function diatonicIndex(note: Note): number {
  * @param a The lower/first note.
  * @param b The upper/second note.
  * @returns The diatonic number, quality, and semitone span.
+ * @example
+ * ```ts
+ * import { spelledInterval, parseNote } from '@libraz/libcantus';
+ * spelledInterval(parseNote('C4'), parseNote('G4'));
+ * // { number: 5, quality: 'P', semitones: 7 }
+ * ```
+ * @category Pitch & Intervals
  */
 export function spelledInterval(a: Note, b: Note): SpelledInterval {
   const octaved = a.octave !== undefined && b.octave !== undefined;
@@ -240,11 +289,17 @@ export function spelledInterval(a: Note, b: Note): SpelledInterval {
     letterSteps = mod7(b.letter - a.letter);
     let rawSemis = mod12(noteToPitchClass(b) - noteToPitchClass(a));
     // Lift the chromatic span into the octave nearest the diatonic reference so
-    // wraparound intervals (e.g. Ab -> G# = augmented seventh) stay consistent
-    // with the ascending diatonic number instead of collapsing modulo 12.
+    // wraparound intervals stay consistent with the diatonic number instead of
+    // collapsing modulo 12. The correction is bidirectional: an upward wrap
+    // (e.g. Ab -> G# = augmented seventh) adds an octave, while a same-letter or
+    // downward chromatic step (e.g. E -> Eb, F# -> F, C -> Cb = descending
+    // diminished/augmented unison) subtracts one so the sign follows pitch
+    // direction instead of returning a garbage stack of augmentations.
     const reference = SIMPLE_REFERENCE[letterSteps + 1] ?? 0;
     if (reference - rawSemis > 6) {
       rawSemis += 12;
+    } else if (rawSemis - reference > 6) {
+      rawSemis -= 12;
     }
     semitones = rawSemis;
   }

package/src/{random → core/random}/index.ts

@@ -5,7 +5,11 @@
  * seed the stream is fully reproducible.
  */
 
-/** A deterministic PRNG with the sampling helpers the generators need. */
+/**
+ * A deterministic PRNG with the sampling helpers the generators need.
+ *
+ * @category Utilities
+ */
 export type Rng = {
   /** Next float in [0, 1). */
   next: () => number;
@@ -22,6 +26,14 @@ export type Rng = {
  *
  * @param seed The 32-bit seed; the same seed always yields the same stream.
  * @returns The seeded generator.
+ * @example
+ * ```ts
+ * import { createRng } from '@libraz/libcantus';
+ * const rng = createRng(42);
+ * rng.next(); // deterministic float in [0, 1)
+ * rng.range(1, 6); // deterministic integer in [1, 6]
+ * ```
+ * @category Utilities
  */
 export function createRng(seed: number): Rng {
   let state = seed >>> 0;

package/src/{tuning → core/tuning}/index.ts

@@ -11,6 +11,8 @@
 /**
  * An equal-tempered tuning: a reference pitch and a number of equal divisions of
  * the octave. With `divisions === 12` a step index is an ordinary MIDI number.
+ *
+ * @category Pitch & Intervals
  */
 export type Tuning = {
   /** Step index (MIDI number when `divisions` is 12) whose frequency is `refFreq`. */
@@ -21,7 +23,11 @@ export type Tuning = {
   divisions: number;
 };
 
-/** Standard twelve-tone equal temperament, A4 (MIDI 69) = 440 Hz. */
+/**
+ * Standard twelve-tone equal temperament, A4 (MIDI 69) = 440 Hz.
+ *
+ * @category Pitch & Intervals
+ */
 export const TWELVE_TET: Tuning = { refStep: 69, refFreq: 440, divisions: 12 };
 
 /**
@@ -31,6 +37,13 @@ export const TWELVE_TET: Tuning = { refStep: 69, refFreq: 440, divisions: 12 };
  * @param refFreq Reference frequency in Hz (default 440).
  * @param refStep Step index of the reference (default 69).
  * @returns The tuning.
+ * @example
+ * ```ts
+ * import { edo, frequencyOf } from '@libraz/libcantus';
+ * const et19 = edo(19); // { refStep: 69, refFreq: 440, divisions: 19 }
+ * frequencyOf(70, et19); // one 19-EDO step above A4
+ * ```
+ * @category Pitch & Intervals
  */
 export function edo(n: number, refFreq = 440, refStep = 69): Tuning {
   return { refStep, refFreq, divisions: n };
@@ -42,6 +55,13 @@ export function edo(n: number, refFreq = 440, refStep = 69): Tuning {
  * @param step Step index (a MIDI number under 12-EDO).
  * @param tuning The tuning (default 12-TET).
  * @returns The frequency in Hz.
+ * @example
+ * ```ts
+ * import { frequencyOf } from '@libraz/libcantus';
+ * frequencyOf(69); // 440 (A4 in 12-TET)
+ * frequencyOf(60); // middle C in Hz
+ * ```
+ * @category Pitch & Intervals
  */
 export function frequencyOf(step: number, tuning: Tuning = TWELVE_TET): number {
   return tuning.refFreq * 2 ** ((step - tuning.refStep) / tuning.divisions);
@@ -54,6 +74,7 @@ export function frequencyOf(step: number, tuning: Tuning = TWELVE_TET): number {
  * @param freq Frequency in Hz.
  * @param tuning The tuning (default 12-TET).
  * @returns The nearest step index.
+ * @category Pitch & Intervals
  */
 export function nearestStep(freq: number, tuning: Tuning = TWELVE_TET): number {
   return Math.round(tuning.refStep + tuning.divisions * Math.log2(freq / tuning.refFreq));
@@ -65,6 +86,7 @@ export function nearestStep(freq: number, tuning: Tuning = TWELVE_TET): number {
  * @param a Lower/first frequency in Hz.
  * @param b Upper/second frequency in Hz.
  * @returns Cents from `a` to `b` (negative if `b` is lower).
+ * @category Pitch & Intervals
  */
 export function centsBetweenFreq(a: number, b: number): number {
   return 1200 * Math.log2(b / a);
@@ -76,6 +98,7 @@ export function centsBetweenFreq(a: number, b: number): number {
  * @param steps Number of steps.
  * @param tuning The tuning (default 12-TET).
  * @returns The cents.
+ * @category Pitch & Intervals
  */
 export function centsOfSteps(steps: number, tuning: Tuning = TWELVE_TET): number {
   return (steps * 1200) / tuning.divisions;
@@ -88,6 +111,7 @@ export function centsOfSteps(steps: number, tuning: Tuning = TWELVE_TET): number
  * @param numerator Ratio numerator.
  * @param denominator Ratio denominator.
  * @returns The interval in cents.
+ * @category Pitch & Intervals
  */
 export function ratioToCents(numerator: number, denominator: number): number {
   return 1200 * Math.log2(numerator / denominator);
@@ -96,6 +120,8 @@ export function ratioToCents(numerator: number, denominator: number): number {
 /**
  * Five-limit just-intonation ratios for the twelve interval classes above a
  * unison, indexed by semitone class (0..12).
+ *
+ * @category Pitch & Intervals
  */
 export const JUST_RATIOS: Record<number, [number, number]> = {
   0: [1, 1],
@@ -119,6 +145,7 @@ export const JUST_RATIOS: Record<number, [number, number]> = {
  *
  * @param semitoneClass Semitone class in [0, 12].
  * @returns The deviation in cents, or NaN if the class has no listed ratio.
+ * @category Pitch & Intervals
  */
 export function justDeviationCents(semitoneClass: number): number {
   const ratio = JUST_RATIOS[semitoneClass];

package/src/{bass → generate/bass}/index.ts

@@ -12,35 +12,63 @@
  * library-wide convention.
  */
 
-import type { Chord } from '../chord/index.js';
-import { isStrongBeat, type TimeSignature } from '../meter/index.js';
-import { createRng } from '../random/index.js';
-import { nearestScaleTone } from '../scale/index.js';
-import type { KeyScale, NoteEvent } from '../types.js';
+import { isStrongBeat, type TimeSignature } from '../../core/meter/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 { nearestScaleTone } from '../../theory/scale/index.js';
 
-/** A chord sounding over a half-open beat span `[startBeat, endBeat)`. */
+/**
+ * A chord sounding over a half-open beat span `[startBeat, endBeat)`.
+ *
+ * @category Composition
+ */
 export type BassSegment = {
   startBeat: number;
   endBeat: number;
   chord: Chord;
 };
 
-/** The bass-line idiom to generate. */
+/**
+ * The bass-line idiom to generate.
+ *
+ * @category Composition
+ */
 export type BassStyle = 'root' | 'rootFifth' | 'pop' | 'walking' | 'arpeggio';
 
-/** Options controlling {@link generateBassLine}. */
+/**
+ * Options controlling {@link generateBassLine}.
+ *
+ * @category Composition
+ */
 export type BassLineOptions = {
   /** Chord placement to follow; need not be pre-sorted. */
   segments: BassSegment[];
   /** Key/scale context, used for diatonic approach tones in `walking`. */
   key: KeyScale;
-  /** Time signature; used for metric accents. Default 4/4. */
+  /**
+   * Time signature; used for metric accents.
+   *
+   * @defaultValue `{ numerator: 4, denominator: 4 }`
+   */
   ts?: TimeSignature;
-  /** Bass-line idiom. Default `'root'`. */
+  /**
+   * Bass-line idiom.
+   *
+   * @defaultValue `'root'`
+   */
   style?: BassStyle;
-  /** Target register as a base MIDI octave; roots land around `octave*12+12`. Default 2. */
+  /**
+   * Target register as a base MIDI octave; roots land around `octave*12+12`.
+   *
+   * @defaultValue 2
+   */
   octave?: number;
-  /** Seed for the deterministic PRNG. Default 0. */
+  /**
+   * Seed for the deterministic PRNG.
+   *
+   * @defaultValue 0
+   */
   seed?: number;
 };
 
@@ -98,10 +126,18 @@ function chordTonePcs(chord: Chord): number[] {
   return pcs;
 }
 
-/** The chord's perfect-fifth pitch class, falling back to the root when absent. */
+/**
+ * The chord's fifth pitch class.
+ *
+ * Uses the perfect fifth when present, otherwise the chord's actual altered
+ * fifth (diminished = 6, augmented = 8 semitones above the root), so dim/aug/
+ * m7b5 chords sound their real fifth rather than a repeated root. Falls back to
+ * the root only when the chord has no fifth degree at all.
+ */
 function fifthPcOf(chord: Chord): number {
-  const hasFifth = chord.intervals.some((i) => pitchClass(i) === 7);
-  return hasFifth ? pitchClass(chord.rootPc + 7) : pitchClass(chord.rootPc);
+  const fifths = new Set(chord.intervals.map((i) => pitchClass(i)));
+  const chosen = fifths.has(7) ? 7 : fifths.has(6) ? 6 : fifths.has(8) ? 8 : undefined;
+  return chosen === undefined ? pitchClass(chord.rootPc) : pitchClass(chord.rootPc + chosen);
 }
 
 /** The sounding bass pitch class of a chord: its slash bass, else its root. */
@@ -166,9 +202,10 @@ function buildPop(ctx: BuildContext, seg: BassSegment): void {
       emitted = true;
     } else if (ctx.rng.prob(PICKUP_PROB)) {
       if (ctx.rng.prob(0.5)) {
-        // Octave pickup: the root an octave below the band anchor.
+        // Octave pickup: the root dropped toward the bottom of the register,
+        // clamped so it never falls below the declared band.
         const base = placePc(rootPc, ctx.prevMidi, ctx.low);
-        emit(ctx, pos, rootPc, base - 12);
+        emit(ctx, pos, rootPc, Math.max(ctx.low, base - 12));
       } else {
         ctx.prevMidi = emit(ctx, pos, fifthPcOf(seg.chord));
       }
@@ -231,6 +268,18 @@ function buildWalking(ctx: BuildContext, seg: BassSegment, next: BassSegment | u
  *
  * @param opts Segments, key, and generation options.
  * @returns Bass notes sorted by onset, non-overlapping.
+ *
+ * @example
+ * ```ts
+ * import { generateBassLine, makeChord, majorKey } from '@libraz/libcantus';
+ * const segments = [
+ *   { startBeat: 0, endBeat: 4, chord: makeChord(0, 'maj') },
+ *   { startBeat: 4, endBeat: 8, chord: makeChord(7, 'maj') },
+ * ];
+ * const notes = generateBassLine({ segments, key: majorKey(0), style: 'walking' });
+ * ```
+ *
+ * @category Composition
  */
 export function generateBassLine(opts: BassLineOptions): NoteEvent[] {
   const segments = [...opts.segments].sort((a, b) => a.startBeat - b.startBeat);

package/src/{countermelody → generate/countermelody}/index.ts

@@ -1,20 +1,20 @@
-import type { Chord } from '../chord/index.js';
-import { chordToneRole } from '../chord/index.js';
-import {
-  createsParallelOctave,
-  createsParallelPerfect,
-  isForbiddenMelodicLeap,
-} from '../counterpoint/index.js';
-import type { TimeSignature } from '../meter/index.js';
-import { isStrongBeat } from '../meter/index.js';
-import type { Rng } from '../random/index.js';
-import { createRng } from '../random/index.js';
-import type { VoiceSnapshot } from '../safety/index.js';
-import { enumerateSafePitches } from '../safety/index.js';
-import { nearestScaleTone } from '../scale/index.js';
-import type { KeyScale, NoteEvent } from '../types.js';
+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}. */
+/**
+ * Options controlling {@link generateCounterMelody}.
+ *
+ * @category Voicing & Counterpoint
+ */
 export type CounterMelodyOptions = {
   /** The lead line to write against, in ascending onset order. */
   melody: NoteEvent[];
@@ -22,22 +22,40 @@ export type CounterMelodyOptions = {
   chordAt: (beat: number) => Chord | null;
   /** Key/scale context for scale-tone decisions. */
   key: KeyScale;
-  /** Meter used for strong-beat decisions (default 4/4). */
+  /**
+   * Meter used for strong-beat decisions.
+   *
+   * @defaultValue 4/4
+   */
   ts?: TimeSignature;
-  /** Which side of the melody the counter line occupies (default `'below'`). */
+  /**
+   * Which side of the melody the counter line occupies.
+   *
+   * @defaultValue 'below'
+   */
   register?: 'above' | 'below';
   /**
-   * Onset strategy: `'complement'` (default) moves where the melody holds or
-   * rests and reinforces some strong beats; `'follow'` mirrors melody onsets.
+   * 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 (default `'pop'`). */
+  /**
+   * 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 (default 0). */
+  /**
+   * PRNG seed; the same seed always yields the same line.
+   *
+   * @defaultValue 0
+   */
   seed?: number;
 };
 
@@ -244,6 +262,17 @@ function fallbackPitch(
  *
  * @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);
@@ -309,8 +338,9 @@ export function generateCounterMelody(opts: CounterMelodyOptions): NoteEvent[] {
         if (
           prevPitch !== undefined &&
           melPrev !== undefined &&
-          (createsParallelPerfect(prevPitch, candidate, melPrev, melPitch) ||
-            createsParallelOctave(prevPitch, candidate, melPrev, melPitch))
+          // 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;
         }

package/src/{drums → generate/drums}/fills.ts

@@ -32,7 +32,19 @@ export function getFillStartBeat(energy: SectionEnergy): number {
   }
 }
 
-/** Pick a fill archetype from the transition context. */
+/**
+ * Pick a fill archetype for a section transition.
+ *
+ * The transition-specific archetypes (into a chorus, out of an intro) are
+ * checked before the generic energy fills so every variation stays reachable;
+ * with `from === to` the caller effectively asks for a within-section fill.
+ *
+ * @param from Section the fill leaves.
+ * @param to Section the fill leads into.
+ * @param style Internal drum style.
+ * @param nextEnergy Energy of the section the fill leads into.
+ * @param rng Deterministic PRNG.
+ */
 export function selectFillType(
   from: SectionType,
   to: SectionType,
@@ -44,6 +56,11 @@ export function selectFillType(
     return rng.range(0, 1) === 0 ? 'simpleCrash' : 'breakdownFill';
   }
 
+  const toChorus = to === 'chorus';
+  const fromIntro = from === 'intro';
+  const highEnergy = style === 'rock' || style === 'fourOnFloor';
+
+  // Dropping into a low-energy section: keep the phrase end gentle.
   if (nextEnergy === 'low') {
     switch (rng.range(0, 2)) {
       case 0:
@@ -55,25 +72,9 @@ export function selectFillType(
     }
   }
 
-  if (nextEnergy === 'peak') {
-    switch (rng.range(0, 3)) {
-      case 0:
-        return 'tomDescend';
-      case 1:
-        return 'snareRoll';
-      case 2:
-        return 'linearFill';
-      default:
-        return 'flamsAndDrags';
-    }
-  }
-
-  const toChorus = to === 'chorus';
-  const fromIntro = from === 'intro';
-  const highEnergy = style === 'rock' || style === 'fourOnFloor';
-  const choice = rng.range(0, 7);
-
+  // Big lead-ins to a chorus take precedence over the generic energy fills.
   if (toChorus) {
+    const choice = rng.range(0, 7);
     if (highEnergy) {
       switch (choice) {
         case 0:
@@ -110,8 +111,9 @@ export function selectFillType(
     }
   }
 
+  // Leaving the intro: lighter, building character.
   if (fromIntro) {
-    switch (choice) {
+    switch (rng.range(0, 5)) {
       case 0:
       case 1:
         return 'snareRoll';
@@ -126,6 +128,8 @@ export function selectFillType(
     }
   }
 
+  // Generic medium/high/peak fills, split by style energy.
+  const choice = rng.range(0, 7);
   if (highEnergy) {
     switch (choice) {
       case 0:
@@ -339,6 +343,13 @@ export function generateFill(
       if (beat === 2) {
         track.add(GM.SD, beatTick, 1, accentVel);
         track.add(GM.BD, beatTick, 1, fillVel);
+      } else if (beat === 3) {
+        // At low energy the fill spans only beat 3, so this branch keeps the
+        // phrase end from going silent: a broad half-time backbeat snare with a
+        // light pickup into the next section.
+        track.add(GM.SD, beatTick, EIGHTH, accentVel);
+        track.add(GM.SD, beatTick + E, S, fillVel * 0.6);
+        track.add(GM.SD, beatTick + E + S, S, accentVel);
       }
       break;
   }