tonus 0.1.0

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

@@ -0,0 +1,66 @@
+export type Season = "adv" | "nat" | "epi" | "quadp" | "quad" | "pasc" | "pent";
+export declare const SEASON_LABELS: Readonly<Record<Season, string>>;
+export declare const TEMPUS_NAMES: Readonly<Record<Season, string>>;
+export declare const PENITENTIAL_SEASONS: ReadonlySet<Season>;
+export type Grade = "triduum" | "duplex-i" | "duplex-majus-i" | "semiduplex-i" | "feria-privilegiata" | "duplex-ii" | "semiduplex-ii" | "duplex-majus" | "duplex" | "semiduplex" | "simplex" | "feria-major" | "vigilia" | "feria";
+export declare const GRADE_ORDER: readonly Grade[];
+export declare const GRADE_NAMES: Readonly<Record<Grade, string>>;
+export declare const RITUS_TO_GRADE: Readonly<Record<string, Grade>>;
+/** Reduce a Tridentine ritus string to its canonical Grade. */
+export declare function ritusToGrade(ritus: string): Grade;
+export declare const PRIVILEGED_SUNDAYS: Readonly<Record<string, Grade>>;
+/**
+ * Grade for a calendar entry: the per-id privileged-Sunday override when
+ * one exists, otherwise the ritus reduction.
+ */
+export declare function entryGrade(id: string | undefined, ritus: string): Grade;
+/** Precedence index (0 = highest). Use for sorting and comparison. */
+export declare function gradeOrder(grade: Grade): number;
+/** Sort comparator: earlier in GRADE_ORDER (higher dignity) sorts first. */
+export declare function compareGrade(a: Grade, b: Grade): number;
+export declare const BVM_FEAST_IDS: ReadonlySet<string>;
+export declare const APOSTOLIC_FEAST_IDS: ReadonlySet<string>;
+export interface Feast {
+    id: string;
+    nomen: string;
+    ritus: string;
+    grade: Grade;
+    season: Season;
+    tempus: string;
+    seasonStart: Date;
+    seasonEnd: Date;
+    date: Date;
+    weekday: number;
+    masses: number[];
+    marian: boolean;
+    apostolic: boolean;
+}
+export interface FeastQuery {
+    date?: Date;
+    from?: Date;
+    to?: Date;
+    nomen?: string;
+    season?: Season;
+    grade?: Grade;
+    marian?: boolean;
+    apostolic?: boolean;
+}
+export interface Pascha {
+    year: number;
+    septuagesima: Date;
+    ashWednesday: Date;
+    firstLentSunday: Date;
+    palmSunday: Date;
+    goodFriday: Date;
+    easter: Date;
+    ascension: Date;
+    pentecost: Date;
+    trinitySunday: Date;
+    corpusChristi: Date;
+    adventFirstSunday: Date;
+    gaudete: Date;
+    christmas: Date;
+    epiphany: Date;
+    baptism: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/cal/types.js

@@ -0,0 +1,189 @@
+// ---------------------------------------------------------------------------
+// engines/cal/types — calendar types and constants
+// ---------------------------------------------------------------------------
+export const SEASON_LABELS = Object.freeze({
+    adv: "Advent",
+    nat: "Christmastide",
+    epi: "Time after Epiphany",
+    quadp: "Septuagesima",
+    quad: "Lent",
+    pasc: "Paschaltide",
+    pent: "Time after Pentecost",
+});
+// Authentic Latin season names (the books' own headings). Feast.tempus
+// carries these; SEASON_LABELS above is the English reference map.
+export const TEMPUS_NAMES = Object.freeze({
+    adv: "Tempus Adventus",
+    nat: "Tempus Nativitatis",
+    epi: "Tempus post Epiphaniam",
+    quadp: "Tempus Septuagesimæ",
+    quad: "Tempus Quadragesimæ",
+    pasc: "Tempus Paschale",
+    pent: "Tempus post Pentecosten",
+});
+// Penitential seasons: Gloria and (in quadp/quad) Alleluia are suppressed.
+export const PENITENTIAL_SEASONS = new Set([
+    "adv",
+    "quadp",
+    "quad",
+]);
+// High → low precedence. Position in this array IS the dignity — earlier
+// outranks later. There is no separate numeric rank field; precedence is read
+// from this order via gradeOrder / compareGrade.
+export const GRADE_ORDER = [
+    "triduum",
+    "duplex-i",
+    "duplex-majus-i",
+    "semiduplex-i",
+    "feria-privilegiata",
+    "duplex-ii",
+    "semiduplex-ii",
+    "duplex-majus",
+    "duplex",
+    "semiduplex",
+    "simplex",
+    "feria-major",
+    "vigilia",
+    "feria",
+];
+// Canonical Latin name per grade (display reference map, like SEASON_LABELS).
+// Feast objects don't carry this — `ritus` is the on-object Latin carrier;
+// use this map when the canonical grade name is wanted instead (it differs
+// from ritus only for octave compounds, the Triduum, and the privileged-
+// Sunday overrides).
+export const GRADE_NAMES = Object.freeze({
+    triduum: "Triduum Sacrum",
+    "duplex-i": "Duplex I classis",
+    "duplex-majus-i": "Duplex majus I classis",
+    "semiduplex-i": "Semiduplex I classis",
+    "feria-privilegiata": "Feria privilegiata",
+    "duplex-ii": "Duplex II classis",
+    "semiduplex-ii": "Semiduplex II classis",
+    "duplex-majus": "Duplex majus",
+    duplex: "Duplex",
+    semiduplex: "Semiduplex",
+    simplex: "Simplex",
+    "feria-major": "Feria major",
+    vigilia: "Vigilia",
+    feria: "Feria",
+});
+// Exact reduction of every ritus string the extractor produces to its
+// canonical Grade. Compounds ("… cum Octava …") reduce to their base
+// grade; the Triduum's privileged-feria ritus reduces to `triduum`.
+export const RITUS_TO_GRADE = Object.freeze({
+    "Feria privilegiata Duplex I classis": "triduum",
+    "Duplex I classis": "duplex-i",
+    "Duplex I classis cum Octava communi": "duplex-i",
+    "Duplex I classis cum Octava privilegiata I ordinis": "duplex-i",
+    "Duplex I classis cum Octava privilegiata II ordinis": "duplex-i",
+    "Duplex I classis cum Octava privilegiata III ordinis": "duplex-i",
+    "Duplex majus I classis": "duplex-majus-i",
+    "Semiduplex I classis": "semiduplex-i",
+    "Feria privilegiata": "feria-privilegiata",
+    "Duplex II classis": "duplex-ii",
+    "Duplex II classis cum Octava simplici": "duplex-ii",
+    "Semiduplex II classis": "semiduplex-ii",
+    "Duplex majus": "duplex-majus",
+    Duplex: "duplex",
+    Semiduplex: "semiduplex",
+    Simplex: "simplex",
+    "Feria major": "feria-major",
+    Vigilia: "vigilia",
+    Feria: "feria",
+});
+// Ordered, most-specific-first fallback matcher for ritus strings not in the
+// exact table above (future data). Longer patterns first so "Feria
+// privilegiata Duplex I classis" wins over "Feria privilegiata", and
+// "Duplex I classis" over "Duplex".
+const RITUS_PATTERNS = [
+    ["Feria privilegiata Duplex I classis", "triduum"],
+    ["Duplex majus I classis", "duplex-majus-i"],
+    ["Duplex I classis", "duplex-i"],
+    ["Duplex II classis", "duplex-ii"],
+    ["Semiduplex I classis", "semiduplex-i"],
+    ["Semiduplex II classis", "semiduplex-ii"],
+    ["Feria privilegiata", "feria-privilegiata"],
+    ["Duplex majus", "duplex-majus"],
+    ["Semiduplex", "semiduplex"],
+    ["Duplex", "duplex"],
+    ["Simplex", "simplex"],
+    ["Feria major", "feria-major"],
+    ["Vigilia", "vigilia"],
+    ["Feria", "feria"],
+];
+/** Reduce a Tridentine ritus string to its canonical Grade. */
+export function ritusToGrade(ritus) {
+    const exact = RITUS_TO_GRADE[ritus];
+    if (exact)
+        return exact;
+    for (const [pattern, grade] of RITUS_PATTERNS) {
+        if (ritus.includes(pattern))
+            return grade;
+    }
+    return "feria"; // last resort; extractor coverage is 100%, so unreached
+}
+// ── Privileged Sundays (per-id dignity overrides) ──
+// DO's Tridentine ritus line under-specifies four privileged Sundays as plain
+// "Semiduplex"; their precedence lived only in DO's numeric rank, which tonus
+// does not use. Historically Advent I is a first-class Sunday (yields to
+// nothing) and the Septuagesima-block Sundays are second-class (yield only to
+// first- and second-class feasts) — the same Sunday classes DO itself encodes
+// for Lent ("Semiduplex I classis") and late Advent ("Semiduplex II classis").
+// `ritus` stays verbatim; only the derived grade is lifted.
+export const PRIVILEGED_SUNDAYS = Object.freeze({
+    "Adv1-0": "semiduplex-i", // Dominica I Adventus
+    "Quadp1-0": "semiduplex-ii", // Dominica in Septuagesima
+    "Quadp2-0": "semiduplex-ii", // Dominica in Sexagesima
+    "Quadp3-0": "semiduplex-ii", // Dominica in Quinquagesima
+});
+/**
+ * Grade for a calendar entry: the per-id privileged-Sunday override when
+ * one exists, otherwise the ritus reduction.
+ */
+export function entryGrade(id, ritus) {
+    return (id !== undefined ? PRIVILEGED_SUNDAYS[id] : undefined) ?? ritusToGrade(ritus);
+}
+/** Precedence index (0 = highest). Use for sorting and comparison. */
+export function gradeOrder(grade) {
+    return GRADE_ORDER.indexOf(grade);
+}
+/** Sort comparator: earlier in GRADE_ORDER (higher dignity) sorts first. */
+export function compareGrade(a, b) {
+    return gradeOrder(a) - gradeOrder(b);
+}
+// ── BVM / Apostolic feast sets (keyed by DO stem: MM-DD for Sancti) ──
+export const BVM_FEAST_IDS = new Set([
+    "12-08", // Immaculate Conception
+    "03-19", // St. Joseph
+    "05-31", // Queenship of Mary
+    "07-02", // Visitation
+    "07-26", // St. Anne
+    "08-05", // Our Lady of the Snows
+    "08-14", // Vigil of the Assumption
+    "08-15", // Assumption
+    "08-16", // St. Joachim
+    "08-22", // Immaculate Heart
+    "09-08", // Nativity of Mary
+    "09-12", // Most Holy Name of Mary
+    "09-15", // Seven Sorrows
+    "10-11", // Motherhood of Mary
+]);
+export const APOSTOLIC_FEAST_IDS = new Set([
+    "11-30", // St. Andrew
+    "12-21", // St. Thomas
+    "01-25", // Conversion of St. Paul
+    "02-24", // St. Matthias
+    "05-11", // SS. Philip and James
+    "06-11", // St. Barnabas
+    "06-28", // Vigil of SS. Peter and Paul
+    "06-29", // SS. Peter and Paul
+    "06-30", // St. Paul
+    "07-25", // St. James
+    "08-24", // St. Bartholomew
+    "09-21", // St. Matthew
+    "10-18", // St. Luke
+    "10-28", // SS. Simon and Jude
+    "04-25", // St. Mark
+    "12-27", // St. John
+]);
+//# sourceMappingURL=types.js.map

package/dist/engines/chant/chant.d.ts

@@ -0,0 +1,10 @@
+import type { Chant, CantusQuery } from "./types.js";
+export declare function resolveChant(id: string | null): Chant | null;
+export declare function resolveChants(ids: string[]): Chant[];
+/**
+ * Cross-corpus chant retrieval (`tonus.cantus`) over GR, LA, LH, and LU.
+ * A `gabc` field bypasses the corpus and returns a single user
+ * chant parsed from raw GABC (body or full file with headers).
+ */
+export declare function getChants(query?: CantusQuery): Chant[];
+//# sourceMappingURL=chant.d.ts.map

package/dist/engines/chant/chant.js

@@ -0,0 +1,135 @@
+import { OFFICE_LABELS, MODE_LABELS } from "./types.js";
+import { GR_DATA, GR_SOURCE } from "../../data/gr.js";
+import { LU_DATA, LU_SOURCE } from "../../data/lu.js";
+import { LA_DATA, LA_SOURCE } from "../../data/la.js";
+import { LH_DATA, LH_SOURCE } from "../../data/lh.js";
+function modusOf(mode) {
+    return mode != null ? (MODE_LABELS[mode] ?? null) : null;
+}
+const HEADER_FIELD_REGEX = /([A-Za-z0-9_-]+)\s*:\s*([^;]*);/g;
+function chantFromGABC(query) {
+    const raw = query.gabc ?? "";
+    const markerIndex = raw.indexOf("%%");
+    let body;
+    let name = null;
+    let headerMode = null;
+    let officePart = null;
+    if (markerIndex >= 0) {
+        const headerBlock = raw.slice(0, markerIndex);
+        body = raw.slice(markerIndex + 2).trim();
+        HEADER_FIELD_REGEX.lastIndex = 0;
+        let match;
+        while ((match = HEADER_FIELD_REGEX.exec(headerBlock)) !== null) {
+            const key = match[1].trim().toLowerCase();
+            const value = match[2].trim();
+            if (key === "name")
+                name = value;
+            else if (key === "mode")
+                headerMode = value;
+            else if (key === "office-part")
+                officePart = value;
+        }
+    }
+    else {
+        body = raw.trim();
+    }
+    const incipit = query.incipit ?? name ?? "";
+    const mode = query.mode != null ? String(query.mode) : headerMode;
+    const office = (query.office
+        ? (Array.isArray(query.office) ? query.office[0] : query.office)
+        : officePart ?? "or");
+    return [{
+            id: `gabc:${incipit.toLowerCase().replace(/\s+/g, "_") || "untitled"}`,
+            incipit,
+            gabc: body,
+            office,
+            genus: OFFICE_LABELS[office] ?? office,
+            mode: mode ?? null,
+            modus: modusOf(mode ?? null),
+            pages: [],
+            source: { book: "User", year: null, editor: null, code: "user" },
+        }];
+}
+function withLabels(c, source) {
+    return {
+        ...c,
+        source,
+        genus: OFFICE_LABELS[c.office] ?? c.office,
+        modus: modusOf(c.mode),
+    };
+}
+const CORPUS = [
+    ...GR_DATA.map((c) => withLabels(c, GR_SOURCE)),
+    ...LU_DATA.map((c) => withLabels(c, LU_SOURCE)),
+    ...LA_DATA.map((c) => withLabels(c, LA_SOURCE)),
+    ...LH_DATA.map((c) => withLabels(c, LH_SOURCE)),
+];
+let _byId = null;
+function byId() {
+    if (!_byId)
+        _byId = new Map(CORPUS.map((c) => [c.id, c]));
+    return _byId;
+}
+function toArray(v) {
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v : [v];
+}
+export function resolveChant(id) {
+    if (!id)
+        return null;
+    return byId().get(id) ?? null;
+}
+export function resolveChants(ids) {
+    return ids.map(resolveChant).filter((c) => c !== null);
+}
+/**
+ * Cross-corpus chant retrieval (`tonus.cantus`) over GR, LA, LH, and LU.
+ * A `gabc` field bypasses the corpus and returns a single user
+ * chant parsed from raw GABC (body or full file with headers).
+ */
+export function getChants(query) {
+    if (!query || Object.keys(query).length === 0)
+        return [];
+    if (query.gabc)
+        return chantFromGABC(query);
+    const ids = toArray(query.id);
+    if (ids) {
+        const map = byId();
+        const found = ids.map((id) => map.get(id)).filter((c) => !!c);
+        return found;
+    }
+    let out = CORPUS;
+    const sources = toArray(query.source);
+    if (sources) {
+        const set = new Set(sources);
+        out = out.filter((c) => c.source.code != null && set.has(c.source.code));
+    }
+    const offices = toArray(query.office);
+    if (offices) {
+        const set = new Set(offices);
+        out = out.filter((c) => set.has(c.office));
+    }
+    const modes = toArray(query.mode);
+    if (modes) {
+        const set = new Set(modes.map(String));
+        out = out.filter((c) => c.mode != null && set.has(c.mode));
+    }
+    if (query.incipit) {
+        const needle = query.incipit.toLowerCase();
+        out = out.filter((c) => c.incipit.toLowerCase().includes(needle));
+    }
+    const sort = query.sort ?? "incipit";
+    const sorted = [...out].sort((a, b) => {
+        if (sort === "id")
+            return a.id.localeCompare(b.id);
+        if (sort === "mode")
+            return (String(a.mode ?? "").localeCompare(String(b.mode ?? "")) ||
+                a.incipit.localeCompare(b.incipit));
+        return a.incipit.localeCompare(b.incipit);
+    });
+    const offset = Math.max(0, query.offset ?? 0);
+    const limit = query.limit == null ? sorted.length : Math.max(0, query.limit);
+    return sorted.slice(offset, offset + limit);
+}
+//# sourceMappingURL=chant.js.map

package/dist/engines/chant/hour.d.ts

@@ -0,0 +1,8 @@
+import type { Chant, OfficiumQuery } from "./types.js";
+/**
+ * Divine Office retrieval (`tonus.officium`) for a canonical hour
+ * (matutinum … completorium). Without an hour, returns chants for all
+ * available hours; a feast acts as a filter.
+ */
+export declare function getHour(query?: OfficiumQuery): Chant[];
+//# sourceMappingURL=hour.d.ts.map

package/dist/engines/chant/hour.js

@@ -0,0 +1,135 @@
+// ---------------------------------------------------------------------------
+// engines/chant/hour — Divine Office hour retrieval
+// ---------------------------------------------------------------------------
+import { resolveChant, resolveChants } from "./chant.js";
+import { temporaSundayId } from "../cal/date.js";
+import { OFFICE_ROMAN } from "../../data/office-roman.js";
+let _roman = null;
+function romanMap() {
+    if (!_roman)
+        _roman = new Map(OFFICE_ROMAN.map((d) => [d.feastId, d]));
+    return _roman;
+}
+function chantsForFeastHour(feast, hour) {
+    const map = romanMap();
+    const sunday = temporaSundayId(feast.id);
+    const day = map.get(feast.id) ?? (sunday ? (map.get(sunday) ?? null) : null);
+    if (!day)
+        return [];
+    const results = [];
+    if (hour === "matutinum") {
+        const inv = resolveChant(day.invit);
+        if (inv)
+            results.push(inv);
+        results.push(...resolveChants(day.antMatutinum));
+        const hy = resolveChant(day.hymnMatutinum);
+        if (hy)
+            results.push(hy);
+        results.push(...resolveChants(day.respMatutinum));
+    }
+    else if (hour === "laudes") {
+        results.push(...resolveChants(day.antLaudes));
+        const bc = resolveChant(day.antBenedictus);
+        if (bc)
+            results.push(bc);
+        const hy = resolveChant(day.hymnLaudes);
+        if (hy)
+            results.push(hy);
+    }
+    else if (hour === "tertia") {
+        const rb = resolveChant(day.respBreveTertia);
+        if (rb)
+            results.push(rb);
+    }
+    else if (hour === "sexta") {
+        const rb = resolveChant(day.respBreveSexta);
+        if (rb)
+            results.push(rb);
+    }
+    else if (hour === "nona") {
+        const rb = resolveChant(day.respBreveNona);
+        if (rb)
+            results.push(rb);
+    }
+    else if (hour === "vesperae") {
+        results.push(...resolveChants(day.antVespera));
+        const mc = resolveChant(day.antMagnificat);
+        if (mc)
+            results.push(mc);
+        const hy = resolveChant(day.hymnVespera);
+        if (hy)
+            results.push(hy);
+    }
+    return results;
+}
+function toArray(v) {
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v : [v];
+}
+/**
+ * Divine Office retrieval (`tonus.officium`) for a canonical hour
+ * (matutinum … completorium). Without an hour, returns chants for all
+ * available hours; a feast acts as a filter.
+ */
+export function getHour(query) {
+    if (!query || Object.keys(query).length === 0)
+        return [];
+    const feasts = toArray(query.feast);
+    const hour = query.hora;
+    let results;
+    if (feasts && hour) {
+        results = feasts.flatMap((f) => chantsForFeastHour(f, hour));
+    }
+    else if (feasts) {
+        const hours = ["matutinum", "laudes", "tertia", "sexta", "nona", "vesperae"];
+        results = feasts.flatMap((f) => hours.flatMap((h) => chantsForFeastHour(f, h)));
+    }
+    else if (hour) {
+        // Hour without feast — scan all office entries
+        results = OFFICE_ROMAN.flatMap((day) => {
+            const mockFeast = { id: day.feastId };
+            return chantsForFeastHour(mockFeast, hour);
+        });
+    }
+    else {
+        return [];
+    }
+    // Apply CantusQuery filters
+    const offices = toArray(query.office);
+    if (offices) {
+        const set = new Set(offices);
+        results = results.filter((c) => set.has(c.office));
+    }
+    const modes = toArray(query.mode);
+    if (modes) {
+        const set = new Set(modes.map(String));
+        results = results.filter((c) => c.mode != null && set.has(c.mode));
+    }
+    const sources = toArray(query.source);
+    if (sources) {
+        const set = new Set(sources);
+        results = results.filter((c) => c.source.code != null && set.has(c.source.code));
+    }
+    if (query.incipit) {
+        const needle = query.incipit.toLowerCase();
+        results = results.filter((c) => c.incipit.toLowerCase().includes(needle));
+    }
+    if (query.id) {
+        const ids = new Set(toArray(query.id));
+        results = results.filter((c) => ids.has(c.id));
+    }
+    const sort = query.sort ?? "incipit";
+    results.sort((a, b) => {
+        if (sort === "id")
+            return a.id.localeCompare(b.id);
+        if (sort === "mode")
+            return (String(a.mode ?? "").localeCompare(String(b.mode ?? "")) ||
+                a.incipit.localeCompare(b.incipit));
+        return a.incipit.localeCompare(b.incipit);
+    });
+    const offset = Math.max(0, query.offset ?? 0);
+    const limit = query.limit == null ? results.length : Math.max(0, query.limit);
+    return results.slice(offset, offset + limit);
+}
+//# sourceMappingURL=hour.js.map

package/dist/engines/chant/intone.d.ts

@@ -0,0 +1,8 @@
+import type { PsalmVerse } from "./types.js";
+export interface IntoneOpts {
+    mode?: number;
+    differentia?: string;
+    intonation?: boolean;
+}
+export declare function intone(text: string | PsalmVerse, opts?: IntoneOpts): string;
+//# sourceMappingURL=intone.d.ts.map

package/dist/engines/chant/intone.js

@@ -0,0 +1,84 @@
+// ---------------------------------------------------------------------------
+// engines/chant/intone — GABC generation for psalm verses sung to psalm tones
+// ---------------------------------------------------------------------------
+import { syllabifyPhrase } from "./syllabify.js";
+import { getTone, getDifferentia } from "../../data/tones.js";
+import { midiToGabc } from "../temper/gabc.js";
+const DEFAULT_CLEF = "c4";
+const CLEF = `(${DEFAULT_CLEF}) `;
+function midiListToLetters(midis, clef) {
+    return midis.map((m) => midiToGabc(m, clef));
+}
+function buildHalf(syllables, tenor, cadenceNotes, prefixNotes) {
+    if (syllables.length === 0)
+        return "";
+    const nonSpace = syllables.filter((s) => s !== " ");
+    let noteAssignment;
+    if (prefixNotes && prefixNotes.length > 0) {
+        noteAssignment = [];
+        const total = nonSpace.length;
+        const pfxLen = Math.min(prefixNotes.length, total);
+        const cadLen = Math.min(cadenceNotes.length, total - pfxLen);
+        const midLen = total - pfxLen - cadLen;
+        for (let i = 0; i < pfxLen; i++)
+            noteAssignment.push(prefixNotes[i]);
+        for (let i = 0; i < midLen; i++)
+            noteAssignment.push(tenor);
+        for (let i = 0; i < cadLen; i++)
+            noteAssignment.push(cadenceNotes[i]);
+    }
+    else {
+        noteAssignment = [];
+        const total = nonSpace.length;
+        const cadLen = Math.min(cadenceNotes.length, total);
+        const midLen = total - cadLen;
+        for (let i = 0; i < midLen; i++)
+            noteAssignment.push(tenor);
+        for (let i = 0; i < cadLen; i++)
+            noteAssignment.push(cadenceNotes[i]);
+    }
+    let noteIdx = 0;
+    const tokens = [];
+    for (const syl of syllables) {
+        if (syl === " ") {
+            tokens.push(" ");
+        }
+        else {
+            const note = noteAssignment[noteIdx++] ?? tenor;
+            tokens.push(`(${note})${syl}`);
+        }
+    }
+    return tokens.join("");
+}
+export function intone(text, opts = {}) {
+    let rawText;
+    if (typeof text === "object") {
+        rawText = `${text.half1} * ${text.half2}`;
+    }
+    else {
+        rawText = text;
+    }
+    const clef = DEFAULT_CLEF;
+    const mode = opts.mode ?? 8;
+    const tone = getTone(mode);
+    const diff = getDifferentia(tone, opts.differentia);
+    const tenorLetter = midiToGabc(tone.tenor, clef);
+    const mediantLetters = midiListToLetters(tone.mediant, clef);
+    const terminationLetters = midiListToLetters(diff.termination, clef);
+    const intonationLetters = midiListToLetters(tone.intonation, clef);
+    const starIdx = rawText.indexOf(" * ");
+    if (starIdx === -1) {
+        const syllables = syllabifyPhrase(rawText.trim());
+        const body = buildHalf(syllables, tenorLetter, terminationLetters);
+        return CLEF + body + "(::)";
+    }
+    const half1Text = rawText.slice(0, starIdx).trim();
+    const half2Text = rawText.slice(starIdx + 3).trim();
+    const half1Sylls = syllabifyPhrase(half1Text);
+    const half2Sylls = syllabifyPhrase(half2Text);
+    const useIntonation = opts.intonation !== false;
+    const h1 = buildHalf(half1Sylls, tenorLetter, mediantLetters, useIntonation ? intonationLetters : undefined);
+    const h2 = buildHalf(half2Sylls, tenorLetter, terminationLetters);
+    return `${CLEF}${h1}(:) ${h2}(::)`;
+}
+//# sourceMappingURL=intone.js.map

package/dist/engines/chant/ordinary.d.ts

@@ -0,0 +1,7 @@
+import { type OrdinaryChant, type OrdinariumQuery } from "./types.js";
+/**
+ * Mass ordinary retrieval (`tonus.ordinarium`) from the Kyriale. A feast
+ * drives mass selection; `mass` pins a kyriale number directly.
+ */
+export declare function getOrdinary(query?: OrdinariumQuery): OrdinaryChant[];
+//# sourceMappingURL=ordinary.d.ts.map