@libraz/libcantus 0.9.3 → 0.9.4

package/dist/{index-Bt4tOUD9.d.ts → index-C83mZI1P.d.ts}

@@ -1,11 +1,20 @@
-import { K as KeyScale } from './types-MGP29r3t.js';
+import { K as KeyScale } from './types-BN6_Q9Kl.js';
 
 /**
  * Chord quality identifiers understood by the chord builder.
  *
  * @category Chords
  */
-type ChordQuality = 'maj' | 'min' | 'dim' | 'aug' | 'maj7' | 'min7' | 'dom7' | 'dim7' | 'm7b5' | 'minMaj7' | 'aug7' | 'augMaj7' | 'majb5' | '6' | 'min6' | '6/9' | 'sus2' | 'sus4' | 'add9' | 'add11' | 'maj9' | 'min9' | 'dom9' | '7b9' | '7#9' | '7#11' | '7b13' | '11' | '13' | '5';
+type ChordQuality = 'maj' | 'min' | 'dim' | 'aug' | 'maj7' | 'min7' | 'dom7' | 'dim7' | 'm7b5' | 'minMaj7' | 'aug7' | 'augMaj7' | 'majb5' | '6' | 'min6' | '6/9' | 'sus2' | 'sus4' | 'add9' | 'add11' | 'maj9' | 'min9' | 'dom9' | '7b9' | '7#9' | '7#11' | '7b13' | '11' | '13' | '5' | '7sus4' | '7b5' | '7alt' | '13b9' | 'maj13' | 'maj7#11' | 'min11' | 'min13' | 'minAdd9' | 'min6/9';
+/**
+ * The basic role a chord tone plays: the degrees a chord's own template names.
+ *
+ * The shared vocabulary behind {@link chordToneRole}, the harmony layer's
+ * `HarmonyRole`, and the voice analyser's labels, so the three cannot drift.
+ *
+ * @category Chords
+ */
+type ChordToneRole = 'root' | 'third' | 'fifth' | 'sixth' | 'seventh';
 /**
  * A bare spelled pitch used as an enharmonic hint: a diatonic letter
  * (0..6 = C..B) plus a chromatic alteration (-2 double-flat .. +2 double-sharp).
@@ -54,7 +63,26 @@ type ChordSpan = {
     secondaryDominant?: boolean;
 };
 /**
- * All chord qualities the builder understands, longest templates last.
+ * A chord occupying a half-open beat span `[startBeat, endBeat)`.
+ *
+ * The exchange record between anything that lays chords out in time — a
+ * timeline analysis, a bass-line plan, an accompaniment generator — so those
+ * surfaces share one definition instead of agreeing by coincidence.
+ *
+ * @category Composition
+ */
+type ChordSegment = {
+    startBeat: number;
+    endBeat: number;
+    chord: Chord;
+};
+/**
+ * All chord qualities the builder understands, in declaration order.
+ *
+ * The order is stable but carries no meaning: it is neither alphabetical nor
+ * sorted by template size. {@link detectChord} uses it as its final tie-break,
+ * so it is part of the observable behaviour and does not get reshuffled
+ * casually — but do not read it as a ranking.
  *
  * @category Chords
  */
@@ -92,21 +120,73 @@ declare function chordFromDegree(degree: number, ext: ChordQuality, key: KeyScal
  * @category Chords
  */
 declare function makeChord(rootPc: number, quality: ChordQuality, bassPc?: number): Chord;
+/**
+ * Transpose a chord by a number of semitones.
+ *
+ * The interval template is carried over untouched, so a chord whose intervals
+ * were customised keeps them, and a slash bass moves with the root. Enharmonic
+ * spelling hints are dropped rather than shifted: the letter a transposed root
+ * should take depends on the destination key, which a semitone count does not
+ * carry. Pass the result through {@link spellChord} to respell it.
+ *
+ * @param chord The chord to transpose.
+ * @param semitones The signed semitone offset.
+ * @returns The transposed chord.
+ * @throws If `semitones` is not finite.
+ *
+ * @example
+ * ```ts
+ * import { formatChordSymbol, parseChordSymbol, transposeChord } from '@libraz/libcantus';
+ * formatChordSymbol(transposeChord(parseChordSymbol('C/G'), 2)); // 'D/A'
+ * ```
+ *
+ * @category Chords
+ */
+declare function transposeChord(chord: Chord, semitones: number): Chord;
 /**
  * Get the sorted, deduplicated pitch classes of a chord.
  *
+ * A slash bass is one of them: `F/G` sounds a G, the voicers put it in the
+ * bass, and a set that omitted it would not re-detect as the chord it came
+ * from. Pass `includeBass: false` to enumerate the interval template alone.
+ *
  * @param chord The chord to enumerate.
+ * @param opts Set `includeBass: false` to omit a slash bass.
  * @returns The chord's pitch classes, sorted ascending in [0, 11].
  *
  * @example
  * ```ts
  * import { makeChord, chordPitchClasses } from '@libraz/libcantus';
  * chordPitchClasses(makeChord(0, 'maj7')); // [0, 4, 7, 11]
+ * chordPitchClasses(makeChord(5, 'maj', 7)); // [0, 5, 7, 9] — F/G, G included
  * ```
  *
  * @category Chords
  */
-declare function chordPitchClasses(chord: Chord): number[];
+declare function chordPitchClasses(chord: Chord, opts?: {
+    includeBass?: boolean;
+}): number[];
+/**
+ * A pitch's interval class above the chord root, in [0, 11].
+ *
+ * The shared reading of "where does this pitch sit in the chord", used by the
+ * safety evaluator and the voice analyser alike so they cannot disagree.
+ *
+ * @param pitch MIDI pitch or bare pitch class.
+ * @param chord The chord providing the root reference.
+ * @returns The interval class above the root.
+ * @category Chords
+ */
+declare function intervalAboveRoot(pitch: number, chord: Chord): number;
+/**
+ * Whether a pitch is one of a chord's tones, ignoring octave.
+ *
+ * @param pitch MIDI pitch or bare pitch class.
+ * @param chord The chord, or null for no sounding harmony.
+ * @returns True when the pitch class belongs to the chord.
+ * @category Chords
+ */
+declare function isChordMember(pitch: number, chord: Chord | null): boolean;
 /**
  * Determine a pitch's harmonic role within a chord.
  *
@@ -121,18 +201,21 @@ declare function chordPitchClasses(chord: Chord): number[];
  *
  * @category Chords
  */
-declare function chordToneRole(pitch: number, chord: Chord): 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' | null;
+declare function chordToneRole(pitch: number, chord: Chord): ChordToneRole | null;
 /**
  * Build the diatonic triad rooted on a scale degree by stacking scale thirds.
  *
  * Unlike {@link chordFromDegree}, the chord quality is derived from the scale
  * rather than supplied, so degrees yield their scale-correct triads (e.g. a
- * diminished triad on the leading tone of a major key). Intended for heptatonic
- * scales; other scales stack by scale step regardless.
+ * diminished triad on the leading tone of a major key).
  *
  * @param degree 0-based scale degree of the chord root.
  * @param key Key/scale context.
  * @returns The diatonic triad.
+ * @throws If the scale is not heptatonic. Stacking thirds means skipping every
+ *   other degree, which only lands on a triad when there are seven of them, so
+ *   the pentatonic, blues, whole-tone, octatonic and chromatic scales have no
+ *   diatonic triad; use {@link chordFromDegree} with an explicit quality there.
  *
  * @example
  * ```ts
@@ -149,9 +232,11 @@ declare function diatonicTriad(degree: number, key: KeyScale): Chord;
  * @param degree 0-based scale degree of the chord root.
  * @param key Key/scale context.
  * @returns The diatonic seventh chord.
+ * @throws If the scale is not heptatonic, for the reason given on
+ *   {@link diatonicTriad}.
  *
  * @category Chords
  */
 declare function diatonicSeventh(degree: number, key: KeyScale): Chord;
 
-export { type Chord as C, type PitchSpelling as P, type ChordQuality as a, type ChordSpan as b, chordFromDegree as c, chordPitchClasses as d, chordQualities as e, chordToneRole as f, diatonicSeventh as g, diatonicTriad as h, makeChord as m };
+export { type Chord as C, type PitchSpelling as P, type ChordQuality as a, type ChordSegment as b, type ChordSpan as c, type ChordToneRole as d, chordFromDegree as e, chordPitchClasses as f, chordQualities as g, chordToneRole as h, diatonicSeventh as i, diatonicTriad as j, intervalAboveRoot as k, isChordMember as l, makeChord as m, transposeChord as t };

package/dist/{index-Bg5dYMmZ.d.ts → index-D6b6na69.d.cts}

@@ -1,11 +1,11 @@
-import { C as Chord } from './index-Bt4tOUD9.js';
+import { d as ChordToneRole, C as Chord } from './index-y_ak9_Hi.cjs';
 
 /**
  * Harmonic role a pitch plays within a chord.
  *
  * @category Functional Harmony
  */
-type HarmonyRole = 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' | 'tension' | 'doubling';
+type HarmonyRole = ChordToneRole | 'tension' | 'doubling';
 /**
  * How firmly a pitch is locked to the chord's identity.
  *
@@ -29,15 +29,18 @@ type VoicedRole = {
 /**
  * Classify a pitch's harmonic role and lock level within a chord.
  *
- * The role comes from the pitch's interval class above the chord root: root (0),
- * third (3/4), fifth (6/7/8), seventh (10/11), and 9/11/13 tensions (2/5/9, and
- * the flat ninth 1). The root locks the chord identity, the third locks its
- * quality, and everything else is free voicing. In a suspended chord (a chord
- * whose intervals include a 4th (5) or 2nd (2) but no third), the suspended tone
- * takes the third's place as the quality-defining tone and is locked to
- * `quality`, since moving it changes the chord. Detecting an octave doubling
- * requires the surrounding voicing, which this single-pitch query does not carry,
- * so `doubling` is part of the type but not returned here.
+ * The role comes from the pitch's interval class above the chord root, read
+ * against the chord's own template: root (0), third (3/4), fifth (6/7/8),
+ * sixth or seventh (9/10/11). Every pitch the template does not claim is
+ * `'tension'` — including one that is simply foreign to the chord, which this
+ * single-pitch query cannot tell from a colour tone. The root locks the chord
+ * identity, the third locks its quality, and everything else is free voicing.
+ * In a suspended chord (a chord whose intervals include a 4th (5) or 2nd (2)
+ * but no third), the suspended tone takes the third's place as the
+ * quality-defining tone and is locked to `quality`, since moving it changes the
+ * chord. Detecting an octave doubling requires the surrounding voicing, which
+ * this query does not carry, so `'doubling'` is part of the type — the shared
+ * vocabulary of harmonic roles — but is never returned here.
  *
  * @param pitch MIDI pitch or bare pitch class.
  * @param chord The chord providing the root reference.

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 };