@libraz/libcantus 0.9.5 → 1.0.0

package/dist/core/index.d.ts

@@ -1,213 +1,107 @@
-import { N as NoteEvent } from '../types-BN6_Q9Kl.js';
-export { K as KeyScale } from '../types-BN6_Q9Kl.js';
-import { T as TimeSignature } from '../index-DXd9JikN.js';
-export { B as BarPosition, b as barPositionToBeat, a as barPositionToPulse, c as beatToBarPosition, d as beatsPerBar, f as formatBarPosition, e as formatTimeSignature, i as isCompound, g as isStrongBeat, m as metricWeight, p as parseTimeSignature, h as pulseBeats, j as pulsesPerBar, t as tuplet } from '../index-DXd9JikN.js';
-export { I as IntervalQualityLabel, N as NoteData, S as SpelledInterval, d as diatonicLetterOf, f as formatNote, i as intervalSemitones, m as midiToNote, n as naturalPitchClassOf, a as noteToMidi, b as noteToPitchClass, p as parseInterval, c as parseNote, e as pitchClassOf, s as spelledInterval, t as transposeByInterval, g as transposeNote } from '../index-tR9jTn26.js';
+export { D as DurationData, I as IndexedNoteEvent, J as JUST_RATIOS, N as NOTE_VALUES, a as NoteEventIndex, b as NoteEventIndexOptions, c as NotePlacement, d as NoteValue, O as OnsetTieBreak, P as PlayabilityIssue, e as PlayabilityIssueType, f as PlayabilityLayer, g as PlayabilityReport, S as SpelledDuration, T as TWELVE_TET, h as TempoEvent, i as TempoMap, j as TuningTable, k as Tuplet, l as beatsToDuration, m as beatsToSeconds, n as beatsToTicks, o as beatsToTiedDurations, p as centsBetweenFreq, q as centsFromNearestStep, r as centsOfSteps, s as centsToRatio, t as createNoteEventIndex, u as durationToBeats, v as durationToSeconds, w as edo, x as frequencyOf, y as justDeviationCents, z as nearestStep, A as playability, B as ratioToCents, C as secondsToBeats, E as stepOf, F as stepsOfCents, G as tempoAt, H as ticksToBeats } from '../index-G1uwGGWQ.js';
+import { g as NoteEvent } from '../index-B9MNZboQ.js';
+export { A as ARTICULATIONS, a as Articulation, B as BudgetExceededError, I as IntervalLike, b as IntervalQualityLabel, c as InvalidInputError, K as KeyName, d as KeyScale, L as LibcantusError, e as LibcantusErrorCode, N as NoSolutionError, f as NoteData, h as NoteLike, i as NoteNameOptions, j as NoteNameSystem, P as ParseResult, S as SpelledInterval, k as detectNoteNameSystem, l as diatonicLetterOf, m as formatKeyName, n as formatNote, o as intervalSemitones, p as isLibcantusError, q as midiToNote, r as naturalPitchClassOf, s as noteToMidi, t as noteToPitchClass, u as parseInterval, v as parseKeyName, w as parseNote, x as pitchClassOf, y as spelledInterval, z as toNoteData, C as toSpelledInterval, D as transposeByInterval, E as transposeNote, F as tryParseInterval, G as tryParseKeyName, H as tryParseNote } from '../index-B9MNZboQ.js';
+import { f as StringedProfile } from '../positional-Cptlj-xs.js';
+export { I as InstrumentProfile, a as InstrumentProfileCommon, b as InstrumentProfileLike, L as LIMBS, c as Limb, P as PercussionProfile, d as PositionalRng, S as SeedPath, e as StringFingering, g as canSound, h as createPositionalRng, i as deriveSeed, j as fingeringsFor, k as foldIntoRange, l as includeAt, m as instrumentRange } from '../positional-Cptlj-xs.js';
+export { C as ConsonanceClass, c as classifyInterval, i as isConsonantInterval, a as isPerfectInterval } from '../index-DInQqT8Q.js';
+import { c as MeterMap, T as TimeSignature } from '../index-Cj49F892.js';
+export { B as BarPosition, M as MeterChange, a as MeterData, b as MeterLike, d as barIndexAt, e as barPositionToBeat, f as barPositionToPulse, g as barStartBeat, h as beatToBarPosition, i as beatsPerBar, j as beatsPerBarAt, k as formatBarPosition, l as formatTimeSignature, m as isCompound, n as isStrongBeat, o as meterAt, p as metricWeight, q as parseTimeSignature, r as pulseBeats, s as pulsesPerBar, t as resolveMeters, u as toMeterData, v as tryParseTimeSignature, w as tuplet } from '../index-Cj49F892.js';
 
 /**
- * The library's error taxonomy.
- *
- * Every failure this library raises falls into one of three kinds, and the kind
- * decides what a caller can do about it. Batch-voicing a lead sheet, for
- * instance, has to tell "fix the input" apart from "loosen the constraints",
- * and a message string is not a contract.
- *
- * The classes extend the built-in error types a caller would otherwise catch —
- * a rejected argument is still a `RangeError` — so the `code` narrows an
- * existing category rather than replacing it.
- */
-/**
- * What kind of failure an error reports.
- *
- * - `INVALID_INPUT`: an argument is malformed or out of range. The caller's
- *   input must change.
- * - `NO_SOLUTION`: the input is valid but nothing satisfies the constraints.
- *   The constraints must change, or the failure must be accepted.
- * - `BUDGET_EXCEEDED`: the requested work is larger than the synchronous
- *   generation budget. The request must be smaller, or the budget larger.
+ * Electric bass in standard tuning: E1 A1 D2 G2 over a 24-fret neck.
  *
  * @category Core
  */
-type LibcantusErrorCode = 'INVALID_INPUT' | 'NO_SOLUTION' | 'BUDGET_EXCEEDED';
+declare const BASS_4_STRING: StringedProfile;
 /**
- * A rejected argument: malformed, out of range, or naming something unknown.
+ * Five-string bass with the low B: B0 E1 A1 D2 G2.
  *
  * @category Core
  */
-declare class InvalidInputError extends RangeError {
-    readonly code: "INVALID_INPUT";
-    readonly name = "InvalidInputError";
-}
+declare const BASS_5_STRING: StringedProfile;
 /**
- * A valid request with no answer: no voicing fits the given ranges, no chord
- * matches the pitches, no preset claims the style.
+ * Six-string guitar in standard tuning: E2 A2 D3 G3 B3 E4.
  *
  * @category Core
  */
-declare class NoSolutionError extends Error {
-    readonly code: "NO_SOLUTION";
-    readonly name = "NoSolutionError";
-    /**
-     * Where in a sequence the failure occurred, when the operation was working
-     * through one — the chord index of a progression, say.
-     */
-    readonly at: number | undefined;
-    constructor(message: string, options?: {
-        at?: number;
-    });
-}
+declare const GUITAR_STANDARD: StringedProfile;
 /**
- * Work that would exceed the synchronous generation budget.
+ * Six-string guitar in drop D: the lowest string down a tone to D2, the rest
+ * standard. Only the tuning differs, which is the whole point of deriving the
+ * range from it.
  *
  * @category Core
  */
-declare class BudgetExceededError extends RangeError {
-    readonly code: "BUDGET_EXCEEDED";
-    readonly name = "BudgetExceededError";
-}
-/**
- * Whether a caught value is one of this library's coded errors.
- *
- * @param value The caught value.
- * @returns True when it carries a {@link LibcantusErrorCode}.
- * @example
- * ```ts
- * import { isLibcantusError, voiceChord, parseChordSymbol } from '@libraz/libcantus';
- * try {
- *   voiceChord(parseChordSymbol('C'), { ranges: [] });
- * } catch (error) {
- *   if (isLibcantusError(error) && error.code === 'NO_SOLUTION') {
- *     // loosen the constraints rather than blaming the input
- *   }
- * }
- * ```
- * @category Core
- */
-declare function isLibcantusError(value: unknown): value is InvalidInputError | NoSolutionError | BudgetExceededError;
+declare const GUITAR_DROP_D: StringedProfile;
 
 /**
- * A validated note retaining its position in the caller's original array.
+ * The reproducibility contract for generated output.
  *
- * @category Core
+ * A saved project is a seed plus parameters, and it only reopens as the same
+ * piece if the library still turns them into the same notes. Package versions
+ * cannot carry that promise: a bug fix inside a generator is a patch release
+ * and still moves every note. The algorithm version is the separate number
+ * that does carry it, declared here and recorded by the caller alongside the
+ * seed.
  */
-type IndexedNoteEvent = {
-    note: Readonly<NoteEvent>;
-    originalIndex: number;
-    endBeat: number;
-};
 /**
- * Which note wins when several sound from the same onset.
+ * The generator algorithm version this build produces by default.
  *
- * `'highest'` and `'lowest'` name a voice, so the answer does not depend on the
- * order the caller happened to store the chord in; `'last'` takes the one
- * latest in the input array.
+ * The guarantee it carries: for a fixed algorithm version, the same inputs —
+ * seed, version and every documented parameter — produce the same generated
+ * output from any build of this library that accepts that version. It covers
+ * what the generators return, and nothing else: analysis results, error
+ * messages and output taken under a different version are outside it.
  *
- * @category Core
- */
-type OnsetTieBreak = 'highest' | 'lowest' | 'last';
-/**
- * Binary-searchable, stable-sorted index over note onsets and active spans.
+ * Changing what a generator returns for a version it already accepts is a
+ * defect. New behaviour raises this constant instead, and the older version
+ * keeps producing what it produced. Withdrawing an accepted version is a
+ * breaking change, and a project pinned to a withdrawn or not-yet-known
+ * version is rejected rather than reinterpreted.
  *
- * @category Core
+ * @category Utilities
  */
-type NoteEventIndex = {
-    notes: readonly IndexedNoteEvent[];
-    /**
-     * Latest-onset note sounding at `beat`. Simultaneous onsets are resolved by
-     * the index's {@link OnsetTieBreak}.
-     */
-    at: (beat: number) => IndexedNoteEvent | undefined;
-    /** Whether one or more sounding notes attack at `beat`. */
-    attacksAt: (beat: number) => boolean;
-    /** Unique sounding-note attack beats strictly inside `(startBeat, endBeat)`. */
-    onsetsBetween: (startBeat: number, endBeat: number) => number[];
-};
+declare const ALGORITHM_VERSION = 1;
 /**
- * Validate and stable-sort note events once, then expose logarithmic onset and
- * active-note lookups. Non-positive-duration notes may be retained for callers
- * that intentionally filter them later, but never count as sounding.
+ * The oldest algorithm version this build still produces.
  *
- * @category Core
- */
-declare function createNoteEventIndex(events: readonly NoteEvent[], options?: {
-    allowNonPositiveDuration?: boolean;
-    tieBreak?: OnsetTieBreak;
-    budget?: number;
-    /** What the events are, for the validation error message. */
-    name?: string;
-}): NoteEventIndex;
-
-/**
- * Counterpoint classification of a harmonic interval by consonance.
- *
- * Distinct from a spelled interval's quality label — see
- * {@link IntervalQualityLabel}, which names the `'P'` / `'M'` / `'m'` / `'A'` /
- * `'d'` spelling of an interval rather than how it sounds against another
- * voice.
- *
- * @see {@link IntervalQualityLabel}
- * @category Pitch & Intervals
+ * @category Utilities
  */
-declare enum ConsonanceClass {
-    PerfectConsonance = 0,
-    ImperfectConsonance = 1,
-    Dissonance = 2
-}
+declare const MIN_ALGORITHM_VERSION = 1;
 /**
- * Classify an interval for counterpoint evaluation.
+ * Resolve the algorithm version a request runs under.
  *
- * The interval is reduced modulo 12, so compound intervals classify as their
- * simple equivalents. The perfect fourth (5) is context-dependent: with
- * `twoVoice` (the default) it classifies as a dissonance, matching
- * {@link isConsonantInterval}; otherwise it is an imperfect consonance.
+ * An unpinned request runs at {@link ALGORITHM_VERSION}, which is what a
+ * caller who wants the current behaviour means; a caller who wants the piece
+ * back records the resolved number and passes it next time. A version this
+ * build does not produce is rejected — a project saved by a newer build cannot
+ * be reproduced by an older one, and quietly rendering it at another version
+ * would return a different piece under the same name.
  *
- * @param semitones Interval size in semitones (may be negative or compound).
- * @param twoVoice When true, the perfect fourth is treated as dissonant.
- * @returns The counterpoint quality of the interval.
+ * @param requested The pinned version, or undefined for the current one.
+ * @returns The version to generate under.
+ * @throws If the version is not an integer this build produces.
  * @example
  * ```ts
- * import { classifyInterval, ConsonanceClass } from '@libraz/libcantus';
- * classifyInterval(7); // ConsonanceClass.PerfectConsonance
- * classifyInterval(5); // ConsonanceClass.Dissonance (two-voice)
- * classifyInterval(5, false); // ConsonanceClass.ImperfectConsonance
+ * import { ALGORITHM_VERSION, resolveAlgorithmVersion } from '@libraz/libcantus';
+ * resolveAlgorithmVersion(undefined); // ALGORITHM_VERSION
+ * resolveAlgorithmVersion(ALGORITHM_VERSION); // the pinned value, unchanged
  * ```
- * @category Pitch & Intervals
- */
-declare function classifyInterval(semitones: number, twoVoice?: boolean): ConsonanceClass;
-/**
- * Test whether an interval is a perfect consonance: the unison/octave or the
- * fifth.
- *
- * The perfect fourth is deliberately excluded. This is the predicate the
- * parallel-motion rules are written against, where the fourth behaves as a
- * dissonance between two voices; {@link classifyInterval} is the general
- * classifier, and it treats the fourth as context-dependent.
- *
- * @param semitones Interval size in semitones (may be negative or compound).
- * @returns True for the unison/octave (0) and the perfect fifth (7) mod 12.
- * @category Pitch & Intervals
- */
-declare function isPerfectInterval(semitones: number): boolean;
-/**
- * Test whether an interval is consonant.
- *
- * The consonant set is {0, 3, 4, 5, 7, 8, 9} mod 12. In two-voice counterpoint
- * the perfect fourth (5) is treated as a dissonance, so `twoVoice` set to true
- * excludes it.
- *
- * @param semitones Interval size in semitones (may be negative or compound).
- * @param twoVoice When true, the perfect fourth is treated as dissonant.
- * @returns True if the interval is consonant in the given context.
- * @category Pitch & Intervals
+ * @category Utilities
  */
-declare function isConsonantInterval(semitones: number, twoVoice?: boolean): boolean;
+declare function resolveAlgorithmVersion(requested?: number): number;
 
 /**
  * Deterministic seeded pseudo-random number generation shared across the
  * generative modules (rhythm, drums, bass, groove, counter-melody). A single
  * mulberry32 core exposes the small set of samplers those modules need; given a
  * seed the stream is fully reproducible.
+ *
+ * Around that core sit the pieces that make a whole project reproducible: seeds
+ * derived hierarchically from one project number, draws addressed by position
+ * rather than by call order, and the algorithm version the output is pinned to.
  */
+
 /**
  * A deterministic PRNG with the sampling helpers the generators need.
  *
@@ -239,183 +133,6 @@ type Rng = {
  */
 declare function createRng(seed: number): Rng;
 
-/**
- * Tuning and microtonality: frequency conversion, cents, arbitrary equal
- * temperaments (EDO), and just-intonation ratios.
- *
- * The rest of the library reasons in twelve-tone pitch classes, which is a
- * deliberate scope choice for tonal theory. This module is the escape hatch for
- * anyone who needs actual frequencies, cents, non-12 equal temperaments, or the
- * acoustic (just) tuning behind the tempered intervals.
- */
-/**
- * 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
- */
-type Tuning = {
-    /** Step index (MIDI number when `divisions` is 12) whose frequency is `refFreq`. */
-    readonly refStep: number;
-    /** Frequency in Hz of `refStep`. */
-    readonly refFreq: number;
-    /** Equal divisions of the octave (12 standard; e.g. 19 or 31 for microtonal). */
-    readonly divisions: number;
-};
-/**
- * Standard twelve-tone equal temperament, A4 (MIDI 69) = 440 Hz.
- *
- * @category Pitch & Intervals
- */
-declare const TWELVE_TET: Tuning;
-/**
- * Build an equal temperament with `n` divisions of the octave.
- *
- * @param n Divisions of the octave (e.g. 19, 24, 31).
- * @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
- */
-declare function edo(n: number, refFreq?: number, refStep?: number): Tuning;
-/**
- * Frequency in Hz of a step index under a 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
- */
-declare function frequencyOf(step: number, tuning?: Tuning): number;
-/**
- * Nearest step index to a frequency under a tuning (the inverse of
- * {@link frequencyOf}, rounded).
- *
- * @param freq Frequency in Hz.
- * @param tuning The tuning (default 12-TET).
- * @returns The nearest step index.
- * @category Pitch & Intervals
- */
-declare function nearestStep(freq: number, tuning?: Tuning): number;
-/**
- * Step index of a frequency under a tuning, unrounded.
- *
- * The exact inverse of {@link frequencyOf}. {@link nearestStep} rounds it,
- * which discards how far off the pitch actually is — the figure a tuner
- * display, a pitch-bend amount, or an intonation check is built on.
- *
- * @param freq Frequency in Hz.
- * @param tuning The tuning (default 12-TET).
- * @returns The fractional step index.
- * @example
- * ```ts
- * import { stepOf } from '@libraz/libcantus';
- * stepOf(442); // slightly above 69, the step for A440
- * ```
- * @category Pitch & Intervals
- */
-declare function stepOf(freq: number, tuning?: Tuning): number;
-/**
- * How far a frequency sits from its nearest step, in cents.
- *
- * Positive means sharp of the step, negative flat.
- *
- * @param freq Frequency in Hz.
- * @param tuning The tuning (default 12-TET).
- * @returns The signed deviation in cents.
- * @example
- * ```ts
- * import { centsFromNearestStep } from '@libraz/libcantus';
- * Math.round(centsFromNearestStep(442)); // 8
- * ```
- * @category Pitch & Intervals
- */
-declare function centsFromNearestStep(freq: number, tuning?: Tuning): number;
-/**
- * Steps spanned by an interval in cents, unrounded — the inverse of
- * {@link centsOfSteps}.
- *
- * @param cents The interval in cents.
- * @param tuning The tuning (default 12-TET).
- * @returns The fractional step count.
- * @category Pitch & Intervals
- */
-declare function stepsOfCents(cents: number, tuning?: Tuning): number;
-/**
- * The frequency ratio an interval in cents spans — the inverse of
- * {@link ratioToCents}.
- *
- * Multiply a frequency by this to move it by that many cents, which is how a
- * cents offset (a pitch-bend spec, a tuning table entry) is applied.
- *
- * @param cents The interval in cents.
- * @returns The frequency ratio.
- * @example
- * ```ts
- * import { centsToRatio } from '@libraz/libcantus';
- * 440 * centsToRatio(14); // A440 raised by 14 cents
- * ```
- * @category Pitch & Intervals
- */
-declare function centsToRatio(cents: number): number;
-/**
- * Interval in cents between two frequencies.
- *
- * @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
- */
-declare function centsBetweenFreq(a: number, b: number): number;
-/**
- * Cents spanned by a number of equal-temperament steps.
- *
- * @param steps Number of steps.
- * @param tuning The tuning (default 12-TET).
- * @returns The cents.
- * @category Pitch & Intervals
- */
-declare function centsOfSteps(steps: number, tuning?: Tuning): number;
-/**
- * Cents of a frequency ratio, e.g. `ratioToCents(3, 2)` ≈ 701.955 for the just
- * perfect fifth.
- *
- * @param numerator Ratio numerator.
- * @param denominator Ratio denominator.
- * @returns The interval in cents.
- * @category Pitch & Intervals
- */
-declare 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
- */
-declare const JUST_RATIOS: Readonly<Record<number, readonly [number, number]>>;
-/**
- * Cents by which a five-limit just interval departs from its 12-TET tempering
- * (positive means the just interval is wider).
- *
- * @param semitoneClass Semitone class in [0, 12].
- * @returns The deviation in cents.
- * @throws If `semitoneClass` is not an integer in [0, 12].
- * @category Pitch & Intervals
- */
-declare function justDeviationCents(semitoneClass: number): number;
-
 /**
  * Default upper bound for synchronous event/window/candidate generation.
  *
@@ -438,7 +155,11 @@ declare function assertInteger(value: number, name: string, min?: number, max?:
 declare function assertMidiPitch(value: number, name?: string): number;
 /** Clamp an integer MIDI pitch to the inclusive range 0..127. */
 declare function clampToMidi(value: number, name?: string): number;
-/** Require a bounded integer scale/chord degree. */
+/**
+ * Require a bounded scale/chord degree, counted from 1 the way musicians count
+ * degrees: 1 is the tonic, 5 the dominant. Zero and negative degrees name no
+ * degree at all and are rejected.
+ */
 declare function assertDegree(value: number, name?: string): number;
 /** Require a finite semitone offset before pitch-class reduction. */
 declare function assertFiniteSemitones(value: number, name?: string): number;
@@ -503,6 +224,17 @@ declare function assertGenerationBudget(estimated: number, name: string, limit?:
  * @category Core
  */
 declare function assertTimeSignature(ts: TimeSignature, name?: string): TimeSignature;
+/**
+ * Validate a meter map: a non-empty run of time signatures, each with the beat
+ * it takes effect at, in strictly increasing beat order.
+ *
+ * The first entry also governs everything before it, so a map need not start at
+ * beat 0 — that is what lets a pickup at a negative beat be read in the
+ * signature the piece opens in.
+ *
+ * @category Core
+ */
+declare function assertMeterMap(meters: MeterMap, name?: string): MeterMap;
 /**
  * How strictly {@link assertNoteEvent} and {@link assertNoteEvents} read an
  * event array.
@@ -517,6 +249,15 @@ type NoteEventAssertOptions = {
     allowNonPositiveDuration?: boolean;
     /** Upper bound on the event count; defaults to the generation budget. */
     budget?: number;
+    /**
+     * Earliest accepted onset. Onsets are unbounded below by default, because a
+     * pickup sounds before the downbeat and the downbeat is beat 0; pass
+     * `-pickupBeats` to reject a note starting earlier than the pickup a caller
+     * has declared.
+     *
+     * @defaultValue `-Number.MAX_SAFE_INTEGER`
+     */
+    minStartBeat?: number;
 };
 /**
  * Validate the finite fields of one timeline note event.
@@ -531,4 +272,4 @@ declare function assertNoteEvent(event: NoteEvent, name?: string, options?: Note
  */
 declare function assertNoteEvents(events: readonly NoteEvent[], name?: string, options?: NoteEventAssertOptions): NoteEvent[];
 
-export { BudgetExceededError, ConsonanceClass, DEFAULT_GENERATION_BUDGET, type IndexedNoteEvent, InvalidInputError, JUST_RATIOS, type LibcantusErrorCode, NoSolutionError, NoteEvent, type NoteEventAssertOptions, type NoteEventIndex, type OnsetTieBreak, type Rng, TWELVE_TET, TimeSignature, type Tuning, assertDegree, assertFiniteNumber, assertFiniteSemitones, assertGenerationBudget, assertInteger, assertMidiPitch, assertNoteEvent, assertNoteEvents, assertOneOf, assertPositiveInt, assertRange, assertTimeSignature, centsBetweenFreq, centsFromNearestStep, centsOfSteps, centsToRatio, clampToMidi, classifyInterval, createNoteEventIndex, createRng, dropSilentNotes, edo, frequencyOf, isConsonantInterval, isLibcantusError, isPerfectInterval, justDeviationCents, nearestStep, ratioToCents, soundingNotesOnly, stepOf, stepsOfCents };
+export { ALGORITHM_VERSION, BASS_4_STRING, BASS_5_STRING, DEFAULT_GENERATION_BUDGET, GUITAR_DROP_D, GUITAR_STANDARD, MIN_ALGORITHM_VERSION, MeterMap, NoteEvent, type NoteEventAssertOptions, type Rng, StringedProfile, TimeSignature, assertDegree, assertFiniteNumber, assertFiniteSemitones, assertGenerationBudget, assertInteger, assertMeterMap, assertMidiPitch, assertNoteEvent, assertNoteEvents, assertOneOf, assertPositiveInt, assertRange, assertTimeSignature, clampToMidi, createRng, dropSilentNotes, resolveAlgorithmVersion, soundingNotesOnly };