@libraz/libcantus 0.9.4 → 1.0.0

package/dist/core/index.d.cts

@@ -1,213 +1,107 @@
-import { N as NoteEvent } from '../types-BN6_Q9Kl.cjs';
-export { K as KeyScale } from '../types-BN6_Q9Kl.cjs';
-import { T as TimeSignature } from '../index-DXd9JikN.cjs';
-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.cjs';
-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-OG65ocOr.cjs';
+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-CGpRv5sl.cjs';
+import { g as NoteEvent } from '../index-B9MNZboQ.cjs';
+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.cjs';
+import { f as StringedProfile } from '../positional-DvH_sd8u.cjs';
+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-DvH_sd8u.cjs';
+export { C as ConsonanceClass, c as classifyInterval, i as isConsonantInterval, a as isPerfectInterval } from '../index-DInQqT8Q.cjs';
+import { c as MeterMap, T as TimeSignature } from '../index-BkGmlyI3.cjs';
+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-BkGmlyI3.cjs';
 
 /**
- * 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: 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: 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.
  *
@@ -434,6 +151,18 @@ declare function assertFiniteNumber(value: number, name: string): number;
  * @category Core
  */
 declare function assertInteger(value: number, name: string, min?: number, max?: number): number;
+/** Require an integer MIDI pitch in the inclusive range 0..127. */
+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 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;
 /**
  * Drop the notes that never sound.
  *
@@ -452,6 +181,8 @@ declare function assertInteger(value: number, name: string, min?: number, max?:
  * @category Core
  */
 declare function dropSilentNotes(events: readonly NoteEvent[]): NoteEvent[];
+/** Alias that makes the shared positive-duration policy explicit at API entrances. */
+declare const soundingNotesOnly: typeof dropSilentNotes;
 /**
  * Require a value to be one of a fixed set of names.
  *
@@ -493,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.
@@ -507,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.
@@ -521,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, assertFiniteNumber, assertGenerationBudget, assertInteger, assertNoteEvent, assertNoteEvents, assertOneOf, assertPositiveInt, assertRange, assertTimeSignature, centsBetweenFreq, centsFromNearestStep, centsOfSteps, centsToRatio, classifyInterval, createNoteEventIndex, createRng, dropSilentNotes, edo, frequencyOf, isConsonantInterval, isLibcantusError, isPerfectInterval, justDeviationCents, nearestStep, ratioToCents, 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 };