@libraz/libcantus 0.9.4 → 1.0.0

package/dist/generate/index.d.ts

@@ -1,1294 +1,636 @@
-import { B as BorrowedSource, H as HarmonicFunction } from '../function-BtiZb9i9.js';
-import { K as KeyScale, N as NoteEvent } from '../types-BN6_Q9Kl.js';
-import { b as ChordSegment, C as Chord, a as ChordQuality, c as ChordSpan } from '../index-C83mZI1P.js';
-export { d as ChordToneRole, P as PitchSpelling } from '../index-C83mZI1P.js';
-import { a as ChordTimeline } from '../index-C5UBbQ4G.js';
-import { T as TimeSignature } from '../index-DXd9JikN.js';
-import { H as HarmonyRole } from '../index-tSQh-xwY.js';
+import { a as Articulation, g as NoteEvent, I as IntervalLike } from '../index-B9MNZboQ.js';
+export { b as IntervalQualityLabel, d as KeyScale, S as SpelledInterval } from '../index-B9MNZboQ.js';
+import { e as ChordSegment, c as ChordLike, K as KeyLike } from '../index-szBv3496.js';
+export { b as ChordData, d as ChordQuality, g as ChordSpan, j as ChordToneRole, l as PitchSpelling, m as ProfileWeights } from '../index-szBv3496.js';
+export { B as BorrowedSource, e as ChordTimeline, H as HarmonicFunction } from '../index-Chbst3Jx.js';
+import { f as StringedProfile, P as PercussionProfile, c as Limb } from '../positional-Cptlj-xs.js';
+export { I as InstrumentProfile, a as InstrumentProfileCommon, d as PositionalRng, S as SeedPath } from '../positional-Cptlj-xs.js';
+import { T as TimeSignature } from '../index-Cj49F892.js';
+export { H as HarmonyRole } from '../index-CunYKLiu.js';
+import { a3 as Vocabulary, s as GridEvent, r as Genre, q as GenerationContextInput, m as DrumStyle, $ as Section, n as DrumVoice, t as GrooveFeel, k as DrumHit } from '../index-CgHqxdps.js';
+export { B as BAR_STEPS, a as BASS_STYLES, b as BEAT_STEPS, c as BORROWED_DEGREES, d as BassLineOptions, e as BassSegment, f as BassStyle, g as BorrowedChord, C as Complexity, h as CounterMelodyOptions, D as DRUM_NOTES, i as DeformOptions, j as Draw, l as DrumRole, o as DrumsOptions, E as EuclideanKick, G as GENRES, p as GenerationContext, u as GrooveSlot, v as GrooveStyle, w as GrooveTemplate, H as HarmonizeOptions, x as HarmonizePlacement, y as HarmonizeResult, z as HumanizeOptions, M as MelodyNote, A as MotifCell, F as MotifContour, I as MotifNote, J as MotifOptions, K as MotifTransform, O as ORNAMENT_STYLES, L as OrnamentOptions, N as OrnamentStyle, P as PROVENANCE_BASES, Q as ProgFunction, R as ProgStyle, S as ProgressionDegree, T as ProgressionOptions, U as ProgressionPreset, V as Provenance, W as ProvenanceBasis, X as ResolvedContext, Y as RhythmEvent, Z as RhythmOptions, _ as STEP_BEATS, a0 as SubstituteOptions, a1 as Substitution, a2 as SubstitutionType, a4 as VocabularyQuery, a5 as applyGrooveTemplate, a6 as assertVocabulary, a7 as deform, a8 as developMotif, a9 as double, aa as doubleTime, ab as drumVoiceOf, ac as extractGrooveTemplate, ad as fitsQuery, ae as generateBassLine, af as generateCounterMelody, ag as generateDrums, ah as generateMotif, ai as generateProgression, aj as generateRhythm, ak as gridMetricWeight, al as halfTime, am as harmonizeMelody, an as humanize, ao as mergeVocabulary, ap as modalInterchangePalette, aq as motifToNoteEvents, ar as negativeHarmonyMirror, as as onsetWeightCurve, at as ornament, au as ornamentBy, av as pickProgressionPreset, aw as pickVocabulary, ax as progressions, ay as progressionsByStyle, az as resolveContext, aA as rhythmDensity, aB as rhythmToNoteEvents, aC as selectVocabulary, aD as substituteChord, aE as syncopate, aF as thin, aG as transformMotif, aH as vocabularyOfKind, aI as withinCeiling } from '../index-CgHqxdps.js';
 
 /**
- * Deterministic bass-line generation over a chord placement.
+ * The playing-difficulty ceiling, as the generators apply it.
  *
- * Given a sequence of chord segments and a key, this builds a monophonic bass
- * line in a chosen low register. Several idiomatic styles are supported, from a
- * single held root per segment to a quarter-note walking line that leads by
- * step into each chord change. All pitches are kept in a narrow bass band and
- * consecutive notes move by small intervals; given a seed the output is fully
- * reproducible.
- *
- * Positions and durations are measured in quarter-note beats, matching the
- * library-wide convention.
- */
-
-/**
- * A chord sounding over a half-open beat span `[startBeat, endBeat)`.
- *
- * The same record {@link ChordSegment} names, so a timeline segment can be fed
- * straight to the bass generator.
- *
- * @category Composition
- */
-type BassSegment = ChordSegment;
-/**
- * Every bass-line idiom, in declaration order.
- *
- * @category Composition
- */
-declare const BASS_STYLES: readonly ["root", "rootFifth", "pop", "walking", "arpeggio"];
-/**
- * The bass-line idiom to generate.
- *
- * @category Composition
+ * A ceiling is not an intensity: a passage can be harmonically involved and
+ * easy to play, or plain and hard. So difficulty never proposes material — it
+ * only rejects what the other complexity dials proposed, and only on the
+ * timing layer, where speed is what stands in the way. Whether the note exists
+ * on the instrument at all, and whether the hand can hold the shape, belong to
+ * the instrument profile and hold regardless of the ceiling.
  */
-type BassStyle = (typeof BASS_STYLES)[number];
+/** The ceiling's lowest level: what a beginner sustains. */
+declare const MIN_DIFFICULTY = 1;
+/** The ceiling's highest level: what a rudimental player sustains. */
+declare const MAX_DIFFICULTY = 5;
 /**
- * Options controlling {@link generateBassLine}.
+ * Whether a player at this ceiling keeps up a stream of strokes on one voice.
  *
- * @category Composition
+ * @param stepBeats Gap between consecutive strokes, in quarter-note beats.
+ * @param bpm Tempo, or undefined when the caller gave none.
+ * @param difficulty The ceiling, or undefined for no ceiling.
+ * @returns True when the stream is inside the ceiling, and whenever either the
+ *   ceiling or the tempo is unknown — a limit nobody stated constrains nothing.
  */
-type BassLineOptions = {
-    /** Chord placement to follow; need not be pre-sorted. */
-    segments: readonly BassSegment[];
-    /** Key/scale context, used for diatonic approach tones in `walking`. */
-    key: KeyScale;
-    /**
-     * Time signature; used for metric accents.
-     *
-     * @defaultValue `{ numerator: 4, denominator: 4 }`
-     */
-    ts?: TimeSignature;
-    /**
-     * Bass-line idiom.
-     *
-     * @defaultValue `'root'`
-     */
-    style?: BassStyle;
-    /**
-     * Target register as a base MIDI octave; roots land around `octave*12+12`.
-     * An octave pickup in the `pop` style may drop a note into the octave below
-     * that band, which is where such a pickup belongs.
-     *
-     * @defaultValue 2
-     */
-    octave?: number;
-    /**
-     * Seed for the deterministic PRNG.
-     *
-     * @defaultValue 0
-     */
-    seed?: number;
-};
+declare function sustainsStrokes(stepBeats: number, bpm: number | undefined, difficulty: number | undefined): boolean;
 /**
- * Generate a bass line following a chord placement.
- *
- * Each segment contributes notes in the chosen bass register per the selected
- * style; consecutive notes are kept within roughly a fifth. Every note's
- * duration extends to the next onset (the final note extends to the last
- * segment's end). Given a seed the output is fully reproducible.
- *
- * @param opts Segments, key, and generation options.
- * @returns Bass notes sorted by onset, non-overlapping.
+ * Whether the fretting hand covers a leap in the time available.
  *
- * @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
+ * @param semitones Distance moved; on a fretted neck one fret is one semitone.
+ * @param stepBeats Time to move it in, in quarter-note beats.
+ * @param bpm Tempo, or undefined when the caller gave none.
+ * @param difficulty The ceiling, or undefined for no ceiling.
+ * @returns True when the shift is inside the ceiling, and whenever either the
+ *   ceiling or the tempo is unknown.
  */
-declare function generateBassLine(opts: BassLineOptions): NoteEvent[];
+declare function sustainsShift(semitones: number, stepBeats: number, bpm: number | undefined, difficulty: number | undefined): boolean;
 
 /**
- * Options controlling {@link generateCounterMelody}.
+ * The bass lick dictionary: the figures a bass player reaches for, held as
+ * chord-relative degrees and beat positions and deformed to fit the progression
+ * actually in front of them.
  *
- * @category Voicing & Counterpoint
+ * Provenance: no entry reproduces a bass line from a particular song. Each is a
+ * figure that belongs to nobody — the descending soul walk-down, the octave
+ * slap, the boogie shuffle — of the kind every player of that music already
+ * plays, and each records the ground it qualifies under.
  */
-type CounterMelodyOptions = {
-    /** The lead line to write against, in ascending onset order. */
-    melody: readonly NoteEvent[];
-    /**
-     * The harmony to write against. A timeline carries its own segment
-     * boundaries, so a chord change anywhere — including off the generator's
-     * half-beat probe grid — is seen; prefer it over `chordAt`.
-     *
-     * Exactly one of `timeline` and `chordAt` is required; `timeline` wins when
-     * both are given.
-     */
-    timeline?: ChordTimeline;
-    /**
-     * Chord sounding at an absolute beat position, or null when none applies.
-     *
-     * A callback is opaque: the generator cannot see where it changes, so it
-     * probes a half-beat grid and otherwise relies on `chordChangeBeats`. A held
-     * counter note that spans an unseen change is not checked against the new
-     * chord.
-     */
-    chordAt?: (beat: number) => Chord | null;
-    /**
-     * Exact chord-change beats the `chordAt` callback does not expose. Ignored
-     * when `timeline` is given, since a timeline lists its own boundaries.
-     */
-    chordChangeBeats?: number[];
-    /** 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. It places the `'complement'` onsets and breaks ties between
-     * equally good candidate pitches; the same seed always yields the same line.
-     * Where the constraints leave only one good answer — which is common with
-     * `rhythm: 'follow'`, whose onsets are fixed by the melody — changing the seed
-     * changes nothing.
-     *
-     * @defaultValue 0
-     */
-    seed?: number;
-};
-/**
- * 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 are broken by a seeded perturbation far
- * below any real score difference (see `TIE_BREAK_JITTER`), so the same
- * seed always yields the same line while a different seed can only reshuffle
- * candidates that were already equally good. 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
- */
-declare function generateCounterMelody(opts: CounterMelodyOptions): NoteEvent[];
 
 /**
- * The percussion voices the generator emits, as General MIDI note numbers.
+ * One note of a lick, relative to the chord it is played over.
  *
- * A {@link DrumHit} carries only its pitch, so splitting a kit across tracks —
- * kick to one, snare to another — means comparing against these numbers. They
- * are published so that comparison is a named constant covered by semver
- * rather than a hard-coded 36.
+ * A degree is 1-based and counts up from the chord's root: 1 is the root, 3 the
+ * third, 8 the octave. Degrees the chord itself names — the third, fifth and
+ * seventh — are taken from the chord, so the same figure comes out major over a
+ * major chord and minor over a minor one; the rest are taken from the key. That
+ * is what lets a figure be written once and fit a whole progression.
  *
- * @example
- * ```ts
- * import { DRUM_NOTES, generateDrums } from '@libraz/libcantus';
- * const hits = generateDrums({ bars: 1, bpm: 120, style: 'standard', section: 'verse', density: 0.5 });
- * const kick = hits.filter((hit) => hit.pitch === DRUM_NOTES.kick);
- * ```
  * @category Composition
  */
-declare const DRUM_NOTES: {
-    readonly kick: 36;
-    readonly snare: 38;
-    readonly sideStick: 37;
-    readonly handClap: 39;
-    readonly closedHiHat: 42;
-    readonly pedalHiHat: 44;
-    readonly openHiHat: 46;
-    readonly crash: 49;
-    readonly ride: 51;
-    readonly tambourine: 54;
-    readonly highTom: 50;
-    readonly midTom: 47;
-    readonly lowTom: 45;
-    readonly shaker: 82;
+type LickNote = GridEvent & {
+    /** Chord degree, 1-based; 8 is the octave above the root. */
+    degree: number;
+    /** Chromatic alteration in semitones, for a flattened or raised degree. */
+    alter?: number;
+    /** Sounding length in sixteenths; one step when absent. */
+    lengthSteps?: number;
+    /** How the note is played, when it is more than a plain note. */
+    articulation?: Articulation;
 };
 /**
- * A percussion voice name, one key of {@link DRUM_NOTES}.
- *
- * @category Composition
- */
-type DrumVoice = keyof typeof DRUM_NOTES;
-/**
- * The voice a percussion note number names.
+ * A lick: its notes and how long the whole figure lasts.
  *
- * @param pitch The General MIDI note number.
- * @returns The voice, or undefined for a note this generator never emits.
  * @category Composition
  */
-declare function drumVoiceOf(pitch: number): DrumVoice | undefined;
-/**
- * A single percussion onset.
- *
- * @category Composition
- */
-type DrumHit = {
-    /** General MIDI note number; {@link drumVoiceOf} names it. */
-    pitch: number;
-    startBeat: number;
-    durationBeat: number;
-    velocity: number;
+type LickMaterial = {
+    /** Length of the figure in sixteenths. */
+    lengthSteps: number;
+    notes: LickNote[];
 };
-
-/** Every groove feel, in declaration order. */
-declare const DRUM_FEELS: readonly ["straight", "swing", "shuffle"];
-/** Groove feel controlling off-beat swing. */
-type Feel = (typeof DRUM_FEELS)[number];
-/**
- * Every public groove style, in declaration order. The type is derived from
- * this list so the runtime guard and the type can never disagree.
- */
-declare const GROOVE_STYLES: readonly ["standard", "funk", "shuffle", "bossa", "trap", "halftime", "breakbeat", "house", "synthpop"];
 /**
- * Public groove style identifiers.
+ * A lick with the conditions it fits.
  *
  * @category Composition
  */
-type GrooveStyle = (typeof GROOVE_STYLES)[number];
-/** Every public role, in declaration order. */
-declare const DRUM_ROLES: readonly ["full", "ambient", "minimal", "fxOnly"];
+type BassLick = Vocabulary<LickMaterial>;
 /**
- * Public role identifiers gating which voices are present.
+ * Whether a caller's material is a bass lick.
  *
  * @category Composition
  */
-type DrumRole = (typeof DRUM_ROLES)[number];
-/** Every public section, in declaration order. */
-declare const PUBLIC_SECTIONS: readonly ["intro", "verse", "prechorus", "chorus", "bridge", "outro"];
-/** Public section identifiers. */
-type PublicSection = (typeof PUBLIC_SECTIONS)[number];
-
+declare function isLickMaterial(material: unknown): material is LickMaterial;
 /**
- * Groove feel (the swing/straight rhythmic character) for {@link generateDrums}.
+ * The built-in bass licks, in declaration order.
  *
  * @category Composition
  */
-type GrooveFeel = Feel;
-
+declare const BASS_LICKS: readonly BassLick[];
 /**
- * Public section identifiers for {@link generateDrums}.
+ * Options controlling {@link placeLicks}.
  *
  * @category Composition
  */
-type Section = PublicSection;
-/**
- * A Euclidean (Bjorklund) kick pattern for {@link generateDrums}.
- *
- * @category Composition
- */
-type EuclideanKick = {
-    /** Number of kick onsets, clamped to `[0, steps]`. */
-    pulses: number;
-    /**
-     * Total steps in the bar (1..16).
-     *
-     * @defaultValue 16
-     */
-    steps?: number;
+type PlaceLicksOptions = {
     /**
-     * Steps to rotate the onsets toward later positions.
-     *
-     * @defaultValue 0
+     * The genre whose figures may be used. Genre is what selects the material:
+     * the dials then deform it, and the ceiling rejects it.
      */
-    rotation?: number;
-};
-/**
- * Options controlling {@link generateDrums}.
- *
- * @category Composition
- */
-type DrumsOptions = {
+    genre: Genre;
     /**
-     * Number of bars to generate. Bars are four quarter-note beats long: the
-     * patterns are written for 4/4 and there is no meter option, so a `bars`
-     * count shared with a meter-aware generator such as
-     * {@link generateRhythm} only lines up when that generator is also in 4/4.
+     * The hardest figure that may be used, 1 to 5. Sugar for
+     * `ctx: { complexity: { difficulty } }`; the context wins over both.
      */
-    bars: number;
-    bpm: number;
-    style: GrooveStyle;
-    section: Section;
-    density: number;
+    difficulty?: number;
+    /** Time signature; defaults to 4/4. */
+    ts?: TimeSignature;
     /**
-     * Replace the final bar with a fill.
-     *
-     * A pre-chorus leading into a chorus builds instead: the two-bar lift takes
-     * precedence over the fill, since the buildup already marks the phrase end.
-     * Set `nextSection` to anything but `'chorus'` to get the fill.
+     * Target register as a base MIDI octave; roots land around `octave*12+12`.
      *
-     * @defaultValue false
+     * @defaultValue 2
      */
-    fills?: boolean;
-    feel?: GrooveFeel;
+    octave?: number;
+    /** The instrument the line is written for; its range always applies. */
+    instrument?: StringedProfile;
     /**
-     * Voicing role, from busiest to sparsest:
-     *
-     * - `'full'`: every voice, backbeat snare at full weight.
-     * - `'ambient'`: side-stick backbeat, ride instead of hi-hat.
-     * - `'minimal'`: side-stick backbeat quieter still, pedal hi-hat, no
-     *   auxiliary percussion.
-     * - `'fxOnly'`: no kick, snare, ghost notes, timekeeping hi-hat, or fills —
-     *   only the fx and auxiliary voices.
+     * The generation context. Its `vocabulary` brings the caller's own figures,
+     * its `complexity.ornament` decides how much decoration survives, and its
+     * `complexity.difficulty` is the ceiling figures are rejected against.
      *
-     * The ordering holds in every style and section: a busier role never emits
-     * fewer or quieter voices than a sparser one.
+     * Its `complexity.rhythmic` is how busy the line is, in [0, 1]: it decides
+     * both how often a segment takes a figure at all and, above its middle
+     * setting, how much the figure is syncopated — one dial, because "less busy"
+     * means both. Its `bpm` is the tempo the ceiling is measured against, and its
+     * `seed` fixes which figures are chosen and where they land.
      *
-     * @defaultValue `'full'`
+     * @defaultValue `{ seed: 0, bpm: 120, complexity: { rhythmic: 0.6 } }`
      */
-    role?: DrumRole;
+    ctx?: GenerationContextInput;
     /**
-     * Seed for the deterministic PRNG.
+     * Maximum number of segments {@link placeLicks} may lay figures over. One
+     * figure is placed per segment, so this is the guard against an unbounded
+     * caller rather than a limit on any search.
      *
-     * @defaultValue 0
-     */
-    seed?: number;
-    /**
-     * Section the final-bar fill leads into. Shapes which fill archetype is
-     * chosen (into-chorus and out-of-intro fills differ from generic ones).
-     * Defaults to `section`, i.e. a within-section fill.
-     */
-    nextSection?: Section;
-    /**
-     * When set, the kick follows this Euclidean rhythm instead of the
-     * style/section pattern, giving direct access to evenly spread onsets.
+     * @defaultValue 1000000
      */
-    euclideanKick?: EuclideanKick;
+    budget?: number;
 };
 /**
- * Generate a drum performance as a flat list of onsets.
+ * Lay licks over a chord placement.
  *
- * Every voice (kick, snare, ghost snares, closed/open/foot hi-hats, ride, toms,
- * crash, and auxiliary percussion) is emitted as a {@link DrumHit} distinguished
- * by its General MIDI pitch. Groove style selects an internal style and feel;
- * `density` sets the backing-density level; `section` shapes kick, hi-hat, ghost,
- * and percussion density. 16th-note hi-hats drop to 8ths at or above 150 BPM.
- * When `fills` is true the final bar is replaced with a fill whose archetype is
- * shaped by `nextSection`; a fill that would emit nothing on its beat falls back
- * to the normal groove so the phrase end is never silent. `euclideanKick`
- * overrides the kick with an evenly-spread Euclidean pattern. Output is fully
- * determined by the options plus `seed`.
+ * Each segment is offered the figures whose conditions it meets — the genre,
+ * the chord quality, the tempo, and the difficulty ceiling — and one of them is
+ * chosen by a draw addressed to that segment, so changing a chord elsewhere
+ * leaves this segment's figure where it was. A segment that takes no figure
+ * gets its root, and the last note before a chord change leads into the next
+ * root by step, the way a walking line does.
  *
- * The patterns are 4/4 only — backbeats, hi-hat subdivisions, and fills are all
- * written against a four-beat bar — so beat positions are quarter notes and bar
- * `n` starts at beat `4n`.
- *
- * @param opts Generation options.
- * @returns Percussion onsets in onset order, ties broken by pitch.
+ * @param timeline Chord segments to play over; they need not be pre-sorted, and
+ *   each segment's chord may be written as a chord symbol.
+ * @param key Key context, which answers for the degrees the chords do not; a
+ *   key name such as `'C major'` is read as that key.
+ * @param opts Genre, density, ceiling and seed.
+ * @returns Bass notes sorted by onset, non-overlapping.
+ * @throws If a segment has a non-positive duration, or the genre is not one
+ *   this library names.
  *
  * @example
  * ```ts
- * import { generateDrums } from '@libraz/libcantus';
- * const hits = generateDrums({ bars: 4, bpm: 120, style: 'standard', section: 'chorus', density: 0.6, fills: true });
- * // Fully determined by the options plus seed (defaults to 0).
+ * import { majorKey, makeChord, placeLicks } from '@libraz/libcantus';
+ * const timeline = [
+ *   { startBeat: 0, endBeat: 4, chord: makeChord(0, 'maj7') },
+ *   { startBeat: 4, endBeat: 8, chord: makeChord(5, 'maj7') },
+ * ];
+ * const notes = placeLicks(timeline, majorKey(0), { genre: 'motown', ctx: { seed: 7 } });
  * ```
  *
  * @category Composition
  */
-declare function generateDrums(opts: DrumsOptions): DrumHit[];
+declare function placeLicks(timeline: readonly (Omit<ChordSegment, 'chord'> & {
+    chord: ChordLike;
+})[], key: KeyLike, opts: PlaceLicksOptions): NoteEvent[];
 
 /**
- * Groove and humanization: nudging quantized note events toward a more human
- * feel, and capturing/replaying the timing-and-velocity "feel" of a
- * performance as a reusable groove template.
+ * Imitative entries: a second voice restating what the first has just sung.
  *
- * Positions and durations are measured in quarter-note beats, matching the
- * library-wide convention. Randomness, where used, always goes through the
- * seeded PRNG from the `random` module so results are fully reproducible.
+ * A motif transform has no time relationship to anything — it returns a cell,
+ * and where that cell goes is the caller's problem. An imitation is defined by
+ * that relationship: it enters at a stated beat, at a stated interval, against a
+ * voice that is still sounding. That is what a canon is, and what the answering
+ * phrase in the second half of a chorus is.
  */
 
+/** Every way an imitation can answer, in declaration order. */
+declare const IMITATION_ANSWERS: readonly ["real", "tonal"];
+/**
+ * How an imitation answers the voice it follows.
+ *
+ * A `real` answer transposes literally, keeping every interval of the subject
+ * and leaving the key where the interval puts it. A `tonal` answer counts scale
+ * degrees instead, so the answer stays in the key and adjusts an interval or two
+ * to do it — the fifth of a subject answered by a fourth.
+ *
+ * @category Composition
+ */
+type ImitationAnswer = (typeof IMITATION_ANSWERS)[number];
 /**
- * Options controlling {@link humanize}.
+ * Options controlling {@link imitate}.
  *
- * @category Rhythm & Meter
+ * @category Composition
  */
-type HumanizeOptions = {
+type ImitationOptions = {
     /**
-     * Time signature used to derive metric accents.
-     *
-     * @defaultValue 4/4
+     * Beat at which the imitation enters; the copied material starts here.
+     * Negative like any other onset, for an answer that enters in a pickup.
      */
-    ts?: TimeSignature;
+    atBeat: number;
     /**
-     * Maximum timing jitter in quarter-note beats, applied as ±this value.
-     *
-     * @defaultValue 0.02
+     * Interval to imitate at, spelled: `'P5'` for an answer a fifth above,
+     * `'-P4'` for one a fourth below.
      */
-    timing?: number;
+    interval: IntervalLike;
     /**
-     * Maximum velocity jitter (MIDI units), applied as ±this value.
-     *
-     * @defaultValue 8
+     * The key the answer is measured in; what makes a tonal answer tonal. A key
+     * name such as `'C major'` is read as that key.
      */
-    velocity?: number;
+    key: KeyLike;
     /**
-     * How much louder strong beats get relative to weak ones, in MIDI velocity units.
+     * Whether the answer transposes literally or by scale degree.
      *
-     * @defaultValue 12
+     * @defaultValue 'real'
      */
-    accent?: number;
+    answer?: ImitationAnswer;
     /**
-     * Velocity assumed for events with no `velocity` of their own.
+     * Turn the subject upside down before transposing it, mirroring it about its
+     * own first note: by semitone for a real answer, by scale degree for a tonal
+     * one.
      *
-     * @defaultValue 80
+     * @defaultValue false
      */
-    baseVelocity?: number;
+    invert?: boolean;
+    /** First beat of the lead to imitate; defaults to the start of the line. */
+    from?: number;
+    /** Beat to imitate up to, exclusive; defaults to the end of the line. */
+    to?: number;
     /**
-     * Seed for the deterministic PRNG.
+     * Factor applied to the copied velocities, for an answer that sits under the
+     * voice it follows.
      *
-     * @defaultValue 0
+     * @defaultValue 1
      */
-    seed?: number;
+    velocityScale?: number;
 };
 /**
- * Humanize a sequence of note events by nudging their timing and velocity
- * with small, deterministic (seeded) randomness plus a metric-accent shape:
- * events on strong beats (see {@link metricWeight}) come out louder on
- * average than events on weak ones.
- *
- * Each returned event is a copy; `startBeat` is jittered within
- * `[-timing, +timing]` beats and clamped to be non-negative, and `velocity`
- * is the event's own velocity (or `baseVelocity` if it has none) plus an
- * accent term scaled by the event's metric weight plus a jitter within
- * `[-velocity, +velocity]`, clamped to `[1, 127]` and rounded. The metric
- * weight is computed from each event's original (pre-jitter) `startBeat`.
- * `pitch` and `durationBeat` pass through unchanged, and the output keeps the
- * input order.
- *
- * @param events The events to humanize.
- * @param opts Humanization options.
- * @returns Humanized copies of `events`, in input order.
+ * Answer a leading voice with an imitation of it.
+ *
+ * The chosen span of the lead is copied so that its first note falls on
+ * `atBeat`, keeping its internal rhythm; only the answer is returned, so the
+ * caller decides what to do with the two voices together. Pitches move by
+ * `interval`: literally for a real answer, by scale degree for a tonal one, and
+ * upside down first when `invert` is set. Inversion mirrors about the first note
+ * of the copied span, so the answer starts where the transposition puts that
+ * note either way. In a tonal answer a pitch outside the key keeps its distance
+ * from the scale tone below it, and inversion mirrors that distance too — a
+ * chromatic passing note stays a chromatic passing note, on the other side.
+ * Where a mirrored chromatic note falls into a diatonic semitone the key leaves
+ * it no room, and it lands on the scale tone there, so a subject saturated with
+ * chromatic steps can answer with a pitch repeated.
+ *
+ * @param lead The voice being imitated, in ascending onset order.
+ * @param opts Where the answer enters, at what interval, and in what key.
+ * @returns The imitation as note events sorted by onset; `[]` when the chosen
+ *   span holds no sounding notes. Notes with a zero or negative duration never
+ *   sound and are not copied, so the answer can be shorter than the span.
+ * @throws If the span is reversed, the answer is not a known kind, or a
+ *   transposed pitch leaves the MIDI range.
  * @example
  * ```ts
- * import { humanize } from '@libraz/libcantus';
- * const events = [{ pitch: 60, startBeat: 0, durationBeat: 1, velocity: 80 }];
- * humanize(events, { seed: 1, timing: 0.03 }); // copies with jittered timing and accented velocity
+ * import { imitate, majorKey } from '@libraz/libcantus';
+ * const lead = [0, 1, 2].map((beat) => ({ pitch: 60 + beat, startBeat: beat, durationBeat: 1 }));
+ * imitate(lead, { atBeat: 2, interval: 'P5', key: majorKey(0) });
+ * // the same three notes a fifth up, entering at beat 2
  * ```
- * Notes with a zero or negative duration never sound and are dropped, so the
- * result can be shorter than the input.
- *
- * @category Rhythm & Meter
+ * @category Composition
  */
-declare function humanize(events: readonly NoteEvent[], opts?: HumanizeOptions): NoteEvent[];
+declare function imitate(lead: readonly NoteEvent[], opts: ImitationOptions): NoteEvent[];
+
 /**
- * The recorded feel at a single grid slot: an average timing deviation and velocity.
+ * The fill vocabulary, as data.
  *
- * @category Rhythm & Meter
+ * Every archetype is a list of strokes on the bar's grid and every selection is
+ * a table indexed by a draw, so a fill can be added, replaced, or supplied by a
+ * caller without touching a generator. The generator's part is to look one up.
  */
-type GrooveSlot = {
-    /** Average `actualStartBeat - quantizedBeat` (in quarter-note beats) for events landing on this slot. */
-    timingOffset: number;
-    /**
-     * Average velocity of events landing on this slot, or `null` if no event
-     * with a velocity did. `null` (not 0) is the "unrecorded" sentinel so that a
-     * genuine velocity of 0 is preserved and applied like any other value.
-     */
-    velocity: number | null;
+
+/** The thirteen fill archetypes for section transitions, in declaration order. */
+declare const FILL_TYPES: readonly ["snareRoll", "tomDescend", "tomAscend", "snareTomCombo", "simpleCrash", "linearFill", "ghostToAccent", "bdSnareAlternate", "hiHatChoke", "tomShuffle", "breakdownFill", "flamsAndDrags", "halfTimeFill"];
+/** The thirteen fill archetypes for section transitions. */
+type FillType = (typeof FILL_TYPES)[number];
+/**
+ * How loud one stroke of a fill is.
+ *
+ * A fill's dynamics are written against the fill's own base velocity rather
+ * than in absolute terms, so the same archetype sounds right in a verse and a
+ * chorus: `fill` is the body of the fill, `accent` the stroke that lands. One
+ * base for the whole gesture, not one per beat — a crescendo that restarts its
+ * arithmetic at every beat line falls back in the middle of itself.
+ */
+type FillVelocity = {
+    base: 'fill' | 'accent';
+    /** Factor on the base, for a crescendo or a ghosted stroke. */
+    scale?: number;
+    /** Fixed offset in MIDI velocity, for a stroke a little above or below. */
+    offset?: number;
+};
+/** One stroke of a fill, positioned within the beat it belongs to. */
+type FillStroke = {
+    /** General MIDI note number of the voice struck. */
+    voice: number;
+    /** Offset from the start of the beat, in quarter-note beats. */
+    offset: number;
+    /** Sounding length, in quarter-note beats. */
+    duration: number;
+    velocity: FillVelocity;
+    /** How the stroke is played, when it is more than a plain hit. */
+    articulation?: Articulation;
 };
 /**
- * A per-bar grid of timing and velocity deviations captured from a performance.
+ * A fill archetype: what each beat of the fill bar plays.
  *
- * @category Rhythm & Meter
+ * Beats are indexed from the start of the bar. A beat with no entry is silent,
+ * which is how the sparse archetypes leave the earlier beats to the groove.
  */
-type GrooveTemplate = {
-    /** Grid resolution: equal grid steps per quarter-note beat. */
-    subdivision: number;
-    /** Number of grid slots per bar (`beatsPerBar(ts) * subdivision`). */
-    slotsPerBar: number;
-    /** One entry per grid slot, in slot-index order (slot 0 is the downbeat). */
-    slots: GrooveSlot[];
+type FillArchetype = {
+    /** Strokes per beat of the bar, indexed 0..3. */
+    atBeat: readonly (readonly FillStroke[])[];
     /**
-     * The time signature the template was extracted under. {@link applyGrooveTemplate}
-     * requires the apply-time meter to match this so the per-bar grid lines up
-     * instead of silently drifting. Optional for backward compatibility with
-     * templates constructed without it (in which case no check is performed).
+     * Whether a bar longer than four beats keeps playing the last beat's strokes.
+     * The archetypes are written against a four-beat bar; most read naturally when
+     * extended, but the half-time figure is a bar-long gesture and stops there.
      */
-    ts?: TimeSignature;
+    boundToBar?: boolean;
 };
 /**
- * Extract a groove template from a set of note events: for each grid slot,
- * the average timing deviation from the quantized grid and the average
- * velocity of events landing on it. Slots with no velocity-carrying event
- * record `velocity: null` (the "unrecorded" sentinel); empty slots default to
- * `{ timingOffset: 0, velocity: null }`. The time signature is stored on the
- * template so {@link applyGrooveTemplate} can verify the meter matches.
+ * The fill dictionary.
  *
- * @param events The (typically "groovy", human-played) events to analyze.
- * @param ts The time signature, used to compute the bar length.
- * @param subdivision Grid resolution: equal grid steps per quarter-note beat.
- *   Defaults to a sixteenth-note grid, which is where the timing deviations a
- *   template records — swing, push, drag — are audible.
- * @returns The extracted groove template.
- * @category Rhythm & Meter
+ * Provenance: every archetype here is a rudiment or a stock phrase-end gesture
+ * — a snare crescendo, a descending tom run, a crash on the last off-beat — of
+ * the kind every drummer plays and nobody owns. None reproduces a fill from a
+ * particular recording.
  */
-declare function extractGrooveTemplate(events: readonly NoteEvent[], ts: TimeSignature, subdivision?: number): GrooveTemplate;
+declare const FILL_ARCHETYPES: Readonly<Record<FillType, FillArchetype>>;
 /**
- * Apply a groove template to a set of (typically quantized) note events: each
- * event is snapped to its grid slot and then offset by that slot's recorded
- * timing deviation, pushing stiff timing toward the template's feel.
- * Velocity is set to the slot's recorded average when it recorded one (a
- * non-`null` velocity, including a genuine 0); otherwise the event's own
- * velocity is left untouched.
- *
- * If the template carries a time signature (see {@link GrooveTemplate.ts}) it
- * must match `ts`, since a differing bar length would misalign the per-bar
- * grid and drift the feel; a mismatch throws rather than corrupting timing
- * silently.
+ * Whether a caller's material is a fill.
  *
- * @param events The events to reshape.
- * @param template The groove template, from {@link extractGrooveTemplate}.
- * @param ts The time signature, used to compute the bar length.
- * @returns Reshaped copies of `events`, in input order.
- * @throws If `template.ts` is set and does not match `ts`.
- * @example
- * ```ts
- * import { extractGrooveTemplate, applyGrooveTemplate, parseTimeSignature } from '@libraz/libcantus';
- * const ts = parseTimeSignature('4/4');
- * // Learn the feel from a loosely played performance...
- * const groovy = [
- *   { pitch: 36, startBeat: 0.02, durationBeat: 1, velocity: 100 },
- *   { pitch: 38, startBeat: 1.06, durationBeat: 1, velocity: 70 },
- * ];
- * const template = extractGrooveTemplate(groovy, ts, 4);
- * // ...then impose it on stiff, quantized events.
- * const quantized = [{ pitch: 36, startBeat: 0, durationBeat: 1, velocity: 80 }];
- * applyGrooveTemplate(quantized, template, ts); // events nudged toward the captured feel
- * ```
- * @category Rhythm & Meter
+ * A context carries one dictionary for the whole piece, so each generator has
+ * to recognise its own material; a bass lick reaching the fill selector would
+ * otherwise be rendered as silence.
  */
-declare function applyGrooveTemplate(events: readonly NoteEvent[], template: GrooveTemplate, ts: TimeSignature): NoteEvent[];
+declare function isFillArchetype(material: unknown): material is FillArchetype;
 
 /**
- * Broad production style a progression preset suits.
- *
- * @category Composition
- */
-type ProgStyle = 'minimal' | 'dance' | 'idol' | 'rock';
-/**
- * Harmonic-function role of a progression as a whole.
+ * The kick vocabulary, as data on a sixteenth grid.
  *
- * @category Composition
+ * The grid is sixteenths rather than eighths because most of what belongs in a
+ * kick dictionary cannot be written on eighths at all: the funk and modern-pop
+ * basics live on the sixteenths between the beats. The eighth-note patterns map
+ * onto the even steps of the same grid, so they read exactly as before.
  */
-type ProgFunction = 'loop' | 'tensionBuild' | 'cadenceStrong' | 'stable';
+
+/** Sixteenth steps in one bar of 4/4; the grid a kick pattern is written on. */
+declare const KICK_STEPS = 16;
+/**
+ * Kick presence flags across the sixteen 16th-note slots of a bar.
+ *
+ * Index `n` is the `n`-th sixteenth from the downbeat, so beat 3 is index 8 and
+ * the "and" of 2 is index 6.
+ */
+type KickPattern = readonly boolean[];
+/**
+ * One onset of a kick figure.
+ *
+ * A slot with no probability is part of the figure itself and always sounds.
+ * One with a probability is where the rhythmic dial reaches the kick: the draw
+ * is fixed by position and leaned on by the dial, so raising the dial fills
+ * slots in without emptying any that were already there.
+ */
+type KickSlot = {
+    /** Sixteenth index within the bar, 0..15. */
+    step: number;
+    /** Chance the slot is taken before the dial leans on it. */
+    probability?: number;
+    /** Draw address for the slot; slots that may sound must name one. */
+    slot?: string;
+    /** Restrict the slot to bars of one parity, for a two-bar figure. */
+    barParity?: 0 | 1;
+    /** Sections the slot is added in; absent means every section. */
+    sections?: Section[];
+};
+/** A style's kick figure: the slots it always plays, plus the ones it may. */
+type KickFigure = readonly KickSlot[];
 /**
- * A named chord-progression preset expressed in scale degrees.
+ * The kick dictionary, keyed by internal style.
  *
- * @category Composition
+ * Provenance: each figure is the plain pulse of its style — the four-on-the-
+ * floor dance kick, the backbeat-answering "and" of two, the clave-leaning
+ * latin figure — none of them traceable to a particular record.
  */
-type ProgressionPreset = {
-    id: string;
-    name: string;
-    /**
-     * The chord roots, in order, as {@link ProgressionDegree} codes: 0..6 for the
-     * key's own scale degrees and {@link BORROWED_DEGREES} for the borrowed ones.
-     */
-    degrees: ProgressionDegree[];
-    functional: ProgFunction;
-    styles: ProgStyle[];
-};
+declare const KICK_FIGURES: Readonly<Record<DrumStyle, KickFigure>>;
+
 /**
- * The borrowed (non-diatonic) chord roots a preset can name, as their semitone
- * offset above the tonic.
+ * A drum kit played with four limbs, covering every voice
+ * {@link generateDrums} emits.
  *
- * Scale degrees 0..6 address the key's own chords; these codes continue the
- * numbering for the chromatic chords a pop progression borrows, so a preset is
- * one flat list of degree codes.
+ * A kit is bounded by limbs rather than by range: two voices wanting the same
+ * hand at the same instant is what makes a pattern unplayable, and a voice no
+ * limb reaches is not on the kit at all.
  *
  * @example
  * ```ts
- * import { BORROWED_DEGREES, generateProgression, majorKey } from '@libraz/libcantus';
- * generateProgression({
- *   key: majorKey(0),
- *   style: 'rock',
- *   bars: 4,
- *   preset: { degrees: [0, BORROWED_DEGREES.bVII, 3, 0] },
+ * import { DRUM_KIT, generateDrums, playability } from '@libraz/libcantus';
+ * const hits = generateDrums({
+ *   bars: 1,
+ *   style: 'funk',
+ *   section: 'chorus',
+ *   ctx: { bpm: 120, complexity: { rhythmic: 0.8 } },
  * });
+ * const report = playability(hits, DRUM_KIT, 120);
  * ```
  * @category Composition
  */
-declare const BORROWED_DEGREES: {
-    /** Flat submediant: bVI. */
-    readonly bVI: 8;
-    /** Flat subtonic: bVII. */
-    readonly bVII: 10;
-    /** Flat mediant: bIII. */
-    readonly bIII: 11;
-    /** Minor subdominant borrowed from the parallel minor: iv. */
-    readonly iv: 12;
-    /** Neapolitan: bII. */
-    readonly bII: 13;
-    /** Sharp subdominant, the diminished #IV. */
-    readonly sharpIV: 14;
-};
+declare const DRUM_KIT: PercussionProfile;
+
 /**
- * A chord root in a preset: a scale degree 0..6, or one of
- * {@link BORROWED_DEGREES}.
+ * The drum pattern dictionary: the bar-long figures that make a groove belong
+ * to a genre rather than merely being correct.
  *
- * @category Composition
+ * Provenance: every pattern here is the plain, unattributable pulse of its
+ * genre — the figure taught as "this is how that music goes" — written out on
+ * the sixteenth grid from that description. None reproduces the drum part of a
+ * particular recording, and each entry says which ground it qualifies under.
  */
-type ProgressionDegree = number;
+
 /**
- * Options controlling {@link generateProgression}.
+ * One stroke of a pattern, on the bar's sixteenth grid.
  *
- * @category Composition
+ * Velocity is a factor of the passage's base velocity rather than a MIDI
+ * number, so the same figure sits right in a verse and in a chorus.
  */
-type ProgressionOptions = {
-    key: KeyScale;
-    /**
-     * Which pool of built-in presets to choose from. Ignored when `preset` names
-     * the progression outright.
-     */
-    style: ProgStyle;
-    bars: number;
-    /** Pick a specific built-in preset by id instead of choosing one by style. */
-    presetId?: string;
-    /**
-     * Use this progression rather than a built-in one. Only `degrees` is
-     * required; see {@link BORROWED_DEGREES} for the non-diatonic codes.
-     */
-    preset?: Partial<ProgressionPreset> & {
-        degrees: ProgressionDegree[];
-    };
-    ext?: ChordQuality | 'auto';
-    reharmonize?: boolean;
-    /**
-     * Seed for the deterministic preset choice and reharmonization.
-     *
-     * @defaultValue 0
-     */
-    seed?: number;
+type DrumStroke = GridEvent & {
+    voice: DrumVoice;
+    /** Sounding length in quarter-note beats; one sixteenth when absent. */
+    duration?: number;
+    articulation?: Articulation;
+    /** Which limb plays the stroke, where the figure depends on it. */
+    limb?: Limb;
 };
 /**
- * All built-in progression presets.
+ * A bar-long drum figure.
  *
  * @category Composition
  */
-declare function progressions(): ProgressionPreset[];
+type DrumPattern = {
+    /** Sixteenth steps in the figure; a 4/4 bar is sixteen. */
+    steps: number;
+    strokes: DrumStroke[];
+};
 /**
- * Presets whose style list includes the given style.
+ * A drum figure with the conditions it fits.
  *
  * @category Composition
  */
-declare function progressionsByStyle(style: ProgStyle): ProgressionPreset[];
+type DrumVocabulary = Vocabulary<DrumPattern>;
 /**
- * The preset {@link generateProgression} would choose for a style and seed.
+ * Whether a caller's material is a drum pattern.
  *
- * The choice is otherwise invisible: the generator returns chords, not the
- * preset it drew them from, so a caller who wants to show or reproduce it has
- * no way to name it.
+ * A context carries one dictionary for the whole piece, so each generator
+ * recognises its own material: an entry meant for the bass is invisible here
+ * rather than mis-read.
  *
- * @param style The style pool to choose from.
- * @param seed The same seed the generator would be given.
- * @returns The preset that seed selects.
- * @throws If no preset claims the style.
- * @example
- * ```ts
- * import { pickProgressionPreset } from '@libraz/libcantus';
- * pickProgressionPreset('dance', 3).name;
- * ```
  * @category Composition
  */
-declare function pickProgressionPreset(style: ProgStyle, seed?: number): ProgressionPreset;
+declare function isDrumPattern(material: unknown): material is DrumPattern;
 /**
- * Generate a chord progression laid out one chord per bar.
- *
- * A preset is chosen by `presetId` when given, otherwise deterministically from
- * the presets matching `style`, seeded by `seed`. An unknown `presetId`, or a
- * `style` no preset claims, is a caller error and throws rather than silently
- * falling back to a random preset. The preset's degrees cycle to
- * fill `bars`; each bar is four beats, so `startBeat` is `barIndex * 4`. Chord
- * roots come from the key's diatonic scale-degree mapping. When `ext` is
- * omitted or `'auto'`, each chord takes its diatonic triad quality; otherwise
- * `ext` is forced on every chord — except a chord replaced by `reharmonize`,
- * which is a secondary dominant and is therefore always a `dom7`; those carry
- * `secondaryDominant: true`. When `reharmonize` is set, some chords are
- * deterministically replaced with the secondary dominant (V7) of the following
- * chord, flagged with `secondaryDominant`.
- *
- * @param opts Generation options.
- * @returns One chord per bar in timeline order.
- * @throws If `presetId` matches no built-in preset, or `style` matches none.
- *
- * @example
- * ```ts
- * import { generateProgression, majorKey } from '@libraz/libcantus';
- * const chords = generateProgression({ key: majorKey(0), style: 'dance', bars: 4 });
- * // Deterministic for a given seed (defaults to 0); one ChordSpan per bar.
- * ```
+ * The built-in drum patterns, in declaration order.
  *
  * @category Composition
  */
-declare function generateProgression(opts: ProgressionOptions): ChordSpan[];
-
+declare const DRUM_PATTERNS: readonly DrumVocabulary[];
 /**
- * A melody note supplied to the harmonizer: a {@link NoteEvent}.
+ * Options controlling {@link placeDrumPattern}.
  *
- * @category Reharmonization
- */
-type MelodyNote = NoteEvent;
-/**
- * Options controlling {@link harmonizeMelody}.
- *
- * @category Reharmonization
- */
-type HarmonizePlacement = {
-    /**
-     * Search a range of transpositions and keep the best-fitting one. The result
-     * reports the shift it chose in `transposeSemitones`.
-     *
-     * @defaultValue false
-     */
-    transposeSearch: boolean;
-    /**
-     * Search octave placements as well, so a melody written too high or too low
-     * is moved into a comfortable register.
-     *
-     * @defaultValue false
-     */
-    octaveSearch: boolean;
-};
-/**
- * Options controlling {@link harmonizeMelody}.
- *
- * Only `melody` is required; every other knob has the default a first call
- * wants.
- *
- * @category Reharmonization
+ * @category Composition
  */
-type HarmonizeOptions = {
-    /** The melody to harmonize, in ascending onset order. */
-    melody: readonly MelodyNote[];
-    /**
-     * The key to harmonize in, or `'infer'` to estimate it from the melody's
-     * pitch-class weighting — which is what a caller who has only a melody
-     * wants, and so the default.
-     *
-     * @defaultValue `'infer'`
-     */
-    key?: KeyScale | 'infer';
-    /**
-     * Length of each chord slot in beats. Any positive value is honoured, as in
-     * {@link chordTimelineFromNotes}; a value fine enough to make the search
-     * explode is rejected by the generation budget rather than rounded up.
-     *
-     * @defaultValue 2
-     */
-    harmonicRhythm?: number;
+type DrumPatternOptions = {
+    /** Number of bars to generate. */
+    bars: number;
     /**
-     * Time signature used to weight metric accents; defaults to 4/4. A waltz or
-     * a jig harmonized against a 4/4 accent grid gets its chords placed on the
-     * wrong beats, and the error accumulates bar by bar.
-     *
-     * @defaultValue `4/4`
+     * The genre whose figures may be used. Genre is what selects the material;
+     * the complexity dials then deform it and the difficulty ceiling rejects it.
      */
+    genre: Genre;
+    /** Section the pattern plays in, matched against each entry's own sections. */
+    section?: Section;
+    /** Time signature; defaults to 4/4. */
     ts?: TimeSignature;
     /**
-     * How far beyond the key's own triads the chord vocabulary reaches:
-     * `'diatonic'` uses only them, `'secondaryDominant'` adds the dominants that
-     * tonicize each degree, and `'borrowed'` adds the parallel mode's chords too.
+     * The generation context. `bpm` is the tempo, `complexity.rhythmic` thins the
+     * figure below its middle setting and syncopates it above,
+     * `complexity.ornament` decides how many ghosts survive,
+     * `complexity.difficulty` rejects a figure the player could not keep up at
+     * this tempo, `vocabulary` brings figures of the caller's own, and `seed`
+     * fixes which figure is chosen for each bar.
      *
-     * @defaultValue `'diatonic'`
+     * @defaultValue `{ seed: 0, bpm: 120 }`
      */
-    reharmonize?: 'diatonic' | 'secondaryDominant' | 'borrowed';
+    ctx?: GenerationContextInput;
     /**
-     * Whether to search transpositions and octave placements for the melody.
-     * Both are off by default, so the melody is harmonized where it was written.
+     * Play the figure at half or double its written rate. This is a deformation
+     * like the dials, not a different figure: the dictionary entry is the same.
      *
-     * @defaultValue both false
-     */
-    placement?: HarmonizePlacement;
-    /**
-     * Seed for the deterministic tie-break perturbation.
+     * It is named for the note values it changes because `feel` names the swing
+     * the figure is played with, here and in {@link generateDrums} alike.
      *
-     * @defaultValue 0
+     * @defaultValue `'straight'`
      */
-    seed?: number;
-};
-/**
- * The chosen transpose, key, chord path, and per-note roles.
- *
- * @category Reharmonization
- */
-type HarmonizeResult = {
-    transposeSemitones: number;
-    key: KeyScale;
-    chords: ChordSpan[];
-    melodyRoles: {
-        noteIndex: number;
-        role: HarmonyRole;
-    }[];
-};
-/**
- * Harmonize a melody with a min-cost chord progression.
- *
- * The melody is segmented by `harmonicRhythm`; each segment is scored against
- * diatonic (and, per `reharmonize`, secondary-dominant and borrowed) candidate
- * chords by melody fit, and a Viterbi search picks the lowest-cost path using a
- * functional-flow transition cost. When `placement.transposeSearch`/`octaveSearch`
- * is set, the whole melody is transposed across a range and the best
- * `(transpose, progression)` pair is returned; a small tessitura cost breaks
- * ties toward placements that keep the melody in a comfortable register.
- *
- * The `seed` drives a deterministic tie-break only: it perturbs candidates by a
- * magnitude far below any real cost difference (see `TIE_BREAK_JITTER`),
- * so it can decide between chords or paths of otherwise-equal cost but never
- * overrides melody fit or functional flow. For a well-determined melody the
- * result is identical across seeds; the same seed always yields the same result.
- *
- * @param opts The melody and, optionally, the key, harmonic rhythm,
- *   reharmonization strength, placement search, meter, and seed. Only `melody`
- *   is required.
- * @returns The chosen transpose, key, chord path, and per-note roles.
- * @example
- * ```ts
- * import { harmonizeMelody } from '@libraz/libcantus';
- * const result = harmonizeMelody({
- *   melody: [
- *     { pitch: 60, startBeat: 0, durationBeat: 1 },
- *     { pitch: 64, startBeat: 1, durationBeat: 1 },
- *   ],
- * });
- * result.chords; // one ChordSpan per harmonic-rhythm segment
- * ```
- * @category Reharmonization
- */
-declare function harmonizeMelody(opts: HarmonizeOptions): HarmonizeResult;
-
-/**
- * A transformation applicable to a motif cell.
- *
- * @category Composition
- */
-type MotifTransform = 'transposeDiatonic' | 'transposeChromatic' | 'invert' | 'retrograde' | 'augment' | 'diminish' | 'sequence';
-/**
- * A single note within a motif cell.
- *
- * @category Composition
- */
-type MotifNote = {
-    pitch: number;
-    startBeat: number;
-    durationBeat: number;
-};
-/**
- * A short melodic cell.
- *
- * @category Composition
- */
-type MotifCell = {
-    notes: MotifNote[];
-};
-/**
- * Melodic contour shape for {@link generateMotif}.
- *
- * @category Composition
- */
-type MotifContour = 'arch' | 'ascending' | 'descending' | 'wave';
-/**
- * Options controlling {@link generateMotif}.
- *
- * @category Composition
- */
-type MotifOptions = {
-    key: KeyScale;
-    chord?: Chord | null;
-    /** Length of the motif in bars of `ts`. */
-    bars: number;
-    /**
-     * Meter the bars are counted in. It sets the bar length, so a motif shares a
-     * bar grid with the other generators instead of assuming four beats.
-     *
-     * @defaultValue 4/4
-     */
-    ts?: TimeSignature;
+    rate?: 'straight' | 'half' | 'double';
     /**
-     * Melodic contour shape the line follows.
+     * The swing the figure is played with. Some entries are written on the
+     * straight grid and are only themselves once a triplet feel is applied at
+     * render — the half-time shuffle is the plain case — so this is the surface
+     * those entries name when they say the feel comes from the performance.
      *
-     * @defaultValue `'arch'`
+     * @defaultValue `'straight'`
      */
-    contour?: MotifContour;
-    /**
-     * Probability in [0, 1] that a note is nudged by a single diatonic step. The
-     * nudge direction is balanced (up or down with equal odds), so it adds
-     * variety without biasing the line off its contour. Default 0, which
-     * reproduces the requested contour exactly (no drift, tails return to tonic).
-     *
-     * @defaultValue 0
-     */
-    jitter?: number;
+    feel?: GrooveFeel;
+    /** Base velocity the figure's own factors are read against. */
+    velocity?: number;
     /**
-     * Seed for the deterministic PRNG.
+     * Maximum number of onsets {@link placeDrumPattern} may write. One figure is
+     * placed per bar, so this is the guard against an unbounded caller rather
+     * than a limit on any search.
      *
-     * @defaultValue 0
+     * @defaultValue 1000000
      */
-    seed?: number;
+    budget?: number;
 };
 /**
- * Generate a short seed motif over `bars`.
- *
- * The melody follows the requested contour in diatonic steps from the tonic,
- * snapped to the key. When a chord is supplied, notes landing on bar downbeats
- * are pulled to the nearest chord tone. An optional `jitter` adds balanced
- * per-note variation without biasing the contour; it is off by default, so the
- * contour is reproduced exactly. Output is deterministic for a given seed.
- *
- * @param opts Key, optional chord, length, contour, jitter, and seed.
- * @returns The generated motif cell.
- *
- * @example
- * ```ts
- * import { generateMotif, majorKey } from '@libraz/libcantus';
- * const cell = generateMotif({ key: majorKey(0), bars: 2, contour: 'arch' });
- * // cell.notes is a deterministic MotifCell (seed defaults to 0)
- * ```
- *
- * @category Composition
- */
-declare function generateMotif(opts: MotifOptions): MotifCell;
-/**
- * Turn a motif cell into note events.
- *
- * A {@link MotifNote} already carries the {@link NoteEvent} fields, but a cell
- * wraps them in an object; this unwraps it, so a motif can be humanized,
- * grooved, or written out like any other line.
- *
- * @param cell The motif to convert.
- * @returns The cell's notes, copied, in the order they are stored.
- * @example
- * ```ts
- * import { generateMotif, humanize, majorKey, motifToNoteEvents } from '@libraz/libcantus';
- * humanize(motifToNoteEvents(generateMotif({ key: majorKey(0), bars: 2 })));
- * ```
- * @category Composition
- */
-declare function motifToNoteEvents(cell: MotifCell): NoteEvent[];
-/**
- * Apply a transformation to a motif cell.
+ * Generate a genre-characteristic groove from the pattern dictionary.
  *
- * `invert` reflects pitches about the first note (chromatic, self-inverse);
- * `retrograde` mirrors onsets about the cell span, preserving rests (self-inverse);
- * `augment`/`diminish` scale time by `amount ?? 2` and its reciprocal;
- * `transposeChromatic` adds `amount` semitones; `transposeDiatonic` shifts by
- * `amount` scale degrees when a `key` is given, or — with no `key` — falls back
- * to a chromatic shift of `amount` semitones; `sequence` appends a shifted copy
- * (by `amount` diatonic degrees with a `key`, or by `amount` semitones without
- * one, since it delegates to `transposeDiatonic`).
+ * The three dials never fight, because each owns a different step: the genre
+ * chooses which figures are candidates, the complexity dials deform the chosen
+ * figure, and the difficulty ceiling rejects a figure whose closest pair of
+ * strokes is faster than a player at that ceiling sustains. A rejected figure
+ * is dropped from the candidates rather than simplified, since a simplified
+ * figure is a different figure.
  *
- * @param cell The cell to transform.
- * @param t The transformation.
- * @param amount Optional parameter (semitones, degrees, or time factor).
- * @param key Key context for the diatonic transforms; without it,
- *   `transposeDiatonic` and `sequence` shift chromatically by semitones.
- * @returns The transformed cell.
- * @throws If a transformed pitch would fall outside the MIDI range 0..127.
- *
- * @example
- * ```ts
- * import { generateMotif, transformMotif, majorKey } from '@libraz/libcantus';
- * const cell = generateMotif({ key: majorKey(0), bars: 1 });
- * const inverted = transformMotif(cell, 'invert');
- * ```
- *
- * @category Composition
- */
-declare function transformMotif(cell: MotifCell, t: MotifTransform, amount?: number, key?: KeyScale): MotifCell;
-/**
- * Lay a motif across `bars` and snap it to a chord timeline.
- *
- * The cell is tiled back-to-back to fill the requested span; each note is then
- * pulled to the nearest chord tone of the segment sounding at its onset, so the
- * developed line spells the underlying harmony.
- *
- * @param cell The source motif.
- * @param timeline Chord segments to snap against.
- * @param key Key context (used to keep snapped pitches sensible).
- * @param bars Number of bars to fill.
- * @param ts Meter the bars are counted in; defaults to 4/4.
- * @returns The developed, harmony-aware cell.
+ * @param opts Generation options.
+ * @returns Percussion onsets in onset order, ties broken by pitch.
+ * @throws If the bar count, tempo, or time signature is invalid, or the genre
+ *   is not one this library names.
  *
  * @example
  * ```ts
- * import { chordTimelineFromChords, developMotif, generateMotif, majorKey } from '@libraz/libcantus';
- * const key = majorKey(0);
- * const timeline = chordTimelineFromChords([{ rootPc: 0, quality: 'maj', startBeat: 0 }], 8);
- * const developed = developMotif(generateMotif({ key, bars: 1 }), timeline, key, 2);
+ * import { placeDrumPattern } from '@libraz/libcantus';
+ * const hits = placeDrumPattern({ bars: 2, genre: 'bossa', ctx: { seed: 7, bpm: 130 } });
  * ```
  *
  * @category Composition
  */
-declare function developMotif(cell: MotifCell, timeline: ChordTimeline, key: KeyScale, bars: number, ts?: TimeSignature): MotifCell;
+declare function placeDrumPattern(opts: DrumPatternOptions): DrumHit[];
 
 /**
- * Reharmonization: chord substitution, modal-interchange palettes, and negative
- * harmony. These transforms take an existing chord (or a key) and propose
- * alternative harmonies that preserve a chosen relationship — a shared function,
- * a common tone, a tonicizing dominant, or a reflection across the key axis.
- *
- * Roots are pitch classes (0..11); no spelled key signature is required.
- */
-
-/**
- * The kind of substitution relationship a candidate realizes.
- *
- * @category Reharmonization
- */
-type SubstitutionType = 'tritone' | 'relative' | 'borrowed' | 'chromaticMediant' | 'secondaryDominant';
-/**
- * A proposed chord substitution with its relationship, numeral, and function.
+ * What a melody note contributes to the harmony: either a structural tone the
+ * chord has to account for, or the ornament figure that explains it away.
  *
  * @category Reharmonization
  */
-type Substitution = {
-    chord: Chord;
-    type: SubstitutionType;
-    roman: string;
-    function: HarmonicFunction;
-};
+type MelodyToneRole = 'structural' | 'passing' | 'neighbor' | 'appoggiatura' | 'suspension' | 'anticipation' | 'escape';
 /**
- * Options controlling which substitutions {@link substituteChord} returns.
+ * One melody note's classification: its index in the classified melody, the
+ * figure it forms, and whether that figure makes it ornamental.
  *
  * @category Reharmonization
  */
-type SubstituteOptions = {
-    /**
-     * Melody pitch classes that must remain chord tones. When given, only
-     * substitutions whose pitch classes contain every listed pitch class are
-     * kept, so the melody stays consonant against the new harmony.
-     */
-    melodyPcs?: number[];
+type ClassifiedMelodyTone = {
+    noteIndex: number;
+    role: MelodyToneRole;
+    /** True for every role but `'structural'`. */
+    ornamental: boolean;
 };
 /**
- * Propose substitutions for a chord within a key.
- *
- * Candidates are generated by several relationships and deduplicated against the
- * original chord and each other:
- *
- * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.
- * - `secondaryDominant`: for a stable target, the dominant seventh a fifth
- *   above its root (tonicizing it).
- * - `relative`: a diatonic triad a third away that shares two common tones.
- * - `borrowed`: a triad from the parallel mode with the same harmonic function.
- * - `chromaticMediant`: a major/minor triad a third away sharing one common
- *   tone.
- *
- * Each result carries its Roman numeral and harmonic function in `key`. When
- * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all
- * of those pitch classes are returned.
- *
- * @param chord The chord to reharmonize.
- * @param key The prevailing key.
- * @param opts Optional melody-preservation constraint.
- * @returns The deduplicated substitution candidates.
+ * Classify a melody's ornaments from the melody and the metre alone.
+ *
+ * This is deliberately chord-free: a harmonizer needs to know which notes the
+ * chords must explain *before* it can choose them, so nothing here may consult a
+ * harmony. What remains is the melodic and metric evidence — stepwise approach
+ * and departure, repeated pitches, leaps, and the relative metric weight and
+ * length of a note against its neighbours.
+ *
+ * The figures are recognized in the order suspension, passing, neighbor,
+ * anticipation, appoggiatura, escape. A note is judged ornamental only when it
+ * is metrically and rhythmically subordinate to the neighbours that frame it
+ * (or, for the accented figures, when it leans on a stronger beat than its
+ * approach and gives way to a resolution). A note without an adjacent
+ * predecessor and successor has no figure to belong to and stays structural, so
+ * the first and last notes of a phrase are always structural.
+ *
+ * @param melody The melody, in ascending onset order.
+ * @param ts Time signature used to weight metric accents.
+ * @returns One classification per input note, in input order.
  * @example
  * ```ts
- * import { substituteChord, makeChord, majorKey } from '@libraz/libcantus';
- * const subs = substituteChord(makeChord(7, 'dom7'), majorKey(0));
- * // includes the tritone sub Db7 (rootPc 1, quality 'dom7')
+ * import { classifyMelodyTones } from '@libraz/libcantus';
+ * const melody = [60, 62, 64, 60].map((pitch, i) => ({
+ *   pitch,
+ *   startBeat: i,
+ *   durationBeat: 1,
+ * }));
+ * classifyMelodyTones(melody, { numerator: 4, denominator: 4 })[1];
+ * // { noteIndex: 1, role: 'passing', ornamental: true }
  * ```
  * @category Reharmonization
  */
-declare function substituteChord(chord: Chord, key: KeyScale, opts?: SubstituteOptions): Substitution[];
-/**
- * A borrowed chord in the modal-interchange palette of a key.
- *
- * @category Reharmonization
- */
-type BorrowedChord = {
-    chord: Chord;
-    roman: string;
-    source: BorrowedSource;
-};
-/**
- * The modal-interchange palette of a key.
- *
- * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to
- * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major
- * key), plus the Neapolitan (a major triad on the flat second degree). Each
- * carries its Roman numeral and {@link borrowedSource} relative to `key`.
- *
- * @param key The prevailing key.
- * @returns The borrowed-chord palette.
- * @category Reharmonization
- */
-declare function modalInterchangePalette(key: KeyScale): BorrowedChord[];
-/**
- * Reflect a chord across the tonic–dominant axis of a key (negative harmony).
- *
- * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key
- * tonic — the reflection that swaps the tonic with the dominant. The mirrored
- * pitch classes (including the bass, if set) are reassembled into a chord by
- * {@link detectChordBest}; when no chord is recognized, the mirrored root and
- * the original quality are used as a fallback.
- *
- * @param chord The chord to reflect.
- * @param key The prevailing key.
- * @returns The negative-harmony counterpart of the chord.
- * @example
- * ```ts
- * import { negativeHarmonyMirror, makeChord, majorKey } from '@libraz/libcantus';
- * negativeHarmonyMirror(makeChord(7, 'maj'), majorKey(0));
- * // G major reflected across C's axis => F minor (rootPc 5, quality 'min')
- * ```
- * @category Reharmonization
- */
-declare function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord;
-
-/**
- * Deterministic rhythm generation over a metric grid.
- *
- * Builds a fixed-resolution grid across one or more bars of a time signature
- * and decides, per grid slot, whether it becomes a note onset. Onset
- * probability follows the metric-accent hierarchy from the `meter` module, so
- * strong positions (downbeats, secondary pulses) are favored over weak
- * off-pulse subdivisions. Given a seed the output is fully reproducible.
- *
- * Positions and durations are measured in quarter-note beats, matching the
- * library-wide convention.
- */
-
-/**
- * A single rhythmic note: an onset position and how long it sounds.
- *
- * @category Rhythm & Meter
- */
-type RhythmEvent = {
-    /** Onset position in quarter-note beats, absolute from the start of the span. */
-    position: number;
-    /** Duration in quarter-note beats, extending to the next onset. */
-    duration: number;
-};
-/**
- * Turn rhythm events into note events at a fixed pitch.
- *
- * {@link RhythmEvent} names its fields `position`/`duration` because a rhythm
- * has no pitch; every other generator in the library speaks {@link NoteEvent}.
- * This is the bridge, so a generated rhythm can be humanized, grooved, or
- * written out like any other line.
- *
- * @param events The rhythm events to convert.
- * @param pitch The MIDI pitch to give every note.
- * @param velocity Velocity for every note; defaults to a mezzo-forte 96.
- * @returns The note events, in the order given.
- * @example
- * ```ts
- * import { generateRhythm, humanize, rhythmToNoteEvents } from '@libraz/libcantus';
- * const rhythm = generateRhythm({ numerator: 4, denominator: 4 }, { bars: 2 });
- * humanize(rhythmToNoteEvents(rhythm, 38));
- * ```
- * @category Rhythm & Meter
- */
-declare function rhythmToNoteEvents(events: RhythmEvent[], pitch: number, velocity?: number): NoteEvent[];
-/**
- * Options controlling {@link generateRhythm}.
- *
- * @category Rhythm & Meter
- */
-type RhythmOptions = {
-    /**
-     * Seed for the deterministic PRNG.
-     *
-     * @defaultValue 0
-     */
-    seed?: number;
-    /**
-     * Number of bars to generate.
-     *
-     * @defaultValue 1
-     */
-    bars?: number;
-    /**
-     * Grid resolution as the number of equal grid steps per quarter-note beat.
-     * The default of 2 yields an eighth-note grid; 4 yields a sixteenth-note
-     * grid, 3 an eighth-note triplet grid, and so on.
-     *
-     * @defaultValue 2
-     */
-    subdivision?: number;
-    /**
-     * Overall onset density in [0, 1]. Scales the per-slot onset probability, so
-     * higher values fill more grid slots. Values outside [0, 1] are clamped into
-     * range.
-     *
-     * @defaultValue 0.5
-     */
-    density?: number;
-};
-/**
- * Map a metric weight (0–3 from {@link metricWeight}) to a base onset
- * probability before density scaling. Strong positions are much more likely to
- * carry an onset than weak ones; the curve is intentionally small and explicit
- * so its behavior is easy to inspect and test.
- *
- * @param weight The metric weight, 0 (off-pulse) to 3 (downbeat).
- * @returns A base onset probability in [0, 1].
- * @category Rhythm & Meter
- */
-declare function onsetWeightCurve(weight: number): number;
-/**
- * Generate a deterministic rhythmic pattern over `bars` bars of a time
- * signature. A grid is built at the chosen subdivision; each slot becomes an
- * onset with a probability derived from its metric weight scaled by `density`
- * and sampled from the seeded PRNG. Every bar's downbeat is always an onset, so
- * a pattern of any length has a reliable pulse independent of the seed. Each
- * event's duration extends to the next onset, and the last event extends to the
- * end of the span. `density` is clamped to [0, 1].
- *
- * @param ts The time signature.
- * @param opts Generation options.
- * @returns Onset events sorted by position, non-overlapping, covering the span.
- * @example
- * ```ts
- * import { parseTimeSignature, generateRhythm } from '@libraz/libcantus';
- * const ts = parseTimeSignature('4/4');
- * generateRhythm(ts, { seed: 42, density: 0.6 }); // onset events over one bar
- * ```
- * @category Rhythm & Meter
- */
-declare function generateRhythm(ts: TimeSignature, opts?: RhythmOptions): RhythmEvent[];
-/**
- * Onset density of a generated pattern: the mean number of onsets per bar.
- *
- * @param events Events from {@link generateRhythm}.
- * @param ts The time signature.
- * @returns The onset count divided by the number of bars the events span.
- * @category Rhythm & Meter
- */
-declare function rhythmDensity(events: RhythmEvent[], ts: TimeSignature): number;
+declare function classifyMelodyTones(melody: readonly NoteEvent[], ts: TimeSignature): ClassifiedMelodyTone[];
 
-export { BASS_STYLES, BORROWED_DEGREES, type BassLineOptions, type BassSegment, type BassStyle, type BorrowedChord, BorrowedSource, Chord as ChordData, ChordQuality, ChordSegment, ChordSpan, ChordTimeline, type CounterMelodyOptions, DRUM_NOTES, type DrumHit, type DrumRole, type DrumVoice, type DrumsOptions, type EuclideanKick, type GrooveFeel, type GrooveSlot, type GrooveStyle, type GrooveTemplate, HarmonicFunction, type HarmonizeOptions, type HarmonizePlacement, type HarmonizeResult, HarmonyRole, type HumanizeOptions, KeyScale, type MelodyNote, type MotifCell, type MotifContour, type MotifNote, type MotifOptions, type MotifTransform, NoteEvent, type ProgFunction, type ProgStyle, type ProgressionDegree, type ProgressionOptions, type ProgressionPreset, type RhythmEvent, type RhythmOptions, type Section, type SubstituteOptions, type Substitution, type SubstitutionType, TimeSignature, applyGrooveTemplate, developMotif, drumVoiceOf, extractGrooveTemplate, generateBassLine, generateCounterMelody, generateDrums, generateMotif, generateProgression, generateRhythm, harmonizeMelody, humanize, modalInterchangePalette, motifToNoteEvents, negativeHarmonyMirror, onsetWeightCurve, pickProgressionPreset, progressions, progressionsByStyle, rhythmDensity, rhythmToNoteEvents, substituteChord, transformMotif };
+export { Articulation, BASS_LICKS, type BassLick, ChordLike, ChordSegment, type ClassifiedMelodyTone, DRUM_KIT, DRUM_PATTERNS, DrumHit, type DrumPattern, type DrumPatternOptions, type DrumStroke, DrumStyle, type DrumVocabulary, DrumVoice, FILL_ARCHETYPES, FILL_TYPES, type FillArchetype, type FillStroke, type FillType, type FillVelocity, GenerationContextInput, Genre, GridEvent, GrooveFeel, type ImitationAnswer, type ImitationOptions, IntervalLike, KICK_FIGURES, KICK_STEPS, KeyLike, type KickFigure, type KickPattern, type KickSlot, type LickMaterial, type LickNote, Limb, MAX_DIFFICULTY, MIN_DIFFICULTY, type MelodyToneRole, NoteEvent, PercussionProfile, type PlaceLicksOptions, Section, StringedProfile, TimeSignature, Vocabulary, classifyMelodyTones, imitate, isDrumPattern, isFillArchetype, isLickMaterial, placeDrumPattern, placeLicks, sustainsShift, sustainsStrokes };