tonus 0.1.0

package/dist/engines/temper/neume.js

@@ -0,0 +1,59 @@
+// ---------------------------------------------------------------------------
+// engines/temper/neume — neume shape classification
+// ---------------------------------------------------------------------------
+import { classifyInterval } from "./interval.js";
+import { toPitch } from "./pitch.js";
+export function classifyShape(dirs) {
+    const n = dirs.length;
+    if (n === 0)
+        return "punctum";
+    const up = (d) => d === "up";
+    const dn = (d) => d === "down";
+    switch (n) {
+        case 1:
+            return up(dirs[0]) ? "pes" : dn(dirs[0]) ? "clivis" : "punctum";
+        case 2: {
+            const [d0, d1] = dirs;
+            if (up(d0) && dn(d1))
+                return "torculus";
+            if (dn(d0) && up(d1))
+                return "porrectus";
+            if (up(d0) && up(d1))
+                return "scandicus";
+            if (dn(d0) && dn(d1))
+                return "climacus";
+            return "compound";
+        }
+        case 3: {
+            const [d0, d1, d2] = dirs;
+            if (up(d0) && dn(d1) && up(d2))
+                return "torculus resupinus";
+            if (dn(d0) && up(d1) && dn(d2))
+                return "porrectus flexus";
+            if (up(d0) && up(d1) && dn(d2))
+                return "scandicus flexus";
+            if (dn(d0) && dn(d1) && up(d2))
+                return "climacus resupinus";
+            if (up(d0) && dn(d1) && dn(d2))
+                return "pes subpunctis";
+            return "compound";
+        }
+        default:
+            if (up(dirs[0]) && dirs.slice(1).every((d) => dn(d)))
+                return "pes subpunctis";
+            return "compound";
+    }
+}
+export function buildNeume(inputs, scala) {
+    const pitches = inputs.map((n) => toPitch(n, scala));
+    const intervals = [];
+    for (let i = 0; i < pitches.length - 1; i++) {
+        intervals.push(classifyInterval(pitches[i].midi, pitches[i + 1].midi));
+    }
+    return {
+        pitches,
+        intervals,
+        shape: classifyShape(intervals.map((iv) => iv.direction)),
+    };
+}
+//# sourceMappingURL=neume.js.map

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

@@ -0,0 +1,40 @@
+import type { Scale } from "./scale.js";
+export interface Pitch {
+    midi: number;
+    pc: number;
+    oct: number;
+    acc: -1 | 0 | 1;
+    spn: string;
+    hz: number;
+    offset: number;
+    bend: number;
+    ratio: number;
+}
+export type PitchInput = number | string | {
+    midi: number;
+} | {
+    hz: number;
+} | {
+    spn: string;
+} | {
+    solfege: string;
+    oct?: number;
+} | {
+    solmization: string;
+    hexachord?: "durum" | "naturale" | "molle";
+    oct?: number;
+} | {
+    gabc: string;
+    clef?: string;
+    oct?: number;
+};
+export interface PitchContext {
+    clef?: string;
+    mode?: number;
+    hexachord?: "durum" | "naturale" | "molle";
+    a4?: number;
+}
+export declare function parsePitch(input: PitchInput, ctx?: PitchContext): number;
+export declare function toPitch(input: PitchInput, scale: Scale): Pitch;
+export declare function scaleDegreeInMode(midi: number, mode: number): number | null;
+//# sourceMappingURL=pitch.d.ts.map

package/dist/engines/temper/pitch.js

@@ -0,0 +1,129 @@
+// ---------------------------------------------------------------------------
+// engines/temper/pitch — Pitch type, input parsing, and scale binding
+// ---------------------------------------------------------------------------
+import { NAME_TO_CHROMA, SOLFEGE_TO_CHROMA, SHARP_SPELLING, FLAT_SPELLING, PREFER_FLAT_PCS, GUIDO_TO_PC } from "./data/constants.js";
+import { gabcToMidi } from "./gabc.js";
+import { MODES } from "./modes.js";
+import { midiToHz } from "./scale.js";
+// ── parsePitch ──
+// Resolves any input form to a raw MIDI number.
+// ctx provides fallback mode/clef/hexachord for ambiguous inputs.
+export function parsePitch(input, ctx = {}) {
+    // Tagged object forms
+    if (typeof input === "object" && input !== null) {
+        if ("midi" in input) {
+            return clamp(input.midi);
+        }
+        if ("hz" in input) {
+            return hzToMidi(input.hz, ctx.a4 ?? 440);
+        }
+        if ("spn" in input) {
+            return parseSpn(input.spn);
+        }
+        if ("solfege" in input) {
+            return parseModernSolfege(input.solfege, input.oct ?? 4);
+        }
+        if ("solmization" in input) {
+            const hex = input.hexachord ?? inferHexachord(ctx.mode);
+            return parseMedievalSolmization(input.solmization, hex, input.oct ?? 4);
+        }
+        if ("gabc" in input) {
+            return parseGabc(input.gabc, input.clef ?? ctx.clef ?? "c4");
+        }
+    }
+    // Bare number
+    if (typeof input === "number") {
+        if (Number.isInteger(input) && input >= 0 && input <= 127)
+            return input;
+        return hzToMidi(input, ctx.a4 ?? 440);
+    }
+    // Bare string — detect form
+    if (typeof input === "string") {
+        const s = input.trim();
+        // Scientific name: starts with A–G, optional #/b, then digits
+        if (/^[A-Ga-g][#b]?-?\d+$/.test(s)) {
+            return parseSpn(s);
+        }
+        // Modern solfège: uppercase syllable, no digits
+        if (/^[A-Z]+$/.test(s) && SOLFEGE_TO_CHROMA.has(s)) {
+            return parseModernSolfege(s, 4);
+        }
+        // GABC letter: single lowercase a–m
+        if (/^[a-m]$/.test(s)) {
+            if (!ctx.clef && !ctx.mode) {
+                throw new Error(`GABC input "${s}" requires clef context. Pass { gabc: "${s}", clef: "c4" } or provide ctx.clef.`);
+            }
+            return parseGabc(s, ctx.clef ?? "c4");
+        }
+    }
+    throw new Error(`Cannot parse pitch input: ${JSON.stringify(input)}`);
+}
+// ── toPitch ──
+// Resolves a PitchInput through a Scale into a tuned Pitch.
+// Applies the Scale's transpose and returns a Pitch with midi/pc/oct/spn
+// from the transposed MIDI plus tuning-derived hz/offset/bend/ratio.
+export function toPitch(input, scale) {
+    const rawMidi = parsePitch(input, { mode: scale.mode, a4: scale.a4 });
+    const { hz, offset, bend } = midiToHz(rawMidi, scale);
+    const midi = clamp(rawMidi + scale.transpose);
+    const pc = midi % 12;
+    const oct = Math.floor(midi / 12) - 1;
+    const useFlat = PREFER_FLAT_PCS.has(pc);
+    const sp = useFlat ? FLAT_SPELLING[pc] : SHARP_SPELLING[pc];
+    const accStr = sp.acc === -1 ? "b" : sp.acc === 1 ? "#" : "";
+    const spn = `${sp.step}${accStr}${oct}`;
+    const ratio = scale.ratios[pc] ?? 1;
+    return { midi, pc, oct, acc: sp.acc, spn, hz, offset, bend, ratio };
+}
+// ── scaleDegreeInMode ──
+export function scaleDegreeInMode(midi, mode) {
+    const modeData = MODES.get(mode);
+    if (!modeData)
+        return null;
+    const pc = ((midi % 12) + 12) % 12;
+    const idx = modeData.scalePcs.indexOf(pc);
+    return idx === -1 ? null : idx + 1;
+}
+// ── Internal helpers ──
+function clamp(n) {
+    return Math.min(127, Math.max(0, Math.round(n)));
+}
+function hzToMidi(hz, a4 = 440) {
+    return clamp(69 + 12 * Math.log2(hz / a4));
+}
+function parseSpn(s) {
+    const m = s.trim().match(/^([A-Ga-g])([#b]?)(-?\d+)$/);
+    if (!m)
+        throw new Error(`Invalid scientific pitch name: "${s}"`);
+    const [, letter, acc, octStr] = m;
+    const normalized = letter.toUpperCase() + (acc === "b" ? "b" : acc === "#" ? "#" : "");
+    const pc = NAME_TO_CHROMA.get(normalized);
+    if (pc === undefined)
+        throw new Error(`Unknown note name: "${normalized}"`);
+    return (parseInt(octStr, 10) + 1) * 12 + pc;
+}
+function parseModernSolfege(s, oct) {
+    const pc = SOLFEGE_TO_CHROMA.get(s.trim().toUpperCase());
+    if (pc === undefined)
+        throw new Error(`Unknown solfège syllable: "${s}"`);
+    return (oct + 1) * 12 + pc;
+}
+function parseMedievalSolmization(s, hexachord, oct) {
+    const map = GUIDO_TO_PC[hexachord];
+    if (!map)
+        throw new Error(`Unknown hexachord: "${hexachord}"`);
+    const pc = map[s.trim().toUpperCase()];
+    if (pc === undefined)
+        throw new Error(`Unknown solmization "${s}" in hexachord "${hexachord}"`);
+    return (oct + 1) * 12 + pc;
+}
+function parseGabc(letter, clef) {
+    return gabcToMidi(letter.toLowerCase(), clef);
+}
+function inferHexachord(mode) {
+    if (!mode)
+        return "naturale";
+    const modeData = MODES.get(mode);
+    return modeData?.hexachords[0] ?? "naturale";
+}
+//# sourceMappingURL=pitch.js.map

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

@@ -0,0 +1,37 @@
+export interface Scale {
+    ratios: number[];
+    cents: number[];
+    mode: number;
+    a4: number;
+    comma: number;
+    root: number;
+    transpose: number;
+}
+export interface ScaleOpts {
+    mode?: number;
+    a4?: number;
+    comma?: number | string;
+    steps?: (number | string)[];
+    root?: number;
+    transpose?: number;
+}
+export interface RatioResult {
+    ratio: number;
+    cents: number;
+    display: string;
+}
+export declare function toRatio(input: string): RatioResult;
+export declare function parseStep(v: number | string): number;
+export interface ScalaFile {
+    name: string;
+    steps: string[];
+}
+export declare function parseScala(input: string): ScalaFile;
+export declare function getPtolemaicRatios(tuning: string): string[] | undefined;
+export declare function buildRatios(opts?: ScaleOpts): Scale;
+export declare function midiToHz(midi: number, scala: Scale): {
+    hz: number;
+    offset: number;
+    bend: number;
+};
+//# sourceMappingURL=scale.d.ts.map

package/dist/engines/temper/scale.js

@@ -0,0 +1,217 @@
+// ---------------------------------------------------------------------------
+// engines/temper/scale — tuning ratio builder
+// ---------------------------------------------------------------------------
+import { MODES } from "./modes.js";
+// Stern-Brocot rational approximation — finds nearest simple fraction
+function approximate(value, maxDen = 1000) {
+    if (value === Math.round(value))
+        return [Math.round(value), 1];
+    let [a, b, c, d] = [0, 1, 1, 0];
+    let bestNum = 1, bestDen = 1, bestErr = Infinity;
+    for (let i = 0; i < 100; i++) {
+        const medNum = a + c;
+        const medDen = b + d;
+        if (medDen > maxDen)
+            break;
+        const med = medNum / medDen;
+        const err = Math.abs(value - med);
+        if (err < bestErr) {
+            bestErr = err;
+            bestNum = medNum;
+            bestDen = medDen;
+        }
+        if (err < 1e-9)
+            break;
+        if (value > med) {
+            a = medNum;
+            b = medDen;
+        }
+        else {
+            c = medNum;
+            d = medDen;
+        }
+    }
+    return [bestNum, bestDen];
+}
+export function toRatio(input) {
+    const r = parseStep(input);
+    const cents = 1200 * Math.log2(r);
+    const [num, den] = approximate(r);
+    const display = den === 1 ? `${num}:1` : `${num}:${den}`;
+    return { ratio: r, cents, display };
+}
+function foldOct(r) {
+    let x = r;
+    while (x >= 2)
+        x *= 0.5;
+    while (x < 1)
+        x *= 2;
+    return x;
+}
+function parseComma(comma) {
+    if (typeof comma === "number")
+        return comma;
+    const s = comma.trim();
+    const slash = s.indexOf("/");
+    if (slash !== -1) {
+        const num = parseFloat(s.slice(0, slash));
+        const den = parseFloat(s.slice(slash + 1));
+        if (!Number.isFinite(num) || !Number.isFinite(den) || den === 0)
+            throw new RangeError(`Invalid comma fraction: "${s}"`);
+        return num / den;
+    }
+    const n = parseFloat(s);
+    if (!Number.isFinite(n))
+        throw new RangeError(`Invalid comma value: "${s}"`);
+    return n;
+}
+// Parse a single pitch value using Scala convention:
+// period present → cents, slash or colon → ratio, bare integer → ratio over 1
+export function parseStep(v) {
+    if (typeof v === "number")
+        return 2 ** (v / 1200);
+    const s = v.trim().split(/\s/)[0]; // first token only (Scala allows trailing text)
+    const ratioMatch = s.match(/^(\d+)[/:](\d+)$/);
+    if (ratioMatch) {
+        const num = Number(ratioMatch[1]);
+        const den = Number(ratioMatch[2]);
+        if (!Number.isFinite(num) || !Number.isFinite(den) || den === 0)
+            throw new RangeError(`Invalid ratio: "${s}"`);
+        return num / den;
+    }
+    const n = parseFloat(s);
+    if (!Number.isFinite(n))
+        throw new RangeError(`Invalid step value: "${s}"`);
+    if (s.includes("."))
+        return 2 ** (n / 1200); // cents
+    return n; // bare integer → ratio (e.g. 2 = 2/1)
+}
+export function parseScala(input) {
+    const lines = input.split(/\r?\n/);
+    const nonComment = [];
+    for (const line of lines) {
+        if (line.trimStart().startsWith("!"))
+            continue;
+        nonComment.push(line);
+    }
+    const name = (nonComment[0] ?? "").trim();
+    const count = parseInt(nonComment[1] ?? "0", 10);
+    if (!Number.isFinite(count) || count < 0)
+        throw new RangeError(`Invalid note count in Scala file: "${nonComment[1]}"`);
+    const steps = [];
+    for (let i = 2; i < nonComment.length && steps.length < count; i++) {
+        const trimmed = nonComment[i].trim();
+        if (trimmed)
+            steps.push(trimmed);
+    }
+    if (steps.length !== count)
+        throw new RangeError(`Scala file declares ${count} pitches but only ${steps.length} found`);
+    return { name, steps };
+}
+const PURE_FIFTH = 3 / 2;
+const SYNTONIC_COMMA = 81 / 80;
+const FIFTH_TO_CHROM = [0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5];
+const PTOLEMAIC = {
+    "ptolemy-intense": ["1/1", "9/8", "5/4", "4/3", "3/2", "5/3", "15/8"],
+    "ptolemy-soft": ["1/1", "8/7", "80/63", "4/3", "3/2", "12/7", "40/21"],
+    "ptolemy-equable": ["1/1", "12/11", "6/5", "4/3", "3/2", "18/11", "9/5"],
+};
+export function getPtolemaicRatios(tuning) {
+    return PTOLEMAIC[tuning];
+}
+function buildPythagoreanRatios(commaN) {
+    const tf = commaN === 0
+        ? PURE_FIFTH
+        : PURE_FIFTH * Math.pow(1 / SYNTONIC_COMMA, Math.min(1, Math.max(0, commaN)));
+    const out = new Array(12);
+    for (let k = 0; k < 12; k++) {
+        const pc = FIFTH_TO_CHROM[k];
+        out[pc] = foldOct(tf ** k);
+    }
+    const root = out[0] ?? 1;
+    for (let i = 0; i < 12; i++)
+        out[i] = (out[i] ?? 1) / root;
+    return out;
+}
+// The natural (white-key) pitch classes in ascending pitch order: C D E F G A B.
+// A diatonic-genus preset (Ptolemy's tetrachord divisions) describes the tuning
+// of THIS fixed gamut, not a per-mode arrangement.
+const NATURAL_PCS = [0, 2, 4, 5, 7, 9, 11];
+// Expand 7 diatonic step ratios to 12 by filling chromatic gaps with pythagorean.
+//
+// The seven ratios are laid onto the fixed natural gamut (C D E F G A B) in
+// pitch order — NOT onto the mode's scalePcs. A church mode is an octave
+// species of this one gamut, so its interval qualities emerge from *where the
+// final sits within the fixed tuning*, handled downstream by normalizeToRoot.
+// (Mapping degree-per-mode instead would force major-scale qualities — e.g.
+// a 5/4 major third above every final — onto every mode; see docs/tuning.md.)
+function expandDiatonicSteps(diatonic) {
+    const base = buildPythagoreanRatios(0);
+    const out = base.slice();
+    for (let i = 0; i < 7 && i < diatonic.length; i++) {
+        out[NATURAL_PCS[i]] = foldOct(diatonic[i]);
+    }
+    return out;
+}
+function normalizeToRoot(ratios, rootPc) {
+    const pivot = ratios[rootPc] ?? 1;
+    return ratios.map((r) => r / pivot);
+}
+function ratiosToCents(ratios) {
+    return ratios.map((r) => 1200 * Math.log2(r));
+}
+// ── Public ──
+export function buildRatios(opts = {}) {
+    const mode = opts.mode ?? 1;
+    const a4 = opts.a4 ?? 440;
+    const transpose = opts.transpose ?? 0;
+    const commaN = opts.comma != null ? parseComma(opts.comma) : 0;
+    const modeData = MODES.get(mode);
+    const finalisPc = modeData?.final ?? 0;
+    const rootPc = opts.root ?? finalisPc;
+    let ratios;
+    if (opts.steps != null) {
+        const parsed = opts.steps.map(parseStep);
+        if (parsed.length === 7) {
+            ratios = expandDiatonicSteps(parsed);
+        }
+        else if (parsed.length === 12) {
+            ratios = parsed;
+        }
+        else {
+            throw new RangeError(`steps must be 7 or 12 values, got ${parsed.length}`);
+        }
+    }
+    else {
+        ratios = buildPythagoreanRatios(commaN);
+    }
+    ratios = normalizeToRoot(ratios, rootPc);
+    const cents = ratiosToCents(ratios);
+    return { ratios, cents, mode, a4, comma: commaN, root: rootPc, transpose };
+}
+export function midiToHz(midi, scala) {
+    const m = Math.min(127, Math.max(0, Math.round(midi + scala.transpose)));
+    const pc = m % 12;
+    const oct = Math.floor(m / 12) - 1;
+    // Interval from A (pc=9) to target pc in cents, within the tuning.
+    // cents[] is root-normalized, and its octave folding differs by build path
+    // (the Pythagorean builder leaves below-root pcs negative; the diatonic-
+    // steps builder folds everything to [0,1200)). Place every pc in the
+    // C-register first — its height above pitch-class C within one octave —
+    // so the A→pc displacement is correct regardless of root or tuning.
+    const posC = (p) => {
+        const rel = (scala.cents[p] ?? 0) - (scala.cents[0] ?? 0);
+        return ((rel % 1200) + 1200) % 1200;
+    };
+    const centsFromA = posC(pc) - posC(9);
+    // A4 = midi 69, so A in this octave is midi (oct+1)*12 + 9 = m's octave A.
+    const octaveShift = oct - 4; // octaves above/below A4
+    const hz = scala.a4 * 2 ** (octaveShift + centsFromA / 1200);
+    const equalHz = scala.a4 * 2 ** ((m - 69) / 12);
+    const offset = 1200 * Math.log2(hz / equalHz);
+    const center = 8192;
+    const semis = offset / 100;
+    const bend = Math.max(0, Math.min(16383, Math.round(center + center * (semis / 2))));
+    return { hz, offset, bend };
+}
+//# sourceMappingURL=scale.js.map

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

@@ -0,0 +1,23 @@
+import type { Scale } from "./scale.js";
+export type Finger = "wrist" | "palm" | "thumb" | "index" | "middle" | "ring" | "pinky";
+export type Region = "base" | "mid" | "tip" | "top";
+export interface StepVariant {
+    hexachord: "durum" | "naturale" | "molle";
+    solmization: string;
+}
+export interface Step {
+    pc: number;
+    name: string;
+    nomen: string | null;
+    hexachord: "durum" | "naturale" | "molle" | null;
+    solmization: string | null;
+    variants: StepVariant[];
+    hand: {
+        finger: Finger;
+        region: Region;
+    } | null;
+    degree: number | null;
+    role: "finalis" | "tenor" | "other" | null;
+}
+export declare function toStep(midi: number, scala?: Scale): Step;
+//# sourceMappingURL=step.d.ts.map

package/dist/engines/temper/step.js

@@ -0,0 +1,53 @@
+// ---------------------------------------------------------------------------
+// engines/temper/step — Step type and modal/Guidonian annotation
+// ---------------------------------------------------------------------------
+import { MODES } from "./modes.js";
+import { lookupGuido } from "./guido.js";
+import { SHARP_SPELLING, FLAT_SPELLING, PREFER_FLAT_PCS } from "./data/constants.js";
+// SPN letter fallback (e.g. "D" for D4, pc 2) for out-of-gamut pitches.
+function spnLetterForPc(pc) {
+    const useFlat = PREFER_FLAT_PCS.has(pc);
+    const sp = useFlat ? FLAT_SPELLING[pc] : SHARP_SPELLING[pc];
+    return sp.step;
+}
+export function toStep(midi, scala) {
+    const mode = scala?.mode;
+    const guido = lookupGuido(midi, mode);
+    const pc = ((midi % 12) + 12) % 12;
+    let degree = null;
+    let role = null;
+    if (mode != null) {
+        const modeData = MODES.get(mode);
+        if (modeData) {
+            const idx = modeData.scalePcs.indexOf(pc);
+            degree = idx === -1 ? null : idx + 1;
+            if (degree != null) {
+                if (pc === modeData.final)
+                    role = "finalis";
+                else if (pc === modeData.tenor)
+                    role = "tenor";
+                else
+                    role = "other";
+            }
+        }
+    }
+    const name = guido.name ?? spnLetterForPc(pc);
+    const hand = guido.hand
+        ? { finger: guido.hand.finger, region: guido.hand.region }
+        : null;
+    return {
+        pc,
+        name,
+        nomen: guido.nomen,
+        hexachord: guido.hexachord,
+        solmization: guido.solmization,
+        variants: guido.mutations.map((m) => ({
+            hexachord: m.hexachord,
+            solmization: m.solmization,
+        })),
+        hand,
+        degree,
+        role,
+    };
+}
+//# sourceMappingURL=step.js.map

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { getFeast, getPascha } from "./engines/cal/calendar.js";
+import { getChants } from "./engines/chant/chant.js";
+import { getPropers } from "./engines/chant/propers.js";
+import { getOrdinary } from "./engines/chant/ordinary.js";
+import { getHour } from "./engines/chant/hour.js";
+import { getPsalm } from "./engines/chant/psalm.js";
+import { buildTemper } from "./engines/temper/api.js";
+import { buildScore } from "./engines/score/api.js";
+import { getCosmos } from "./engines/planet/planet.js";
+import { buildHarmonia } from "./engines/harmonia/api.js";
+import type { FeastQuery, Feast, Pascha, Season, Grade } from "./engines/cal/types.js";
+import type { CantusQuery, Chant, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery } from "./engines/chant/types.js";
+import type { TemperamentumInput, Temperamentum, Tuning, TemperamentumOpts, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, GamutOptions, Tonus, TonusOpts } from "./engines/temper/api.js";
+import type { Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, MidiOpts, MidiEmitResult, MidiJsonResult, MidiJsonEvent, MusicXmlOpts, MusicXmlEmitResult } from "./engines/score/api.js";
+import type { ChantTabulaRow } from "./engines/score/tabula.js";
+import type { Imprint, Attractor, VowelAttractor, ModalAffinity } from "./engines/imprint.js";
+import type { Prosody, RhythmicProfile, NoteRange, CadenceDistribution } from "./engines/score/prosody.js";
+import type { Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author } from "./engines/harmonia/api.js";
+import type { HarmonyTabulaRow } from "./engines/harmonia/tabula.js";
+import type { PlanetVowel } from "./engines/harmonia/data/vowels.js";
+import type { Note, Performance, Phrase, Syllable, RestEvent, ParseError, ArsisThesis } from "./engines/score/types.js";
+import type { VoicedPitch } from "./engines/harmonia/voice.js";
+import type { Cosmos, CosmosQuery, Body, BodyName, Aspect } from "./engines/planet/types.js";
+declare const tonus: {
+    festum: typeof getFeast;
+    pascha: typeof getPascha;
+    cantus: typeof getChants;
+    proprium: typeof getPropers;
+    ordinarium: typeof getOrdinary;
+    officium: typeof getHour;
+    psalmus: typeof getPsalm;
+    temperamentum: typeof buildTemper;
+    notatio: typeof buildScore;
+    caelum: typeof getCosmos;
+    harmonia: typeof buildHarmonia;
+};
+export default tonus;
+export { SEASON_LABELS, TEMPUS_NAMES, GRADE_ORDER, GRADE_NAMES, gradeOrder, compareGrade, ritusToGrade, } from "./engines/cal/types.js";
+export type { Feast, FeastQuery, Pascha, Season, Grade, Chant, CantusQuery, OrdinaryChant, PropriumQuery, OrdinariumQuery, OfficiumQuery, PsalmusQuery, Temperamentum, TemperamentumInput, TemperamentumOpts, Tuning, Pitch, PitchInput, Step, Neume, NeumeShape, Interval, ModeData, GamutOptions, Tonus, TonusOpts, Score, ScoreOpts, PondusInput, PondusOpts, AccentusInput, AccentusOpts, MidiOpts, MidiEmitResult, MidiJsonResult, MidiJsonEvent, MusicXmlOpts, MusicXmlEmitResult, ChantTabulaRow, Note, Performance, Phrase, Syllable, RestEvent, ParseError, ArsisThesis, VoicedPitch, Cosmos, CosmosQuery, Body, BodyName, Aspect, Imprint, Attractor, VowelAttractor, ModalAffinity, Prosody, RhythmicProfile, NoteRange, CadenceDistribution, Harmony, HarmoniaOpts, VoicedBody, VoicedAspect, Frame, Author, HarmonyTabulaRow, PlanetVowel, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,27 @@
+import { getFeast, getPascha } from "./engines/cal/calendar.js";
+import { getChants } from "./engines/chant/chant.js";
+import { getPropers } from "./engines/chant/propers.js";
+import { getOrdinary } from "./engines/chant/ordinary.js";
+import { getHour } from "./engines/chant/hour.js";
+import { getPsalm } from "./engines/chant/psalm.js";
+import { buildTemper } from "./engines/temper/api.js";
+import { buildScore } from "./engines/score/api.js";
+import { getCosmos } from "./engines/planet/planet.js";
+import { buildHarmonia } from "./engines/harmonia/api.js";
+const tonus = {
+    festum: getFeast,
+    pascha: getPascha,
+    cantus: getChants,
+    proprium: getPropers,
+    ordinarium: getOrdinary,
+    officium: getHour,
+    psalmus: getPsalm,
+    temperamentum: buildTemper,
+    notatio: buildScore,
+    caelum: getCosmos,
+    harmonia: buildHarmonia,
+};
+export default tonus;
+// Reference maps and grade helpers (display strings live here, not on objects).
+export { SEASON_LABELS, TEMPUS_NAMES, GRADE_ORDER, GRADE_NAMES, gradeOrder, compareGrade, ritusToGrade, } from "./engines/cal/types.js";
+//# sourceMappingURL=index.js.map