@libraz/libcantus 0.9.3 → 0.9.4

package/dist/generate/index.js

@@ -1,6 +1,10 @@
 import {
+  BASS_STYLES,
+  BORROWED_DEGREES,
+  DRUM_NOTES,
   applyGrooveTemplate,
   developMotif,
+  drumVoiceOf,
   extractGrooveTemplate,
   generateBassLine,
   generateCounterMelody,
@@ -10,27 +14,34 @@ import {
   generateRhythm,
   harmonizeMelody,
   humanize,
+  motifToNoteEvents,
   onsetWeightCurve,
+  pickProgressionPreset,
   progressions,
   progressionsByStyle,
   rhythmDensity,
+  rhythmToNoteEvents,
   transformMotif
-} from "../chunk-4MHA432G.js";
-import "../chunk-62QZKCJQ.js";
-import "../chunk-I5R7ZBJS.js";
+} from "../chunk-7NKDPF74.js";
+import "../chunk-HKGYCQ34.js";
+import "../chunk-YLEMGEFH.js";
 import {
   modalInterchangePalette,
   negativeHarmonyMirror,
   substituteChord
-} from "../chunk-IT2O4XFE.js";
-import "../chunk-CHMXELDS.js";
-import "../chunk-2ZWMSJH6.js";
-import "../chunk-EH6EM37U.js";
-import "../chunk-MIWO425M.js";
-import "../chunk-FBQK3ZQN.js";
+} from "../chunk-GQSGS2N4.js";
+import "../chunk-KMHOICIY.js";
+import "../chunk-NKIBQ6PT.js";
+import "../chunk-NYYWMV2C.js";
+import "../chunk-D2FAJBYL.js";
+import "../chunk-XEBG3G53.js";
 export {
+  BASS_STYLES,
+  BORROWED_DEGREES,
+  DRUM_NOTES,
   applyGrooveTemplate,
   developMotif,
+  drumVoiceOf,
   extractGrooveTemplate,
   generateBassLine,
   generateCounterMelody,
@@ -41,11 +52,14 @@ export {
   harmonizeMelody,
   humanize,
   modalInterchangePalette,
+  motifToNoteEvents,
   negativeHarmonyMirror,
   onsetWeightCurve,
+  pickProgressionPreset,
   progressions,
   progressionsByStyle,
   rhythmDensity,
+  rhythmToNoteEvents,
   substituteChord,
   transformMotif
 };

package/dist/{index-CxqBQtH1.d.cts → index-6VR8-kit.d.ts}

@@ -1,5 +1,5 @@
-import { K as KeyScale } from './types-MGP29r3t.cjs';
-import { C as Chord } from './index-BNlGP86A.cjs';
+import { K as KeyScale } from './types-BN6_Q9Kl.js';
+import { C as Chord } from './index-C83mZI1P.js';
 
 /**
  * Severity policy: `strict` counterpoint vs. lenient `pop` voice-leading.
@@ -102,7 +102,22 @@ type SafetyResult = {
  * ```
  * @category Arrangement & Analysis
  */
-declare function evaluateSafety(q: SafetyQuery): SafetyResult;
+declare function evaluateSafety(q: SafetyQuery, opts?: EvaluateSafetyOptions): SafetyResult;
+/**
+ * Options for {@link evaluateSafety}.
+ *
+ * @category Arrangement & Analysis
+ */
+type EvaluateSafetyOptions = {
+    /**
+     * Whether to search for safe replacement pitches when the verdict is not
+     * safe. Turning it off skips up to two dozen extra evaluations per rejected
+     * pitch, which is worth doing when only the verdict is wanted.
+     *
+     * @defaultValue true
+     */
+    suggestions?: boolean;
+};
 /**
  * Enumerate placeable pitches in a range, chord tones first, descending.
  *
@@ -125,4 +140,4 @@ declare function evaluateSafety(q: SafetyQuery): SafetyResult;
  */
 declare function enumerateSafePitches(q: Omit<SafetyQuery, 'candidatePitch'>, pitchLow: number, pitchHigh: number): number[];
 
-export { NoteSafety as N, ReasonFlag as R, type SafetyProfile as S, type VoiceSnapshot as V, type SafetyQuery as a, type SafetyResult as b, evaluateSafety as c, enumerateSafePitches as e };
+export { type EvaluateSafetyOptions as E, NoteSafety as N, ReasonFlag as R, type SafetyProfile as S, type VoiceSnapshot as V, type SafetyQuery as a, type SafetyResult as b, evaluateSafety as c, enumerateSafePitches as e };

package/dist/index-70p168VM.d.ts

@@ -0,0 +1,192 @@
+import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.js';
+import { a as ChordQuality, C as Chord } from './index-C83mZI1P.js';
+
+/**
+ * Recognition: infer a chord name from a set of pitches, or a key from a set of
+ * pitch classes. This is the inverse direction of the chord/scale builders,
+ * which only go name -> notes.
+ */
+
+/**
+ * A candidate chord interpretation of a pitch set.
+ *
+ * @category Recognition
+ */
+type ChordMatch = {
+    rootPc: number;
+    quality: ChordQuality;
+    /** Chord tones absent from the input (an incomplete voicing). */
+    missingPcs: number[];
+    /** Input pitch classes not belonging to the chord. */
+    extraPcs: number[];
+    /** True when the input pitch-class set equals the chord exactly. */
+    exact: boolean;
+    /**
+     * Inversion implied by a known bass: 0 for root position, 1..n for an
+     * inversion. Null when no inversion can be named — either the input is an
+     * unordered pitch-class set with no bass, or the bass is not a chord tone (a
+     * pedal or passing bass), in which case `bassPc` still reports it.
+     */
+    inversion: number | null;
+    /** Bass pitch class when the lowest note is not the root. */
+    bassPc?: number;
+};
+/**
+ * Input interpretation for {@link detectChord} and {@link detectChordBest}.
+ *
+ * @category Recognition
+ */
+type DetectChordOptions = {
+    /**
+     * `midi` uses the numerically lowest pitch as bass; `pitchClass` treats the
+     * input as unordered. `auto` (default) selects pitch-class mode only when all
+     * values lie in 0..11.
+     */
+    input?: 'auto' | 'midi' | 'pitchClass';
+    /** Explicit bass pitch class, including for an unordered pitch-class set. */
+    bassPc?: number;
+};
+/**
+ * A candidate key interpretation of a pitch-class set.
+ *
+ * @category Recognition
+ */
+type KeyMatch = {
+    /** The scale that scored best for this tonic and mode, `variant` included. */
+    key: KeyScale;
+    mode: 'major' | 'minor';
+    /** Which scale form `key` uses; minor keys pick the best-scoring of the three. */
+    variant: KeyVariant;
+    /**
+     * Fraction of the distinct input pitch classes that belong to `key`, in
+     * [0, 1]. Measured against the returned scale, so it always agrees with
+     * `isScaleTone(pc, match.key)`. This is a coverage figure, not the ranking:
+     * see `score`.
+     */
+    fit: number;
+    /**
+     * The value the results are ranked by, in [0, 1.5]. Unlike `fit` it counts
+     * every occurrence rather than every distinct pitch class, so a repeated tone
+     * weighs more, and it adds half a count per sounding of the tonic itself to
+     * break ties between keys that contain the same notes.
+     */
+    score: number;
+};
+/**
+ * Which form of a scale a {@link KeyMatch} settled on.
+ *
+ * @category Recognition
+ */
+type KeyVariant = 'major' | 'natural' | 'harmonic' | 'melodic';
+/**
+ * Input weighting for {@link detectKey}.
+ *
+ * @category Recognition
+ */
+type DetectKeyOptions = {
+    /**
+     * How much each pitch counts toward the histogram, one entry per pitch.
+     * Defaults to one per pitch, which weighs a thirty-second-note ornament as
+     * heavily as the whole note under it. {@link detectKeyFromNotes} supplies
+     * duration times velocity, matching how chord inference weighs its own
+     * histogram.
+     */
+    weights?: readonly number[];
+};
+/**
+ * Identify chords matching a set of pitches.
+ *
+ * Every input pitch class is tried as a root against every known chord quality.
+ * A match is reported when all of the chord's tones are present in the input, or
+ * when the only absent tone is the perfect fifth (a common omission in shell
+ * voicings); matches are ranked best-first by fewest extra notes, then fewest
+ * missing notes, then most specific (largest) chord. An exact match (no extras,
+ * no missing) is flagged and ranked first.
+ *
+ * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).
+ * @returns Ranked chord interpretations (may be empty).
+ * @example
+ * ```ts
+ * import { detectChord } from '@libraz/libcantus';
+ * const matches = detectChord([60, 64, 67]); // C E G
+ * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }
+ * ```
+ * @category Recognition
+ */
+declare function detectChord(pitches: readonly number[], opts?: DetectChordOptions): ChordMatch[];
+/**
+ * The single best chord interpretation of a pitch set, or null if none.
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @returns The top-ranked chord, or null when nothing matches.
+ * @example
+ * ```ts
+ * import { detectChordBest } from '@libraz/libcantus';
+ * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }
+ * ```
+ * @category Recognition
+ */
+declare function detectChordBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null;
+/**
+ * Rank major and minor keys by how well they contain a set of pitch classes.
+ *
+ * Ranking is by `score`, which counts repetitions and adds a tonic weight so
+ * that, among equally-fitting keys, the one whose root is actually sounded is
+ * preferred. Minor candidates are scored against the natural, harmonic, and
+ * melodic minor variants and keep the best of the three, so a minor cadence
+ * containing the leading tone still resolves to its own tonic; the winning
+ * variant is what `key` and `variant` report, so `fit` describes the scale the
+ * caller receives. Returns all 24 keys ranked best-first, or an empty array for
+ * an empty input (mirroring {@link detectChord}).
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @returns Ranked key interpretations (empty for an empty input).
+ * @example
+ * ```ts
+ * import { detectKey } from '@libraz/libcantus';
+ * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale
+ * keys[0].mode; // 'major', with keys[0].key.rootPc === 0
+ * ```
+ * @category Recognition
+ */
+declare function detectKey(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch[];
+/**
+ * Rank keys by how well they contain a set of note events, weighting each note
+ * by how much of the music it actually occupies.
+ *
+ * {@link detectKey} counts every pitch once, which lets a run of fast ornamental
+ * notes outvote the sustained harmony that establishes the key. This weighs
+ * each note by duration times velocity, the same measure chord inference uses,
+ * so the two agree on what the music emphasises. Notes that never sound (zero
+ * or negative duration) are ignored.
+ *
+ * @param notes The note events to weigh.
+ * @returns Ranked key interpretations (empty when nothing sounds).
+ * @example
+ * ```ts
+ * import { detectKeyFromNotes } from '@libraz/libcantus';
+ * detectKeyFromNotes([{ pitch: 60, startBeat: 0, durationBeat: 4 }])[0]?.key.rootPc; // 0
+ * ```
+ * @category Recognition
+ */
+declare function detectKeyFromNotes(notes: readonly NoteEvent[]): KeyMatch[];
+/**
+ * The single best key interpretation of a pitch set.
+ *
+ * The counterpart of {@link detectChordBest}: the ranked list is the general
+ * answer, but a caller that just wants "what key is this" should not have to
+ * index into it and assert the result is there.
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @param opts How to weigh the input; see {@link DetectKeyOptions}.
+ * @returns The top-ranked key, or null when nothing sounds.
+ * @example
+ * ```ts
+ * import { detectKeyBest } from '@libraz/libcantus';
+ * detectKeyBest([0, 2, 4, 5, 7, 9, 11])?.mode; // 'major'
+ * ```
+ * @category Recognition
+ */
+declare function detectKeyBest(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch | null;
+
+export { type ChordMatch as C, type DetectChordOptions as D, type KeyMatch as K, type DetectKeyOptions as a, type KeyVariant as b, detectChordBest as c, detectChord as d, detectKey as e, detectKeyBest as f, detectKeyFromNotes as g };

package/dist/{index-CpOsP1y9.d.cts → index-Be74mcon.d.cts}

@@ -1,18 +1,8 @@
-import { T as TimeSignature } from './index-Cl7mhOFM.cjs';
-import { K as KeyScale, N as NoteEvent } from './types-MGP29r3t.cjs';
-import { C as Chord, b as ChordSpan } from './index-BNlGP86A.cjs';
-import { C as Cadence } from './function-DYt4iKsn.cjs';
+import { T as TimeSignature } from './index-DXd9JikN.cjs';
+import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
+import { C as Chord, b as ChordSegment, c as ChordSpan } from './index-y_ak9_Hi.cjs';
+import { C as Cadence } from './function-DNugAOrt.cjs';
 
-/**
- * A chord occupying a half-open beat span.
- *
- * @category Arrangement & Analysis
- */
-type ChordSegment = {
-    startBeat: number;
-    endBeat: number;
-    chord: Chord;
-};
 /**
  * A beat-indexed sequence of chord segments.
  *
@@ -36,14 +26,14 @@ type ChordTimeline = {
  * @returns A queryable chord timeline.
  * @category Arrangement & Analysis
  */
-declare function chordTimelineFromChords(chords: ChordSpan[], totalBeats: number): ChordTimeline;
+declare function chordTimelineFromChords(chords: readonly ChordSpan[], totalBeats: number): ChordTimeline;
 /**
  * Options controlling {@link chordTimelineFromNotes}.
  *
  * @category Arrangement & Analysis
  */
 type ChordTimelineOptions = {
-    /** Key context; inferred from the notes with {@link detectKey} when omitted. */
+    /** Key context; inferred from the notes with {@link detectKeyFromNotes} when omitted. */
     key?: KeyScale;
     /**
      * Time signature used for metric accents; defaults to 4/4.
@@ -63,6 +53,17 @@ type ChordTimelineOptions = {
      * @defaultValue the end of the last note
      */
     totalBeats?: number;
+    /**
+     * Upper bound on the work this call may do — note counts, windows, and
+     * candidate counts are each checked against it before anything is allocated.
+     *
+     * Raise it to analyse a piece larger than the default allows; the default is
+     * {@link DEFAULT_GENERATION_BUDGET}, chosen so a runaway input fails fast
+     * rather than blocking the thread.
+     *
+     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
+     */
+    budget?: number;
 };
 /**
  * The result of {@link chordTimelineFromNotes}.
@@ -148,4 +149,4 @@ type CadenceHit = {
  */
 declare function detectCadences(timeline: ChordTimeline, key: KeyScale): CadenceHit[];
 
-export { type CadenceHit as C, type ChordSegment as a, type ChordTimeline as b, type ChordTimelineOptions as c, type ChordTimelineResult as d, chordTimelineFromChords as e, chordTimelineFromNotes as f, detectCadences as g };
+export { type CadenceHit as C, type ChordTimeline as a, type ChordTimelineOptions as b, type ChordTimelineResult as c, chordTimelineFromChords as d, chordTimelineFromNotes as e, detectCadences as f };

package/dist/index-BtXT6UQ0.d.cts

@@ -0,0 +1,192 @@
+import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
+import { a as ChordQuality, C as Chord } from './index-y_ak9_Hi.cjs';
+
+/**
+ * Recognition: infer a chord name from a set of pitches, or a key from a set of
+ * pitch classes. This is the inverse direction of the chord/scale builders,
+ * which only go name -> notes.
+ */
+
+/**
+ * A candidate chord interpretation of a pitch set.
+ *
+ * @category Recognition
+ */
+type ChordMatch = {
+    rootPc: number;
+    quality: ChordQuality;
+    /** Chord tones absent from the input (an incomplete voicing). */
+    missingPcs: number[];
+    /** Input pitch classes not belonging to the chord. */
+    extraPcs: number[];
+    /** True when the input pitch-class set equals the chord exactly. */
+    exact: boolean;
+    /**
+     * Inversion implied by a known bass: 0 for root position, 1..n for an
+     * inversion. Null when no inversion can be named — either the input is an
+     * unordered pitch-class set with no bass, or the bass is not a chord tone (a
+     * pedal or passing bass), in which case `bassPc` still reports it.
+     */
+    inversion: number | null;
+    /** Bass pitch class when the lowest note is not the root. */
+    bassPc?: number;
+};
+/**
+ * Input interpretation for {@link detectChord} and {@link detectChordBest}.
+ *
+ * @category Recognition
+ */
+type DetectChordOptions = {
+    /**
+     * `midi` uses the numerically lowest pitch as bass; `pitchClass` treats the
+     * input as unordered. `auto` (default) selects pitch-class mode only when all
+     * values lie in 0..11.
+     */
+    input?: 'auto' | 'midi' | 'pitchClass';
+    /** Explicit bass pitch class, including for an unordered pitch-class set. */
+    bassPc?: number;
+};
+/**
+ * A candidate key interpretation of a pitch-class set.
+ *
+ * @category Recognition
+ */
+type KeyMatch = {
+    /** The scale that scored best for this tonic and mode, `variant` included. */
+    key: KeyScale;
+    mode: 'major' | 'minor';
+    /** Which scale form `key` uses; minor keys pick the best-scoring of the three. */
+    variant: KeyVariant;
+    /**
+     * Fraction of the distinct input pitch classes that belong to `key`, in
+     * [0, 1]. Measured against the returned scale, so it always agrees with
+     * `isScaleTone(pc, match.key)`. This is a coverage figure, not the ranking:
+     * see `score`.
+     */
+    fit: number;
+    /**
+     * The value the results are ranked by, in [0, 1.5]. Unlike `fit` it counts
+     * every occurrence rather than every distinct pitch class, so a repeated tone
+     * weighs more, and it adds half a count per sounding of the tonic itself to
+     * break ties between keys that contain the same notes.
+     */
+    score: number;
+};
+/**
+ * Which form of a scale a {@link KeyMatch} settled on.
+ *
+ * @category Recognition
+ */
+type KeyVariant = 'major' | 'natural' | 'harmonic' | 'melodic';
+/**
+ * Input weighting for {@link detectKey}.
+ *
+ * @category Recognition
+ */
+type DetectKeyOptions = {
+    /**
+     * How much each pitch counts toward the histogram, one entry per pitch.
+     * Defaults to one per pitch, which weighs a thirty-second-note ornament as
+     * heavily as the whole note under it. {@link detectKeyFromNotes} supplies
+     * duration times velocity, matching how chord inference weighs its own
+     * histogram.
+     */
+    weights?: readonly number[];
+};
+/**
+ * Identify chords matching a set of pitches.
+ *
+ * Every input pitch class is tried as a root against every known chord quality.
+ * A match is reported when all of the chord's tones are present in the input, or
+ * when the only absent tone is the perfect fifth (a common omission in shell
+ * voicings); matches are ranked best-first by fewest extra notes, then fewest
+ * missing notes, then most specific (largest) chord. An exact match (no extras,
+ * no missing) is flagged and ranked first.
+ *
+ * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).
+ * @returns Ranked chord interpretations (may be empty).
+ * @example
+ * ```ts
+ * import { detectChord } from '@libraz/libcantus';
+ * const matches = detectChord([60, 64, 67]); // C E G
+ * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }
+ * ```
+ * @category Recognition
+ */
+declare function detectChord(pitches: readonly number[], opts?: DetectChordOptions): ChordMatch[];
+/**
+ * The single best chord interpretation of a pitch set, or null if none.
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @returns The top-ranked chord, or null when nothing matches.
+ * @example
+ * ```ts
+ * import { detectChordBest } from '@libraz/libcantus';
+ * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }
+ * ```
+ * @category Recognition
+ */
+declare function detectChordBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null;
+/**
+ * Rank major and minor keys by how well they contain a set of pitch classes.
+ *
+ * Ranking is by `score`, which counts repetitions and adds a tonic weight so
+ * that, among equally-fitting keys, the one whose root is actually sounded is
+ * preferred. Minor candidates are scored against the natural, harmonic, and
+ * melodic minor variants and keep the best of the three, so a minor cadence
+ * containing the leading tone still resolves to its own tonic; the winning
+ * variant is what `key` and `variant` report, so `fit` describes the scale the
+ * caller receives. Returns all 24 keys ranked best-first, or an empty array for
+ * an empty input (mirroring {@link detectChord}).
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @returns Ranked key interpretations (empty for an empty input).
+ * @example
+ * ```ts
+ * import { detectKey } from '@libraz/libcantus';
+ * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale
+ * keys[0].mode; // 'major', with keys[0].key.rootPc === 0
+ * ```
+ * @category Recognition
+ */
+declare function detectKey(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch[];
+/**
+ * Rank keys by how well they contain a set of note events, weighting each note
+ * by how much of the music it actually occupies.
+ *
+ * {@link detectKey} counts every pitch once, which lets a run of fast ornamental
+ * notes outvote the sustained harmony that establishes the key. This weighs
+ * each note by duration times velocity, the same measure chord inference uses,
+ * so the two agree on what the music emphasises. Notes that never sound (zero
+ * or negative duration) are ignored.
+ *
+ * @param notes The note events to weigh.
+ * @returns Ranked key interpretations (empty when nothing sounds).
+ * @example
+ * ```ts
+ * import { detectKeyFromNotes } from '@libraz/libcantus';
+ * detectKeyFromNotes([{ pitch: 60, startBeat: 0, durationBeat: 4 }])[0]?.key.rootPc; // 0
+ * ```
+ * @category Recognition
+ */
+declare function detectKeyFromNotes(notes: readonly NoteEvent[]): KeyMatch[];
+/**
+ * The single best key interpretation of a pitch set.
+ *
+ * The counterpart of {@link detectChordBest}: the ranked list is the general
+ * answer, but a caller that just wants "what key is this" should not have to
+ * index into it and assert the result is there.
+ *
+ * @param pitches MIDI pitches or bare pitch classes.
+ * @param opts How to weigh the input; see {@link DetectKeyOptions}.
+ * @returns The top-ranked key, or null when nothing sounds.
+ * @example
+ * ```ts
+ * import { detectKeyBest } from '@libraz/libcantus';
+ * detectKeyBest([0, 2, 4, 5, 7, 9, 11])?.mode; // 'major'
+ * ```
+ * @category Recognition
+ */
+declare function detectKeyBest(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch | null;
+
+export { type ChordMatch as C, type DetectChordOptions as D, type KeyMatch as K, type DetectKeyOptions as a, type KeyVariant as b, detectChordBest as c, detectChord as d, detectKey as e, detectKeyBest as f, detectKeyFromNotes as g };

package/dist/{index-DxvARIP2.d.ts → index-C5UBbQ4G.d.ts}

@@ -1,18 +1,8 @@
-import { T as TimeSignature } from './index-Cl7mhOFM.js';
-import { K as KeyScale, N as NoteEvent } from './types-MGP29r3t.js';
-import { C as Chord, b as ChordSpan } from './index-Bt4tOUD9.js';
-import { C as Cadence } from './function-DVH4Eusr.js';
+import { T as TimeSignature } from './index-DXd9JikN.js';
+import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.js';
+import { C as Chord, b as ChordSegment, c as ChordSpan } from './index-C83mZI1P.js';
+import { C as Cadence } from './function-BtiZb9i9.js';
 
-/**
- * A chord occupying a half-open beat span.
- *
- * @category Arrangement & Analysis
- */
-type ChordSegment = {
-    startBeat: number;
-    endBeat: number;
-    chord: Chord;
-};
 /**
  * A beat-indexed sequence of chord segments.
  *
@@ -36,14 +26,14 @@ type ChordTimeline = {
  * @returns A queryable chord timeline.
  * @category Arrangement & Analysis
  */
-declare function chordTimelineFromChords(chords: ChordSpan[], totalBeats: number): ChordTimeline;
+declare function chordTimelineFromChords(chords: readonly ChordSpan[], totalBeats: number): ChordTimeline;
 /**
  * Options controlling {@link chordTimelineFromNotes}.
  *
  * @category Arrangement & Analysis
  */
 type ChordTimelineOptions = {
-    /** Key context; inferred from the notes with {@link detectKey} when omitted. */
+    /** Key context; inferred from the notes with {@link detectKeyFromNotes} when omitted. */
     key?: KeyScale;
     /**
      * Time signature used for metric accents; defaults to 4/4.
@@ -63,6 +53,17 @@ type ChordTimelineOptions = {
      * @defaultValue the end of the last note
      */
     totalBeats?: number;
+    /**
+     * Upper bound on the work this call may do — note counts, windows, and
+     * candidate counts are each checked against it before anything is allocated.
+     *
+     * Raise it to analyse a piece larger than the default allows; the default is
+     * {@link DEFAULT_GENERATION_BUDGET}, chosen so a runaway input fails fast
+     * rather than blocking the thread.
+     *
+     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
+     */
+    budget?: number;
 };
 /**
  * The result of {@link chordTimelineFromNotes}.
@@ -148,4 +149,4 @@ type CadenceHit = {
  */
 declare function detectCadences(timeline: ChordTimeline, key: KeyScale): CadenceHit[];
 
-export { type CadenceHit as C, type ChordSegment as a, type ChordTimeline as b, type ChordTimelineOptions as c, type ChordTimelineResult as d, chordTimelineFromChords as e, chordTimelineFromNotes as f, detectCadences as g };
+export { type CadenceHit as C, type ChordTimeline as a, type ChordTimelineOptions as b, type ChordTimelineResult as c, chordTimelineFromChords as d, chordTimelineFromNotes as e, detectCadences as f };