@libraz/libcantus 0.9.3 → 0.9.5

package/dist/{index-DxvARIP2.d.ts → index-DRtIhlJj.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-COw1Ky9g.js';
+import { C as Cadence } from './function-DTCt675z.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 };

package/dist/{index-Cl7mhOFM.d.cts → index-DXd9JikN.d.cts}

@@ -16,9 +16,17 @@ type TimeSignature = {
     /**
      * Optional additive grouping of the bar's main pulses, as the felt-beat
      * lengths in pulses — e.g. `[2, 2, 3]` for a 2+2+3 reading of 7/8, or
-     * `[3, 2]` for 5/8. The entries must be positive integers summing to
-     * {@link pulsesPerBar}. When present, the head pulse of each group (other
-     * than the downbeat) is treated as a secondary strong pulse by
+     * `[3, 2]` for 5/8. The entries must be positive integers summing to the
+     * numerator.
+     *
+     * A compound numerator accepts both readings. 9/8 groups its three dotted
+     * pulses as `[1, 1, 1]`, or reads additively as `[2, 2, 2, 3]` quavers; a
+     * grouping that sums to the numerator selects the additive reading, so
+     * aksak and other additive metres are expressible. {@link pulsesPerBar}
+     * and {@link isCompound} follow whichever reading the grouping selects.
+     *
+     * When present, the head pulse of each group (other than the downbeat) is
+     * treated as a secondary strong pulse by
      * {@link metricWeight}/{@link isStrongBeat}; when absent, all main pulses
      * are weighted equally as flat, evenly divided pulses.
      */
@@ -30,8 +38,13 @@ type TimeSignature = {
  * @category Rhythm & Meter
  */
 type BarPosition = {
+    /** 0-based bar index. {@link formatBarPosition} renders it 1-based. */
     bar: number;
-    /** Quarter-note offset from the start of the bar. */
+    /**
+     * Quarter-note offset from the start of the bar — not the felt beat. In 6/8
+     * the second felt beat is at `beat: 1.5`; {@link barPositionToPulse} converts
+     * to felt-beat numbering.
+     */
     beat: number;
 };
 /**
@@ -49,16 +62,34 @@ type BarPosition = {
  */
 declare function parseTimeSignature(text: string): TimeSignature;
 /**
- * Render a time signature as `"n/d"`.
+ * Render a time signature as `"n/d"`, or as `"a+b+c/d"` when it carries an
+ * additive grouping and `grouping` is requested.
+ *
+ * The plain form drops the grouping, so a round trip through it reads 7/8 as
+ * flat rather than as 2+2+3; ask for the additive form to keep it.
  *
+ * @param ts The time signature.
+ * @param opts Set `grouping: true` to render an additive grouping.
+ * @returns The formatted signature.
+ * @example
+ * ```ts
+ * import { formatTimeSignature } from '@libraz/libcantus';
+ * const aksak = { numerator: 7, denominator: 8, grouping: [2, 2, 3] };
+ * formatTimeSignature(aksak); // '7/8'
+ * formatTimeSignature(aksak, { grouping: true }); // '2+2+3/8'
+ * ```
  * @category Rhythm & Meter
  */
-declare function formatTimeSignature(ts: TimeSignature): string;
+declare function formatTimeSignature(ts: TimeSignature, opts?: {
+    grouping?: boolean;
+}): string;
 /**
  * Whether a meter is compound: its main pulses each divide into three, as in
  * 6/8, 9/8, 12/8, or 6/4. Compound meters are those whose numerator is a
  * multiple of three greater than three, independent of the denominator. Meters
- * like 3/8 and 3/4 (simple triples, numerator 3) are not compound.
+ * like 3/8 and 3/4 (simple triples, numerator 3) are not compound, and neither
+ * is a signature whose {@link TimeSignature.grouping} selects the additive
+ * reading (9/8 as 2+2+2+3).
  *
  * @param ts The time signature.
  * @returns True for compound meters.
@@ -103,6 +134,57 @@ declare function pulsesPerBar(ts: TimeSignature): number;
  * @category Rhythm & Meter
  */
 declare function beatToBarPosition(beatInQuarters: number, ts: TimeSignature): BarPosition;
+/**
+ * Length of one felt beat (main pulse) in quarter-note beats.
+ *
+ * A quarter note in simple meters, a dotted quarter in compound ones, and one
+ * denominator unit in an additive metre. Position displays, click tracks, and
+ * score export are all written against this length.
+ *
+ * @param ts The time signature.
+ * @returns The pulse length in quarter-note beats.
+ * @example
+ * ```ts
+ * import { parseTimeSignature, pulseBeats } from '@libraz/libcantus';
+ * pulseBeats(parseTimeSignature('6/8')); // 1.5
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function pulseBeats(ts: TimeSignature): number;
+/**
+ * The felt-beat number of a bar position, 1-based.
+ *
+ * {@link BarPosition.beat} is a quarter-note offset, so in 6/8 the second felt
+ * beat reads as 1.5. This is the number a musician says and a position display
+ * shows.
+ *
+ * @param pos The bar position.
+ * @param ts The time signature.
+ * @returns The 1-based felt-beat number, fractional between pulses.
+ * @example
+ * ```ts
+ * import { barPositionToPulse, parseTimeSignature } from '@libraz/libcantus';
+ * barPositionToPulse({ bar: 0, beat: 1.5 }, parseTimeSignature('6/8')); // 2
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function barPositionToPulse(pos: BarPosition, ts: TimeSignature): number;
+/**
+ * Render an absolute position as the `bar.beat` a DAW or a score shows:
+ * 1-based bar, 1-based felt beat.
+ *
+ * @param beatInQuarters Absolute position in quarter-note beats.
+ * @param ts The time signature.
+ * @param decimals Digits of the fractional beat to keep.
+ * @returns The formatted position, e.g. `'3.2'` for bar 3, felt beat 2.
+ * @example
+ * ```ts
+ * import { formatBarPosition, parseTimeSignature } from '@libraz/libcantus';
+ * formatBarPosition(7.5, parseTimeSignature('6/8')); // '3.2'
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function formatBarPosition(beatInQuarters: number, ts: TimeSignature, decimals?: number): string;
 /**
  * Convert a bar index and in-bar offset back to an absolute quarter-note
  * position.
@@ -128,8 +210,8 @@ declare function barPositionToBeat(pos: BarPosition, ts: TimeSignature): number;
  * @param beatInQuarters Absolute or in-bar quarter-note position.
  * @param ts The time signature.
  * @returns The metric weight (0–3).
- * @throws If `ts.grouping` is present but is not a positive-integer list
- *   summing to {@link pulsesPerBar}.
+ * @throws If the time signature is malformed, including a grouping that is not
+ *   a positive-integer list summing to the pulse count or the numerator.
  * @example
  * ```ts
  * import { parseTimeSignature, metricWeight } from '@libraz/libcantus';
@@ -161,4 +243,4 @@ declare function isStrongBeat(beatInQuarters: number, ts: TimeSignature): boolea
  */
 declare function tuplet(totalBeats: number, count: number): number[];
 
-export { type BarPosition as B, type TimeSignature as T, beatToBarPosition as a, barPositionToBeat as b, beatsPerBar as c, isStrongBeat as d, pulsesPerBar as e, formatTimeSignature as f, isCompound as i, metricWeight as m, parseTimeSignature as p, tuplet as t };
+export { type BarPosition as B, type TimeSignature as T, barPositionToPulse as a, barPositionToBeat as b, beatToBarPosition as c, beatsPerBar as d, formatTimeSignature as e, formatBarPosition as f, isStrongBeat as g, pulseBeats as h, isCompound as i, pulsesPerBar as j, metricWeight as m, parseTimeSignature as p, tuplet as t };

package/dist/{index-Cl7mhOFM.d.ts → index-DXd9JikN.d.ts}

@@ -16,9 +16,17 @@ type TimeSignature = {
     /**
      * Optional additive grouping of the bar's main pulses, as the felt-beat
      * lengths in pulses — e.g. `[2, 2, 3]` for a 2+2+3 reading of 7/8, or
-     * `[3, 2]` for 5/8. The entries must be positive integers summing to
-     * {@link pulsesPerBar}. When present, the head pulse of each group (other
-     * than the downbeat) is treated as a secondary strong pulse by
+     * `[3, 2]` for 5/8. The entries must be positive integers summing to the
+     * numerator.
+     *
+     * A compound numerator accepts both readings. 9/8 groups its three dotted
+     * pulses as `[1, 1, 1]`, or reads additively as `[2, 2, 2, 3]` quavers; a
+     * grouping that sums to the numerator selects the additive reading, so
+     * aksak and other additive metres are expressible. {@link pulsesPerBar}
+     * and {@link isCompound} follow whichever reading the grouping selects.
+     *
+     * When present, the head pulse of each group (other than the downbeat) is
+     * treated as a secondary strong pulse by
      * {@link metricWeight}/{@link isStrongBeat}; when absent, all main pulses
      * are weighted equally as flat, evenly divided pulses.
      */
@@ -30,8 +38,13 @@ type TimeSignature = {
  * @category Rhythm & Meter
  */
 type BarPosition = {
+    /** 0-based bar index. {@link formatBarPosition} renders it 1-based. */
     bar: number;
-    /** Quarter-note offset from the start of the bar. */
+    /**
+     * Quarter-note offset from the start of the bar — not the felt beat. In 6/8
+     * the second felt beat is at `beat: 1.5`; {@link barPositionToPulse} converts
+     * to felt-beat numbering.
+     */
     beat: number;
 };
 /**
@@ -49,16 +62,34 @@ type BarPosition = {
  */
 declare function parseTimeSignature(text: string): TimeSignature;
 /**
- * Render a time signature as `"n/d"`.
+ * Render a time signature as `"n/d"`, or as `"a+b+c/d"` when it carries an
+ * additive grouping and `grouping` is requested.
+ *
+ * The plain form drops the grouping, so a round trip through it reads 7/8 as
+ * flat rather than as 2+2+3; ask for the additive form to keep it.
  *
+ * @param ts The time signature.
+ * @param opts Set `grouping: true` to render an additive grouping.
+ * @returns The formatted signature.
+ * @example
+ * ```ts
+ * import { formatTimeSignature } from '@libraz/libcantus';
+ * const aksak = { numerator: 7, denominator: 8, grouping: [2, 2, 3] };
+ * formatTimeSignature(aksak); // '7/8'
+ * formatTimeSignature(aksak, { grouping: true }); // '2+2+3/8'
+ * ```
  * @category Rhythm & Meter
  */
-declare function formatTimeSignature(ts: TimeSignature): string;
+declare function formatTimeSignature(ts: TimeSignature, opts?: {
+    grouping?: boolean;
+}): string;
 /**
  * Whether a meter is compound: its main pulses each divide into three, as in
  * 6/8, 9/8, 12/8, or 6/4. Compound meters are those whose numerator is a
  * multiple of three greater than three, independent of the denominator. Meters
- * like 3/8 and 3/4 (simple triples, numerator 3) are not compound.
+ * like 3/8 and 3/4 (simple triples, numerator 3) are not compound, and neither
+ * is a signature whose {@link TimeSignature.grouping} selects the additive
+ * reading (9/8 as 2+2+2+3).
  *
  * @param ts The time signature.
  * @returns True for compound meters.
@@ -103,6 +134,57 @@ declare function pulsesPerBar(ts: TimeSignature): number;
  * @category Rhythm & Meter
  */
 declare function beatToBarPosition(beatInQuarters: number, ts: TimeSignature): BarPosition;
+/**
+ * Length of one felt beat (main pulse) in quarter-note beats.
+ *
+ * A quarter note in simple meters, a dotted quarter in compound ones, and one
+ * denominator unit in an additive metre. Position displays, click tracks, and
+ * score export are all written against this length.
+ *
+ * @param ts The time signature.
+ * @returns The pulse length in quarter-note beats.
+ * @example
+ * ```ts
+ * import { parseTimeSignature, pulseBeats } from '@libraz/libcantus';
+ * pulseBeats(parseTimeSignature('6/8')); // 1.5
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function pulseBeats(ts: TimeSignature): number;
+/**
+ * The felt-beat number of a bar position, 1-based.
+ *
+ * {@link BarPosition.beat} is a quarter-note offset, so in 6/8 the second felt
+ * beat reads as 1.5. This is the number a musician says and a position display
+ * shows.
+ *
+ * @param pos The bar position.
+ * @param ts The time signature.
+ * @returns The 1-based felt-beat number, fractional between pulses.
+ * @example
+ * ```ts
+ * import { barPositionToPulse, parseTimeSignature } from '@libraz/libcantus';
+ * barPositionToPulse({ bar: 0, beat: 1.5 }, parseTimeSignature('6/8')); // 2
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function barPositionToPulse(pos: BarPosition, ts: TimeSignature): number;
+/**
+ * Render an absolute position as the `bar.beat` a DAW or a score shows:
+ * 1-based bar, 1-based felt beat.
+ *
+ * @param beatInQuarters Absolute position in quarter-note beats.
+ * @param ts The time signature.
+ * @param decimals Digits of the fractional beat to keep.
+ * @returns The formatted position, e.g. `'3.2'` for bar 3, felt beat 2.
+ * @example
+ * ```ts
+ * import { formatBarPosition, parseTimeSignature } from '@libraz/libcantus';
+ * formatBarPosition(7.5, parseTimeSignature('6/8')); // '3.2'
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function formatBarPosition(beatInQuarters: number, ts: TimeSignature, decimals?: number): string;
 /**
  * Convert a bar index and in-bar offset back to an absolute quarter-note
  * position.
@@ -128,8 +210,8 @@ declare function barPositionToBeat(pos: BarPosition, ts: TimeSignature): number;
  * @param beatInQuarters Absolute or in-bar quarter-note position.
  * @param ts The time signature.
  * @returns The metric weight (0–3).
- * @throws If `ts.grouping` is present but is not a positive-integer list
- *   summing to {@link pulsesPerBar}.
+ * @throws If the time signature is malformed, including a grouping that is not
+ *   a positive-integer list summing to the pulse count or the numerator.
  * @example
  * ```ts
  * import { parseTimeSignature, metricWeight } from '@libraz/libcantus';
@@ -161,4 +243,4 @@ declare function isStrongBeat(beatInQuarters: number, ts: TimeSignature): boolea
  */
 declare function tuplet(totalBeats: number, count: number): number[];
 
-export { type BarPosition as B, type TimeSignature as T, beatToBarPosition as a, barPositionToBeat as b, beatsPerBar as c, isStrongBeat as d, pulsesPerBar as e, formatTimeSignature as f, isCompound as i, metricWeight as m, parseTimeSignature as p, tuplet as t };
+export { type BarPosition as B, type TimeSignature as T, barPositionToPulse as a, barPositionToBeat as b, beatToBarPosition as c, beatsPerBar as d, formatTimeSignature as e, formatBarPosition as f, isStrongBeat as g, pulseBeats as h, isCompound as i, pulsesPerBar as j, metricWeight as m, parseTimeSignature as p, tuplet as t };

package/dist/index-alrRninU.d.cts

@@ -0,0 +1,199 @@
+import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
+import { a as ChordQuality, C as Chord } from './index-oTQbYYIs.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[];
+    /**
+     * Upper bound on the input pitches processed by this detection call.
+     *
+     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
+     */
+    budget?: 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.
+ * @param opts Budget for processing imported note events.
+ * @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[], opts?: Omit<DetectKeyOptions, 'weights'>): 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 };