tonus 0.1.0

package/dist/engines/score/prosody.js

@@ -0,0 +1,109 @@
+export function computeProsody(phrases) {
+    let phraseCount = 0;
+    let noteCount = 0;
+    let syllableCount = 0;
+    let ictusCount = 0;
+    let minMidi = Infinity;
+    let maxMidi = -Infinity;
+    let arsicCount = 0;
+    let theticCount = 0;
+    // Group-size tracking: a new group starts at every rhythmicIndex === 1.
+    let groupSizes = [];
+    let currentGroupSize = 0;
+    let maxGroupSize = 0;
+    const cadDist = {
+        comma: 0, tick: 0, semicolon: 0, colon: 0, doubleBar: 0,
+    };
+    let cadenceWeight = 0;
+    const melismaByPhrase = [];
+    const closeGroup = () => {
+        if (currentGroupSize > 0) {
+            groupSizes.push(currentGroupSize);
+            if (currentGroupSize > maxGroupSize)
+                maxGroupSize = currentGroupSize;
+        }
+    };
+    for (const phrase of phrases) {
+        phraseCount++;
+        let phraseNotes = 0;
+        let phraseSyllables = 0;
+        for (const syl of phrase.syllables) {
+            if (syl.notes.length === 0)
+                continue;
+            phraseSyllables++;
+            syllableCount++;
+            for (const note of syl.notes) {
+                noteCount++;
+                phraseNotes++;
+                if (note.pitch.midi < minMidi)
+                    minMidi = note.pitch.midi;
+                if (note.pitch.midi > maxMidi)
+                    maxMidi = note.pitch.midi;
+                if (note.context.ictus)
+                    ictusCount++;
+                if (note.performance.rhythmicShape === "arsic")
+                    arsicCount++;
+                else
+                    theticCount++;
+                if (note.performance.rhythmicIndex === 1) {
+                    closeGroup();
+                    currentGroupSize = 1;
+                }
+                else {
+                    currentGroupSize++;
+                }
+            }
+        }
+        if (phrase.divisio) {
+            const d = phrase.divisio.divisio;
+            if (d === "::") {
+                cadDist.doubleBar++;
+                cadenceWeight += 1.5;
+            }
+            else if (d === ":") {
+                cadDist.colon++;
+                cadenceWeight += 1.0;
+            }
+            else if (d === ";") {
+                cadDist.semicolon++;
+                cadenceWeight += 0.75;
+            }
+            else if (d === ",") {
+                cadDist.comma++;
+                cadenceWeight += 0.5;
+            }
+            else if (d === "`") {
+                cadDist.tick++;
+                cadenceWeight += 0.25;
+            }
+        }
+        if (phraseSyllables > 0)
+            melismaByPhrase.push(phraseNotes / phraseSyllables);
+    }
+    closeGroup();
+    const noteRange = noteCount > 0
+        ? { min: minMidi, max: maxMidi, span: maxMidi - minMidi }
+        : null;
+    const avgGroupSize = groupSizes.length > 0
+        ? groupSizes.reduce((s, n) => s + n, 0) / groupSizes.length
+        : 0;
+    return {
+        phraseCount,
+        noteCount,
+        syllableCount,
+        noteRange,
+        ambitus: noteRange?.span ?? null,
+        melismaRatio: syllableCount > 0 ? noteCount / syllableCount : 0,
+        melismaByPhrase,
+        ictusRate: noteCount > 0 ? ictusCount / noteCount : 0,
+        rhythmicProfile: {
+            arsic: arsicCount,
+            thetic: theticCount,
+            avgGroupSize,
+            maxGroupSize,
+        },
+        cadenceWeight,
+        cadenceDistribution: cadDist,
+    };
+}
+//# sourceMappingURL=prosody.js.map

package/dist/engines/score/tabula.d.ts

@@ -0,0 +1,70 @@
+import type { Score, Neume } from "./types.js";
+import type { ChantType, InterpretationOptions } from "./types.js";
+export type NoteRole = "finalis" | "tenor" | "other" | null;
+export interface ChantTabulaRow {
+    phraseIndex: number;
+    syllableIndex: number;
+    noteIndex: number;
+    /** 0-based index of the neume figure within the syllable (GABC break markers). */
+    neumeGroup: number;
+    /** 0-based position of this note within its neume figure. */
+    neumeIndex: number;
+    lyric: string;
+    vowel: string;
+    /** MIDI pitch number (after transpose, clamped 0–127) */
+    midi: number;
+    /** Pitch class 0–11 (C=0) */
+    pc: number;
+    /** Octave (MIDI convention: C4 = octave 4) */
+    octave: number;
+    /** Diatonic scale degree 1–7 relative to mode finalis; null for non-diatonic pitches or no mode */
+    degree: number | null;
+    hz: number;
+    offset: number;
+    /** Scientific pitch name, e.g. "D4", "Bb3" — the MusicXML step + octave. */
+    spn: string;
+    /** 14-bit MIDI pitch bend for this note's microtuning (8192 = center). */
+    bend: number;
+    /** Solesmes quality of this note's compound beat (shared across group). */
+    rhythmicShape: "arsic" | "thetic";
+    /** 1-based position within the compound beat. */
+    rhythmicIndex: number;
+    duration: number;
+    /** 0–1 from phrasing; null if phrasing inactive */
+    velocity: number | null;
+    shapedDuration: number;
+    ictus: boolean;
+    accidental: -1 | 0 | 1;
+    /** How this note's accidental arose — only "explicit" prints a glyph. */
+    accidentalSource: "none" | "state" | "explicit";
+    quilisma: boolean;
+    liquescent: boolean;
+    strophicus: boolean;
+    divisio: string | null;
+    /** Modal role: "final" | "tenor" | "mod" (modulation) | null if no mode or no match */
+    role: NoteRole;
+    /** Guidonian short name (e.g. "g", "aa") — null for chromatic pitches with no gamut entry */
+    name: string | null;
+    /** Guidonian full compound name (e.g. "Gesolreut") — null for chromatic pitches */
+    nomen: string | null;
+    /** Guidonian hand position */
+    hand: {
+        finger: string;
+        region: string;
+    } | null;
+    /** Hexachord context for this pitch */
+    hexachord: "durum" | "naturale" | "molle" | null;
+    /** Solfege syllable — Guidonian variant when in gamut, chromatic fallback otherwise */
+    solfege: string | null;
+    /** Neume classification for the syllable this note belongs to */
+    neume: Neume;
+}
+export interface TabulaOptions {
+    mode?: number;
+    office?: ChantType;
+    interpretation?: InterpretationOptions;
+    a4Hz?: number;
+    transpose?: number;
+}
+export declare function computeTabula(ir: Score, options?: TabulaOptions): ChantTabulaRow[];
+//# sourceMappingURL=tabula.d.ts.map

package/dist/engines/score/tabula.js

@@ -0,0 +1,109 @@
+import { MODES } from "../temper/modes.js";
+import { buildPhrasing, shapePhrasingForMode, applyPhrasing, } from "./phrasing.js";
+import { inferMode } from "./infer.js";
+import { CHROMA_TO_SOLFEGE as SOLFEGE_BY_PC } from "../temper/data/constants.js";
+export function computeTabula(ir, options = {}) {
+    const modeNum = options.mode ?? inferMode(ir);
+    const modeData = modeNum !== undefined ? MODES.get(modeNum) : undefined;
+    const interpretation = options.interpretation ?? {};
+    const usePhrasing = options.mode !== undefined ||
+        interpretation.phrasing !== undefined ||
+        options.office !== undefined;
+    const annotated = [];
+    const flatForPhrasing = [];
+    for (let pi = 0; pi < ir.phrases.length; pi++) {
+        const phrase = ir.phrases[pi];
+        const divStr = phrase.divisio?.divisio ?? null;
+        let si = 0;
+        for (const syl of phrase.syllables) {
+            for (let ni = 0; ni < syl.notes.length; ni++) {
+                const note = syl.notes[ni];
+                annotated.push({
+                    note,
+                    phraseIndex: pi,
+                    syllableIndex: si,
+                    noteIndex: ni,
+                    divisio: divStr,
+                    neume: syl.neume,
+                });
+                flatForPhrasing.push(note);
+            }
+            si++;
+        }
+        if (phrase.divisio) {
+            flatForPhrasing.push({
+                type: "rest",
+                divisio: phrase.divisio.divisio,
+                duration: phrase.divisio.duration,
+            });
+        }
+    }
+    let velocities = annotated.map(() => null);
+    let shapedDurations = annotated.map((a) => a.note.performance.duration);
+    if (usePhrasing && annotated.length > 0) {
+        const profile = buildPhrasing(interpretation.phrasing ?? "lyrical", {
+            overrides: interpretation.phrasingOverrides,
+        });
+        const modeProfile = shapePhrasingForMode(profile, modeData, {
+            strength: interpretation.modalInfluence,
+        });
+        const tenorPc = modeData?.tenor;
+        const shaped = applyPhrasing(flatForPhrasing, modeProfile, tenorPc);
+        for (let i = 0; i < shaped.length && i < annotated.length; i++) {
+            velocities[i] = shaped[i].performance.velocity;
+            shapedDurations[i] = shaped[i].shapedDuration;
+        }
+    }
+    // Position of each note within its neume figure — resets when the
+    // (syllableIndex, neumeGroup) pair changes.
+    const neumeIndices = [];
+    let prevKey = null;
+    let withinGroup = 0;
+    for (const a of annotated) {
+        const key = `${a.phraseIndex}:${a.syllableIndex}:${a.note.context.neumeGroup}`;
+        withinGroup = key === prevKey ? withinGroup + 1 : 0;
+        neumeIndices.push(withinGroup);
+        prevKey = key;
+    }
+    const rows = annotated.map((a, i) => {
+        const n = a.note;
+        return {
+            phraseIndex: a.phraseIndex,
+            syllableIndex: a.syllableIndex,
+            noteIndex: a.noteIndex,
+            neumeGroup: n.context.neumeGroup,
+            neumeIndex: neumeIndices[i],
+            lyric: n.context.lyric,
+            vowel: n.context.vowel,
+            midi: n.pitch.midi,
+            pc: n.pitch.pc,
+            octave: n.pitch.oct,
+            degree: n.step.degree,
+            hz: n.pitch.hz,
+            offset: n.pitch.offset,
+            spn: n.pitch.spn,
+            bend: n.pitch.bend,
+            rhythmicShape: n.performance.rhythmicShape,
+            rhythmicIndex: n.performance.rhythmicIndex,
+            duration: n.performance.duration,
+            velocity: velocities[i],
+            shapedDuration: shapedDurations[i],
+            ictus: n.context.ictus,
+            accidental: n.pitch.acc,
+            accidentalSource: n.context.accidentalSource,
+            quilisma: n.context.quilisma,
+            liquescent: n.context.liquescent,
+            strophicus: n.context.strophicus,
+            divisio: a.divisio,
+            role: n.step.role,
+            name: n.step.name,
+            nomen: n.step.nomen,
+            hand: n.step.hand,
+            hexachord: n.step.hexachord,
+            solfege: n.step.solmization ?? SOLFEGE_BY_PC.get(n.pitch.pc) ?? null,
+            neume: a.neume,
+        };
+    });
+    return rows;
+}
+//# sourceMappingURL=tabula.js.map

package/dist/engines/score/types.d.ts

@@ -0,0 +1,159 @@
+import type { Pitch } from "../temper/pitch.js";
+import type { Step } from "../temper/step.js";
+import type { NeumeShape } from "../temper/neume.js";
+import type { OfficeCode, OrdinaryCode } from "../chant/types.js";
+export type ArsisThesis = "arsic" | "thetic";
+export interface Performance {
+    velocity: number;
+    duration: number;
+    rhythmicShape: ArsisThesis;
+    rhythmicIndex: number;
+}
+export interface Context {
+    lyric: string;
+    vowel: string;
+    syllableIndex: number;
+    /** 0-based index of the neume figure within the syllable (GABC break markers). */
+    neumeGroup: number;
+    ictus: boolean;
+    accidentalSource: "none" | "state" | "explicit";
+    quilisma: boolean;
+    liquescent: boolean;
+    strophicus: boolean;
+    doubleEpisema: boolean;
+    weight: number;
+}
+export interface Note {
+    pitch: Pitch;
+    step: Step;
+    performance: Performance;
+    context: Context;
+}
+export type { Pitch, Step, NeumeShape, OfficeCode, OrdinaryCode };
+export type Clef = "c1" | "c2" | "c3" | "c4" | "f1" | "f2" | "f3" | "f4" | `cb${1 | 2 | 3 | 4}` | `fb${1 | 2 | 3 | 4}`;
+export type PhrasingType = "recitative" | "lyrical" | "hymnic" | "solemn";
+export type ArticulationType = "restrained" | "balanced" | "expressive" | "strict";
+export interface ArticulationWeights {
+    ictusWeight: number;
+    ictusDuration: number;
+    episemaWeight: number;
+    episemaDuration: number;
+    episemaDoubleDuration: number;
+    strophicusWeight: number;
+    strophicusDuration: number;
+    strophicusTripleDuration: number;
+    quilismaPrevWeight: number;
+    quilismaWeight: number;
+    liquescentWeight: number;
+    liquescentDuration: number;
+    initioWeight: number;
+    initioMelismaWeight: number;
+    initioMelismaDuration: number;
+    accentWeight: number;
+    uppercaseWeight: number;
+    uppercaseDuration: number;
+    repercussionPrevWeight: number;
+    repercussionPrevDuration: number;
+    repercussionOriscusWeight: number;
+    breakWeight: number;
+    dashWeight: number;
+    dashDuration: number;
+}
+export interface ArticulationProfile {
+    weights: ArticulationWeights;
+    weightBase: number;
+    weightGain: number;
+    weightSaturation: number;
+    durationBase: number;
+    durationGain: number;
+    durationMin: number;
+    durationMax: number;
+    neumeArch?: number;
+    durArch?: number;
+    ictusBoost?: number;
+    ruleGain?: number;
+    contourScale?: number;
+}
+export interface PhrasingProfile {
+    curve: number;
+    accent: number;
+    cadence: number;
+    tenor: number;
+    baseVelocity: number;
+    contourVel: number;
+    contourDur: number;
+    velSpread: number;
+    ictusBoost: number;
+    neumeArch: number;
+    durArch: number;
+}
+export interface InterpretationOptions {
+    articulation?: ArticulationType;
+    articulationOverrides?: Partial<ArticulationProfile>;
+    phrasing?: PhrasingType;
+    phrasingOverrides?: Partial<PhrasingProfile>;
+    modalInfluence?: number;
+}
+export interface ParseOptions {
+    oct?: number;
+    useVowelAccent?: boolean;
+    interpretation?: InterpretationOptions;
+}
+export interface ParseError {
+    message: string;
+    index?: number;
+}
+export interface ParsedNote {
+    type: "note";
+    step: number;
+    lyric: string;
+    syllableIndex: number;
+    /** 0-based index of the neume figure within the syllable (GABC break markers). */
+    neumeGroup: number;
+    ictus: boolean;
+    weight: number;
+    duration: number;
+    accidental: -1 | 0 | 1;
+    accidentalSource: "none" | "state" | "explicit";
+    quilisma: boolean;
+    liquescent: boolean;
+    strophicus: boolean;
+    doubleEpisema: boolean;
+}
+export interface RestEvent {
+    type: "rest";
+    divisio: "," | "`" | ";" | ":" | "::";
+    duration: number;
+}
+export type ChantEvent = ParsedNote | RestEvent;
+export interface ParseResult {
+    events: ChantEvent[];
+    errors: ParseError[];
+}
+export type ChantType = OrdinaryCode | OfficeCode;
+export interface Neume {
+    type: NeumeShape;
+    intervals: number[];
+    hasQuilisma: boolean;
+    hasLiquescent: boolean;
+    hasStrophicus: boolean;
+}
+export interface Syllable {
+    lyric: string;
+    notes: Note[];
+    neume: Neume;
+}
+export interface Phrase {
+    syllables: Syllable[];
+    divisio?: RestEvent;
+}
+export interface Score {
+    chant: {
+        incipit: string;
+        mode: string | null;
+        office: string;
+    };
+    phrases: Phrase[];
+    errors: ParseError[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/score/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engines/temper/api.d.ts

@@ -0,0 +1,60 @@
+import type { Scale, ScaleOpts, ScalaFile, RatioResult } from "./scale.js";
+import type { Pitch, PitchInput } from "./pitch.js";
+import type { Step, StepVariant, Finger, Region } from "./step.js";
+import type { Interval, IntervalDirection, IntervalQuality } from "./interval.js";
+import type { Neume, NeumeShape } from "./neume.js";
+import type { GamutOptions } from "./gamut.js";
+import type { ModeData, ModeProfile } from "./modes.js";
+import type { GuidonianEntry, GuidonianVariant } from "./guido.js";
+export type BuiltinTuning = "pythagorean" | "meantone" | "equal" | "ptolemy-intense" | "ptolemy-soft" | "ptolemy-equable";
+export type Tuning = BuiltinTuning | string;
+export interface TemperamentumOpts {
+    tuning?: Tuning;
+    mode?: number | "auto";
+    a4?: number;
+    root?: number;
+    transpose?: number;
+    comma?: number | string;
+    scale?: string | string[];
+}
+export type TemperamentumInput = BuiltinTuning | TemperamentumOpts;
+export interface TonusOpts {
+    differentia?: string;
+}
+export interface Tonus {
+    mode: number;
+    differentia: string;
+    intonatio: Pitch[];
+    mediatio: Pitch[];
+    terminatio: Pitch[];
+}
+export interface Temperamentum {
+    tuning: Tuning;
+    mode: number | "auto";
+    a4: number;
+    root: number;
+    transpose: number;
+    comma: number;
+    ratios: number[];
+    cents: number[];
+    nota(input: PitchInput): Pitch;
+    gradus(input: PitchInput): Step;
+    intervallum(a: PitchInput, b: PitchInput): Interval;
+    neuma(inputs: PitchInput[]): Neume;
+    ratio(input: string): RatioResult & {
+        step: Step | null;
+    };
+    gamut(opts?: GamutOptions): Pitch[];
+    modus(mode: number): ModeData;
+    tonus(opts?: TonusOpts): Tonus;
+}
+/**
+ * Tuning context builder (`tonus.temperamentum`). Accepts a built-in
+ * tuning name, options, a custom scale array, or a Scala file, and
+ * returns a Temperamentum whose methods resolve pitches, intervals,
+ * neumes, the Guidonian gamut, and psalm tones under that tuning.
+ * @throws Error on invalid tuning, scale, or mode input.
+ */
+export declare function buildTemper(input?: TemperamentumInput): Temperamentum;
+export type { Scale, ScaleOpts, ScalaFile, RatioResult, Pitch, PitchInput, Step, StepVariant, Finger, Region, Neume, NeumeShape, Interval, IntervalDirection, IntervalQuality, ModeData, ModeProfile, GamutOptions, GuidonianEntry, GuidonianVariant, };
+//# sourceMappingURL=api.d.ts.map

package/dist/engines/temper/api.js

@@ -0,0 +1,130 @@
+// ---------------------------------------------------------------------------
+// engines/temper/api — Temperamentum context builder
+// ---------------------------------------------------------------------------
+import { buildRatios, parseScala, getPtolemaicRatios, toRatio } from "./scale.js";
+import { parsePitch, toPitch } from "./pitch.js";
+import { toStep } from "./step.js";
+import { classifyInterval } from "./interval.js";
+import { buildNeume } from "./neume.js";
+import { buildGamut } from "./gamut.js";
+import { getMode } from "./modes.js";
+import { getTone, getDifferentia } from "../../data/tones.js";
+function resolveOpts(input) {
+    if (!input)
+        return {};
+    if (typeof input === "string")
+        return { tuning: input };
+    return input;
+}
+function resolveScale(opts) {
+    if (!opts.scale)
+        return { tuning: opts.tuning ?? "pythagorean" };
+    if (Array.isArray(opts.scale)) {
+        return { tuning: opts.tuning ?? "custom", scaleSteps: opts.scale };
+    }
+    const parsed = parseScala(opts.scale);
+    return { tuning: opts.tuning ?? (parsed.name || "custom"), scaleSteps: parsed.steps };
+}
+function tuningToScaleOpts(opts) {
+    const { tuning, scaleSteps } = resolveScale(opts);
+    const scalaOpts = {
+        mode: opts.mode === "auto" ? 1 : (opts.mode ?? 1),
+        a4: opts.a4 ?? 440,
+        root: opts.root,
+        transpose: opts.transpose ?? 0,
+    };
+    if (scaleSteps) {
+        scalaOpts.steps = scaleSteps;
+    }
+    else {
+        switch (tuning) {
+            case "pythagorean":
+                scalaOpts.comma = 0;
+                break;
+            case "meantone":
+                scalaOpts.comma = opts.comma ?? "1/4";
+                break;
+            case "equal":
+                scalaOpts.steps = Array.from({ length: 12 }, (_, i) => i * 100);
+                break;
+            default: {
+                const ptolemaic = getPtolemaicRatios(tuning);
+                if (ptolemaic)
+                    scalaOpts.steps = ptolemaic;
+                break;
+            }
+        }
+    }
+    return { scalaOpts, tuning };
+}
+/**
+ * Tuning context builder (`tonus.temperamentum`). Accepts a built-in
+ * tuning name, options, a custom scale array, or a Scala file, and
+ * returns a Temperamentum whose methods resolve pitches, intervals,
+ * neumes, the Guidonian gamut, and psalm tones under that tuning.
+ * @throws Error on invalid tuning, scale, or mode input.
+ */
+export function buildTemper(input) {
+    const opts = resolveOpts(input);
+    const modeVal = opts.mode ?? "auto";
+    const { scalaOpts, tuning } = tuningToScaleOpts(opts);
+    const scala = buildRatios(scalaOpts);
+    return {
+        tuning,
+        mode: modeVal,
+        a4: scala.a4,
+        root: scala.root,
+        transpose: scala.transpose,
+        comma: scala.comma,
+        ratios: scala.ratios,
+        cents: scala.cents,
+        nota(pitchInput) {
+            return toPitch(pitchInput, scala);
+        },
+        gradus(pitchInput) {
+            const midi = parsePitch(pitchInput, { mode: scala.mode, a4: scala.a4 });
+            return toStep(midi, scala);
+        },
+        intervallum(a, b) {
+            const midiA = parsePitch(a, { mode: scala.mode, a4: scala.a4 });
+            const midiB = parsePitch(b, { mode: scala.mode, a4: scala.a4 });
+            return classifyInterval(midiA, midiB);
+        },
+        neuma(inputs) {
+            return buildNeume(inputs, scala);
+        },
+        ratio(input) {
+            const result = toRatio(input);
+            const folded = result.ratio >= 2 ? result.ratio / Math.pow(2, Math.floor(Math.log2(result.ratio))) : result.ratio;
+            let step = null;
+            for (let pc = 0; pc < 12; pc++) {
+                if (Math.abs((scala.ratios[pc] ?? 0) - folded) < 1e-6) {
+                    const baseMidi = 60 + pc;
+                    step = toStep(baseMidi, scala);
+                    break;
+                }
+            }
+            return { ...result, step };
+        },
+        gamut(gamutOpts) {
+            return buildGamut(scala, gamutOpts);
+        },
+        modus(mode) {
+            return getMode(mode);
+        },
+        tonus(tonusOpts) {
+            if (modeVal === "auto")
+                throw new Error("tonus() requires an explicit mode — set mode in temperamentum()");
+            const tone = getTone(modeVal);
+            const diff = getDifferentia(tone, tonusOpts?.differentia);
+            return {
+                mode: modeVal,
+                differentia: diff.code,
+                intonatio: tone.intonation.map((m) => toPitch(m, scala)),
+                mediatio: tone.mediant.map((m) => toPitch(m, scala)),
+                terminatio: diff.termination.map((m) => toPitch(m, scala)),
+            };
+        },
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/engines/temper/data/constants.d.ts

@@ -0,0 +1,27 @@
+/** 12 pitch-class names, index = pitch class 0–11. Sharp-biased except Eb/Ab/Bb. */
+export declare const PITCH_CLASS: readonly ["C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B"];
+/** Diatonic step letters in ascending order. */
+export declare const DIATONIC_STEPS: readonly ["C", "D", "E", "F", "G", "A", "B"];
+export type DiatonicStep = (typeof DIATONIC_STEPS)[number];
+/** Map any note name (including enharmonics) to its pitch class 0–11. */
+export declare const NAME_TO_CHROMA: Map<string, number>;
+export declare const SOLFEGE_TO_CHROMA: Map<string, number>;
+export declare const CHROMA_TO_SOLFEGE: Map<number, string>;
+export interface IntervalEntry {
+    latin: string;
+    alias?: string;
+    degree: number;
+    quality: "perfect" | "major" | "minor" | "augmented" | "diminished";
+    class: string;
+}
+export declare const INTERVAL: IntervalEntry[];
+export declare const UNISONUS: IntervalEntry;
+export interface StepAlter {
+    step: DiatonicStep;
+    acc: -1 | 0 | 1;
+}
+export declare const SHARP_SPELLING: StepAlter[];
+export declare const FLAT_SPELLING: StepAlter[];
+export declare const PREFER_FLAT_PCS: Set<number>;
+export declare const GUIDO_TO_PC: Record<string, Record<string, number>>;
+//# sourceMappingURL=constants.d.ts.map