tonus 0.1.4 → 0.1.8

package/dist/data/office-psalms-monastic.d.ts

@@ -0,0 +1,3 @@
+import type { OfficePsalmEntry } from "./office-psalms-roman.js";
+export declare const OFFICE_PSALMS_MONASTIC: OfficePsalmEntry[];
+//# sourceMappingURL=office-psalms-monastic.d.ts.map

package/dist/data/office-psalms-monastic.js

@@ -0,0 +1,21 @@
+export const OFFICE_PSALMS_MONASTIC = [
+    { hour: "Prima", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 1, to: 8 }, { psalm: 118, from: 9, to: 16 }, { psalm: 118, from: 17, to: 24 }, { psalm: 118, from: 25, to: 32 }] },
+    { hour: "Prima", weekday: 1, festis: false, psalms: [{ psalm: 1 }, { psalm: 2 }, { psalm: 6 }] },
+    { hour: "Prima", weekday: 2, festis: false, psalms: [{ psalm: 7 }, { psalm: 8 }, { psalm: 9, from: 2, to: 19 }] },
+    { hour: "Prima", weekday: 3, festis: false, psalms: [{ psalm: 9, from: 20, to: 39 }, { psalm: 10 }, { psalm: 11 }] },
+    { hour: "Prima", weekday: 4, festis: false, psalms: [{ psalm: 12 }, { psalm: 13 }, { psalm: 14 }] },
+    { hour: "Prima", weekday: 5, festis: false, psalms: [{ psalm: 15 }, { psalm: 16 }, { psalm: 17, from: 2, to: 25 }] },
+    { hour: "Prima", weekday: 6, festis: false, psalms: [{ psalm: 17, from: 26, to: 51 }, { psalm: 18 }, { psalm: 19 }] },
+    { hour: "Prima", weekday: null, festis: true, psalms: [{ psalm: 118, from: 1, to: 8 }, { psalm: 118, from: 9, to: 16 }, { psalm: 118, from: 17, to: 24 }, { psalm: 118, from: 25, to: 32 }] },
+    { hour: "Tertia", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 33, to: 40 }, { psalm: 118, from: 41, to: 48 }, { psalm: 118, from: 49, to: 56 }] },
+    { hour: "Tertia", weekday: 1, festis: false, psalms: [{ psalm: 118, from: 105, to: 112 }, { psalm: 118, from: 113, to: 120 }, { psalm: 118, from: 121, to: 128 }] },
+    { hour: "Tertia", weekday: null, festis: false, psalms: [{ psalm: 119 }, { psalm: 120 }, { psalm: 121 }] },
+    { hour: "Sexta", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 57, to: 64 }, { psalm: 118, from: 65, to: 72 }, { psalm: 118, from: 73, to: 80 }] },
+    { hour: "Sexta", weekday: 1, festis: false, psalms: [{ psalm: 118, from: 129, to: 136 }, { psalm: 118, from: 137, to: 144 }, { psalm: 118, from: 145, to: 152 }] },
+    { hour: "Sexta", weekday: null, festis: false, psalms: [{ psalm: 122 }, { psalm: 123 }, { psalm: 124 }] },
+    { hour: "Nona", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 81, to: 88 }, { psalm: 118, from: 89, to: 96 }, { psalm: 118, from: 97, to: 104 }] },
+    { hour: "Nona", weekday: 1, festis: false, psalms: [{ psalm: 118, from: 153, to: 160 }, { psalm: 118, from: 161, to: 168 }, { psalm: 118, from: 169, to: 176 }] },
+    { hour: "Nona", weekday: null, festis: false, psalms: [{ psalm: 125 }, { psalm: 126 }, { psalm: 127 }] },
+    { hour: "Completorium", weekday: null, festis: false, psalms: [{ psalm: 4 }, { psalm: 90 }, { psalm: 133 }] }
+];
+//# sourceMappingURL=office-psalms-monastic.js.map

package/dist/data/{office-psalms.d.ts → office-psalms-roman.d.ts}

@@ -12,4 +12,4 @@ export interface OfficePsalmEntry {
     psalms: OfficePsalmPortion[];
 }
 export declare const OFFICE_PSALMS: OfficePsalmEntry[];
-//# sourceMappingURL=office-psalms.d.ts.map
+//# sourceMappingURL=office-psalms-roman.d.ts.map

package/dist/data/{office-psalms.js → office-psalms-roman.js}

@@ -1,7 +1,7 @@
-// office-psalms.ts — little-hours psalmody (Prime, Terce, Sext, None, Compline)
+// office-psalms-roman.ts — Roman little-hours psalmody (Prime, Terce, Sext, None, Compline)
 // Extracted from Divinum Officium (Psalterium, [Tridentinum] section) by
 // scripts/extract-office-psalms.mjs
-// Generated: 2026-07-05T01:25:28.943Z
+// Generated: 2026-07-08T04:45:29.223Z
 // Entries: 15
 //
 // The traditional (pre-1911) Roman little-hours psalm distribution. Each entry
@@ -25,4 +25,4 @@ export const OFFICE_PSALMS = [
     { hour: "Nona", weekday: null, festis: false, psalms: [{ psalm: 118, from: 129, to: 144 }, { psalm: 118, from: 145, to: 160 }, { psalm: 118, from: 161, to: 176 }] },
     { hour: "Completorium", weekday: null, festis: false, psalms: [{ psalm: 4 }, { psalm: 30, from: 2, to: 6 }, { psalm: 90 }, { psalm: 133 }] }
 ];
-//# sourceMappingURL=office-psalms.js.map
+//# sourceMappingURL=office-psalms-roman.js.map

package/dist/engines/cal/calendar.js

@@ -1,8 +1,23 @@
 // ---------------------------------------------------------------------------
 // engines/cal/calendar — liturgical feast lookup
 // ---------------------------------------------------------------------------
+// The era, and why it is what it is. The calendar's *structure* is medieval —
+// the temporale from Advent through the season after Pentecost (Septuagesima
+// included), the eight-hour office cursus, the duplex/semiduplex/simplex
+// dignity system. The *data* is the Tridentine codification (1570–1962) drawn
+// from Divinum Officium [biblio: divinum-officium], substantially continuous
+// with late-medieval Roman usage but carrying feasts instituted as late as the
+// 1950s (Queenship of Mary 1954, Immaculate Heart 1944).
+//
+// Decision: those post-medieval feasts are KEPT, not pruned. Pruning would
+// break the DO data's integrity and demand per-feast historical adjudication;
+// instead tonus states its actual era plainly. The honest description is
+// "Tridentine Roman, continuous with medieval practice" — not "a medieval
+// calendar." (Per-feast era metadata — medieval / tridentine / modern — is
+// noted as future work.) The rank system this data carries is documented at
+// `ritus`/`Grade` in ./types.ts; Easter reckoning at pascha() in ./date.ts.
 import { CAL } from "../../data/cal.js";
-import { MASSES } from "../../data/masses.js";
+import { MASSES } from "../chant/data/masses.js";
 import { isoDate, startOfDay, addDays, subDays, firstSundayOnOrAfter, nextSunday, pascha, resolveEntryId, DEFAULT_EPOCH, } from "./date.js";
 import { TEMPUS_NAMES, entryGrade, gradeOrder, BVM_FEAST_IDS, APOSTOLIC_FEAST_IDS, } from "./types.js";
 const _calCache = new Map();

package/dist/engines/cal/date.js

@@ -37,6 +37,11 @@ export function parseMonthDay(year, mmdd) {
     return new Date(Date.UTC(year, m - 1, d));
 }
 // ── Easter ──
+// Split at the Gregorian reform (1583): from 1583 on, the Gauss/Butcher
+// Gregorian computus; before it, the classical 19-year Julian cycle with a
+// Julian→Gregorian day-number conversion [biblio: computus]. This keeps Easter
+// correct for date queries reaching back into the medieval period — the era the
+// calendar is built for (see the era note in ./calendar.ts).
 export function pascha(year) {
     if (year < 1583)
         return paschaJulian(year);

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

@@ -1,4 +1,10 @@
-import type { Chant, CantusQuery } from "./types.js";
+import type { Chant, CantusQuery, ChantSource, Corpus } from "./types.js";
+/**
+ * Metadata and content breakdown for one corpus book (`tonus.corpus`). Pass a
+ * source code; get the book's bibliographic identity plus its genre and mode
+ * distributions. Computed on first access from the loaded corpus, then cached.
+ */
+export declare function getCorpus(code: ChantSource): Corpus;
 export declare function resolveChant(id: string | null): Chant | null;
 export declare function resolveChants(ids: string[]): Chant[];
 /**

package/dist/engines/chant/chant.js

@@ -1,8 +1,11 @@
 import { OFFICE_LABELS, MODE_LABELS } from "./types.js";
+import { CORPUS_OVERLAP } from "../../data/corpus-overlap.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";
+import { AM_DATA, AM_SOURCE } from "../../data/am.js";
+import { NR_DATA, NR_SOURCE } from "../../data/nocturnale-romanum.js";
 function modusOf(mode) {
     return mode != null ? (MODE_LABELS[mode] ?? null) : null;
 }
@@ -63,6 +66,8 @@ const CORPUS = [
     ...LU_DATA.map((c) => withLabels(c, LU_SOURCE)),
     ...LA_DATA.map((c) => withLabels(c, LA_SOURCE)),
     ...LH_DATA.map((c) => withLabels(c, LH_SOURCE)),
+    ...AM_DATA.map((c) => withLabels(c, AM_SOURCE)),
+    ...NR_DATA.map((c) => withLabels(c, NR_SOURCE)),
 ];
 let _byId = null;
 function byId() {
@@ -70,6 +75,73 @@ function byId() {
         _byId = new Map(CORPUS.map((c) => [c.id, c]));
     return _byId;
 }
+const SOURCES = {
+    gr: GR_SOURCE, lu: LU_SOURCE, la: LA_SOURCE, lh: LH_SOURCE, am: AM_SOURCE, nr: NR_SOURCE,
+};
+// Tally a book's genre and mode distribution — computed once per code, cached.
+const _corpusCache = new Map();
+/**
+ * Metadata and content breakdown for one corpus book (`tonus.corpus`). Pass a
+ * source code; get the book's bibliographic identity plus its genre and mode
+ * distributions. Computed on first access from the loaded corpus, then cached.
+ */
+export function getCorpus(code) {
+    const cached = _corpusCache.get(code);
+    if (cached)
+        return cached;
+    const src = SOURCES[code];
+    if (!src)
+        throw new Error(`Unknown corpus code: "${code}" (expected gr, lu, la, lh, or am)`);
+    const chants = CORPUS.filter((c) => c.source.code === code);
+    // Genre distribution — count by office code, descending by count.
+    const officeCounts = new Map();
+    // Mode distribution — count by mode 1–8; everything else (p/d/e, null) into one bucket.
+    const modeCounts = new Map();
+    let otherModes = 0;
+    for (const c of chants) {
+        officeCounts.set(c.office, (officeCounts.get(c.office) ?? 0) + 1);
+        if (c.mode != null && MODE_LABELS[c.mode]) {
+            modeCounts.set(c.mode, (modeCounts.get(c.mode) ?? 0) + 1);
+        }
+        else {
+            otherModes++;
+        }
+    }
+    const genera = [...officeCounts.entries()]
+        .map(([office, count]) => ({ office, genus: OFFICE_LABELS[office] ?? office, count }))
+        .sort((a, b) => b.count - a.count);
+    const modes = [];
+    for (const m of ["1", "2", "3", "4", "5", "6", "7", "8"]) {
+        const count = modeCounts.get(m);
+        if (count)
+            modes.push({ mode: m, modus: MODE_LABELS[m], count });
+    }
+    if (otherModes > 0)
+        modes.push({ mode: null, modus: null, count: otherModes });
+    // Pre-dedup relationships (precomputed in tonus-corpus — tonus can't derive
+    // them, since it stores only one copy of each shared chant).
+    const ov = CORPUS_OVERLAP[code];
+    const shared = Object.entries(ov?.shared ?? {})
+        .map(([c, count]) => ({ code: c, count }))
+        .sort((a, b) => b.count - a.count);
+    const result = {
+        code,
+        book: src.book,
+        fullTitle: src.fullTitle ?? null,
+        edition: src.edition ?? null,
+        year: src.year,
+        editor: src.editor,
+        scanSource: src.scanSource ?? null,
+        count: chants.length,
+        total: ov?.total ?? chants.length,
+        unique: ov?.unique ?? chants.length,
+        shared,
+        genera,
+        modes,
+    };
+    _corpusCache.set(code, result);
+    return result;
+}
 function toArray(v) {
     if (v === undefined)
         return undefined;

package/dist/{data → engines/chant/data}/compline.d.ts

@@ -1,4 +1,4 @@
-import type { Season } from "../engines/cal/types.js";
+import type { Season } from "../../cal/types.js";
 /** The invariable spine — chants sung the same every night. */
 export declare const COMPLINE_ORDINARY: {
     /** Deus in adjutorium — the opening versicle. */

package/dist/{data → engines/chant/data}/masses.d.ts

@@ -1,4 +1,4 @@
-import { type Season, type Grade } from "../engines/cal/types.js";
+import { type Season, type Grade } from "../../cal/types.js";
 export interface MassEntry {
     id: string;
     mass: number;

package/dist/{data → engines/chant/data}/masses.js

@@ -2,7 +2,7 @@
 //
 // Describes which masses are appropriate for a given season, grade, and day.
 // Mass 0 has two ad-lib variants (index 0a/0b); all others are single entries.
-import { GRADE_ORDER, } from "../engines/cal/types.js";
+import { GRADE_ORDER, } from "../../cal/types.js";
 // Inclusive slice of GRADE_ORDER from `high` (more solemn) to `low`.
 // e.g. gradesFrom("duplex-i", "duplex-ii") lists every grade between them.
 function gradesFrom(high, low) {

package/dist/{data → engines/chant/data}/prime.d.ts

@@ -1,4 +1,4 @@
-import type { Season } from "../engines/cal/types.js";
+import type { Season } from "../../cal/types.js";
 /** The invariable spine. */
 export declare const PRIME_ORDINARY: {
     /** Deus in adjutorium — the opening versicle. */

package/dist/{data → engines/chant/data}/prime.js

@@ -8,7 +8,7 @@
 // Solesmes chant and are not in the corpus, so they are out of scope; this is a
 // chant ordo, not a full Breviary Prime.
 //
-// Like data/compline.ts and data/masses.ts this is a hand-authored table that
+// Like compline.ts and masses.ts (its siblings here) this is a hand-authored table that
 // references chants already in the corpus by id; it carries no GABC of its own.
 // See docs/chant.md and BIBLIOGRAPHY.md.
 // Prime's psalmody (Ps 53 + a weekday-proper psalm + Ps 118 in two sections,

package/dist/engines/chant/hour.js

@@ -6,10 +6,17 @@ import { intonePortion, officePsalmPortions } from "./psalm.js";
 import { temporaSundayId } from "../cal/date.js";
 import { getFeast } from "../cal/calendar.js";
 import { OFFICE_ROMAN } from "../../data/office-roman.js";
-import { COMPLINE_ORDINARY, COMPLINE_SEASONAL, marianAntiphonFor, } from "../../data/compline.js";
-import { PRIME_ORDINARY, PRIME_SEASONAL } from "../../data/prime.js";
+import { OFFICE_MONASTIC } from "../../data/office-monastic.js";
+import { COMPLINE_ORDINARY, COMPLINE_SEASONAL, marianAntiphonFor, } from "./data/compline.js";
+import { PRIME_ORDINARY, PRIME_SEASONAL } from "./data/prime.js";
 let _roman = null;
-function romanMap() {
+let _monastic = null;
+function officeMap(rite) {
+    if (rite === "monasticum") {
+        if (!_monastic)
+            _monastic = new Map(OFFICE_MONASTIC.map((d) => [d.feastId, d]));
+        return _monastic;
+    }
     if (!_roman)
         _roman = new Map(OFFICE_ROMAN.map((d) => [d.feastId, d]));
     return _roman;
@@ -29,14 +36,17 @@ const SEASONAL_ORDO_HOURS = new Set([
 // tables at all. The ordo is assembled from the season (Te lucis, In manus
 // tuas), the fixed psalms (from the extracted DO scheme), the invariable spine
 // (Deus in adjutorium, Nunc dimittis), and the date-driven Marian antiphon.
-// See data/compline.ts.
-function complineForFeast(feast) {
+// See ./data/compline.ts.
+function complineForFeast(feast, rite) {
     const seasonal = COMPLINE_SEASONAL[feast.season];
     const results = [];
     const opening = resolveChant(COMPLINE_ORDINARY.opening);
     if (opening)
         results.push(opening);
-    for (const p of officePsalmPortions("Completorium", feast.weekday)) {
+    // Monastic Compline uses a fixed three-psalm set (4, 90, 133); the Roman rite
+    // adds Ps 30 vv. 2–6. The difference is entirely in the psalm scheme — the
+    // rest of the ordo (spine, hymn, In manus tuas, Marian antiphon) is shared.
+    for (const p of officePsalmPortions("Completorium", feast.weekday, rite)) {
         results.push(...intonePortion(p));
     }
     const hymn = seasonal && resolveChant(seasonal.teLucis);
@@ -54,9 +64,9 @@ function complineForFeast(feast) {
     return results;
 }
 // Prime, like Compline, is a fixed+seasonal ordo, not per-feast. Covers the
-// sung parts only (see data/prime.ts): opening, fixed psalms, the hymn Iam
+// sung parts only (see ./data/prime.ts): opening, fixed psalms, the hymn Iam
 // lucis, and the seasonal short responsory Christe Fili Dei.
-function primeForFeast(feast) {
+function primeForFeast(feast, rite) {
     const seasonal = PRIME_SEASONAL[feast.season];
     const results = [];
     const opening = resolveChant(PRIME_ORDINARY.opening);
@@ -65,7 +75,9 @@ function primeForFeast(feast) {
     const hymn = resolveChant(PRIME_ORDINARY.hymn);
     if (hymn)
         results.push(hymn);
-    for (const p of officePsalmPortions("Prima", feast.weekday)) {
+    // The monastic Prime psalmody is weekday-varied across the psalter (vs. the
+    // Roman Ps-118 pattern) — a psalm-scheme difference; the ordo spine is shared.
+    for (const p of officePsalmPortions("Prima", feast.weekday, rite)) {
         results.push(...intonePortion(p));
     }
     const responsory = seasonal && resolveChant(seasonal.responsory);
@@ -73,12 +85,12 @@ function primeForFeast(feast) {
         results.push(responsory);
     return results;
 }
-function chantsForFeastHour(feast, hour) {
+function chantsForFeastHour(feast, hour, rite) {
     if (hour === "completorium")
-        return complineForFeast(feast);
+        return complineForFeast(feast, rite);
     if (hour === "prima")
-        return primeForFeast(feast);
-    const map = romanMap();
+        return primeForFeast(feast, rite);
+    const map = officeMap(rite);
     const sunday = temporaSundayId(feast.id);
     const day = map.get(feast.id) ?? (sunday ? (map.get(sunday) ?? null) : null);
     if (!day)
@@ -111,7 +123,7 @@ function chantsForFeastHour(feast, hour) {
         // repeat the psalms once per feast).
         if (feast.date) {
             const hourName = hour === "tertia" ? "Tertia" : hour === "sexta" ? "Sexta" : "Nona";
-            for (const p of officePsalmPortions(hourName, feast.weekday)) {
+            for (const p of officePsalmPortions(hourName, feast.weekday, rite)) {
                 results.push(...intonePortion(p));
             }
         }
@@ -147,34 +159,37 @@ export function getHour(query) {
         return [];
     const feasts = toArray(query.feast);
     const hour = query.hora;
+    const rite = query.rite ?? "romanum";
     let results;
     if (feasts && hour) {
         // Prime and Compline are seasonal/weekday ordos, identical for every feast
         // of the day — so concurrent feasts collapse to a single ordo rather than
         // repeating it. The other hours are genuinely per-feast.
         results = SEASONAL_ORDO_HOURS.has(hour)
-            ? feasts[0] ? chantsForFeastHour(feasts[0], hour) : []
-            : feasts.flatMap((f) => chantsForFeastHour(f, hour));
+            ? feasts[0] ? chantsForFeastHour(feasts[0], hour, rite) : []
+            : feasts.flatMap((f) => chantsForFeastHour(f, hour, rite));
     }
     else if (feasts) {
         const hours = [
             "matutinum", "laudes", "prima", "tertia", "sexta", "nona",
             "vesperae", "completorium",
         ];
-        results = feasts.flatMap((f) => hours.flatMap((h) => chantsForFeastHour(f, h)));
+        results = feasts.flatMap((f) => hours.flatMap((h) => chantsForFeastHour(f, h, rite)));
     }
     else if (hour && SEASONAL_ORDO_HOURS.has(hour)) {
         // Prime and Compline are seasonal ordos, not per-feast. With no feast,
         // resolve for the default epoch (Guido d'Arezzo's era) — festum()'s anchor.
         const [feast] = getFeast();
-        results = feast ? chantsForFeastHour(feast, hour) : [];
+        results = feast ? chantsForFeastHour(feast, hour, rite) : [];
     }
     else if (hour) {
-        // Hour without feast — survey per-feast content across all office entries.
-        // mockFeast has no date, so the little hours return only their responsories.
-        results = OFFICE_ROMAN.flatMap((day) => {
+        // Hour without feast — survey per-feast content across the office entries of
+        // the chosen rite. mockFeast has no date, so the little hours return only
+        // their responsories.
+        const table = rite === "monasticum" ? OFFICE_MONASTIC : OFFICE_ROMAN;
+        results = table.flatMap((day) => {
             const mockFeast = { id: day.feastId };
-            return chantsForFeastHour(mockFeast, hour);
+            return chantsForFeastHour(mockFeast, hour, rite);
         });
     }
     else {

package/dist/engines/chant/intone.js

@@ -1,8 +1,13 @@
 // ---------------------------------------------------------------------------
 // engines/chant/intone — GABC generation for psalm verses sung to psalm tones
 // ---------------------------------------------------------------------------
+// Psalmody structure follows the Liber Usualis rules [biblio: liber-usualis]:
+// each verse is intonation → tenor (reciting note) → mediation → final cadence,
+// with the flex a subdivision of a long first half. The intonation is sung on
+// the first verse only (unless repeated, as in the Magnificat) — see the
+// `intonation` option; `inDirectum` recites straight through with no mediant.
 import { syllabifyPhrase } from "./syllabify.js";
-import { getTone, getDifferentia } from "../../data/tones.js";
+import { getTone, getDifferentia } from "../temper/data/tones.js";
 import { midiToGabc } from "../temper/gabc.js";
 const DEFAULT_CLEF = "c4";
 const CLEF = `(${DEFAULT_CLEF}) `;

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

@@ -0,0 +1,33 @@
+import type { Chant, OfficiumQuery } from "./types.js";
+/** One nocturn of a resolved Matins: its responsories (and any antiphons). */
+export interface Nocturn {
+    /** 1–3. */
+    n: number;
+    /** The nocturn's great responsories, in order, as resolved chants. */
+    responsories: Chant[];
+    /** The nocturn's antiphons, where the Nocturnale carries them (else empty). */
+    antiphons: Chant[];
+}
+/** A feast's structured Roman Matins. */
+export interface Matins {
+    /** The tonus feast id this Matins was resolved for. */
+    feastId: string;
+    /** The feast's Latin name from the Nocturnale. */
+    name: string;
+    /** The rank/class, e.g. "I. classis", "Feria". */
+    rank: string;
+    /** One nocturn (simple) or three (festal). */
+    nocturns: Nocturn[];
+    /** The feast whose chants were borrowed by rubric, if any (provenance). */
+    redirectedFrom: string | null;
+}
+/**
+ * Structured Roman Matins (`tonus.matutinum`) for a feast: the nocturns with
+ * their responsories (and antiphons where present), assembled from the
+ * Nocturnale Romanum. Without a feast, resolves the default epoch's feast (as
+ * `officium` does). Only the Roman rite is served today; other rites return
+ * null (the monastic night office is not yet modelled — see office-matins-roman).
+ * @returns the Matins structure, or null when no Nocturnale match exists.
+ */
+export declare function getMatins(query?: OfficiumQuery): Matins | null;
+//# sourceMappingURL=matutinum.d.ts.map

package/dist/engines/chant/matutinum.js

@@ -0,0 +1,81 @@
+// ---------------------------------------------------------------------------
+// engines/chant/matutinum — structured Roman Matins (nocturns)
+// ---------------------------------------------------------------------------
+// The flat `officium({ hora: "matutinum" })` returns Matins chants as an
+// undifferentiated Chant[] (the best-effort flat view, unchanged). This module
+// adds the STRUCTURED night office for the Roman rite: the 3-nocturn assembly
+// from the Nocturnale Romanum, joined to the tonus calendar by feast id.
+//
+// It is additive and separate — a distinct accessor (`tonus.matutinum`), not a
+// reshape of getHour — so the flat path and every other rite stay as they are.
+// Coverage is what the Nocturnale + the calendar bridge give: the sanctorale and
+// Advent today (see office-matins-roman.ts). A feast with no Nocturnale match
+// returns null, the office's graceful-degradation convention.
+import { resolveChant } from "./chant.js";
+import { getFeast } from "../cal/calendar.js";
+import { temporaSundayId } from "../cal/date.js";
+import { MATINS_ROMAN } from "../../data/office-matins-roman.js";
+let _byFeast = null;
+function byFeast() {
+    if (!_byFeast) {
+        _byFeast = new Map();
+        for (const d of MATINS_ROMAN)
+            if (d.tonusFeastId)
+                _byFeast.set(d.tonusFeastId, d);
+    }
+    return _byFeast;
+}
+function resolveDay(day) {
+    const nocturns = day.nocturns.map((noc) => {
+        const responsories = [];
+        const antiphons = [];
+        for (const c of noc.chants) {
+            const chant = resolveChant(c.id);
+            if (!chant)
+                continue;
+            if (c.type === "A")
+                antiphons.push(chant);
+            else
+                responsories.push(chant); // R (and I invitatory) resolve as responsories
+        }
+        return { n: noc.n, responsories, antiphons };
+    });
+    return {
+        feastId: day.tonusFeastId,
+        name: day.name,
+        rank: day.rank,
+        nocturns,
+        redirectedFrom: day.redirectedFrom,
+    };
+}
+/** The Nocturnale Matins for a feast id, or null when the calendar has no match. */
+function matinsForFeastId(feastId) {
+    const map = byFeast();
+    const day = map.get(feastId) ?? (() => {
+        // Temporal feasts resolve their Sunday where a weekday has no proper.
+        const sunday = temporaSundayId(feastId);
+        return sunday ? map.get(sunday) : undefined;
+    })();
+    return day ? resolveDay(day) : null;
+}
+/**
+ * Structured Roman Matins (`tonus.matutinum`) for a feast: the nocturns with
+ * their responsories (and antiphons where present), assembled from the
+ * Nocturnale Romanum. Without a feast, resolves the default epoch's feast (as
+ * `officium` does). Only the Roman rite is served today; other rites return
+ * null (the monastic night office is not yet modelled — see office-matins-roman).
+ * @returns the Matins structure, or null when no Nocturnale match exists.
+ */
+export function getMatins(query) {
+    const rite = query?.rite ?? "romanum";
+    if (rite !== "romanum")
+        return null;
+    const feasts = query?.feast
+        ? Array.isArray(query.feast) ? query.feast : [query.feast]
+        : null;
+    const feast = feasts ? feasts[0] : getFeast()[0];
+    if (!feast)
+        return null;
+    return matinsForFeastId(feast.id);
+}
+//# sourceMappingURL=matutinum.js.map

package/dist/engines/chant/ordinary.js

@@ -1,7 +1,7 @@
 // ---------------------------------------------------------------------------
 // engines/chant/ordinary — Mass ordinary (kyriale) selection
 // ---------------------------------------------------------------------------
-import { MASSES, AD_LIB } from "../../data/masses.js";
+import { MASSES, AD_LIB } from "./data/masses.js";
 import { KYRIALE } from "../../data/kyriale.js";
 import { MODE_LABELS, ORDINARY_LABELS, } from "./types.js";
 import { gradeOrder, PENITENTIAL_SEASONS, } from "../cal/types.js";

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

@@ -1,5 +1,5 @@
-import { type OfficePsalmEntry, type OfficePsalmPortion } from "../../data/office-psalms.js";
-import { type Chant, type PsalmusQuery } from "./types.js";
+import { type OfficePsalmEntry, type OfficePsalmPortion } from "../../data/office-psalms-roman.js";
+import { type Chant, type PsalmusQuery, type Rite } from "./types.js";
 /**
  * Psalm and canticle retrieval (`tonus.psalmus`) from the Psalterium,
  * intoned to the psalm tones (modes 1-8 plus tonus peregrinus) as GABC.
@@ -16,9 +16,9 @@ export declare function getPsalmRange(psalm: number, lo: number, hi: number, mod
 export declare function intonePortion(p: OfficePsalmPortion, mode?: number): Chant[];
 /**
  * The little-hours psalmody for one hour on a given weekday (0 = Sunday), from
- * the extracted DO Tridentine scheme (`office-psalms.ts`). Prefers the
+ * the extracted DO Tridentine scheme (`office-psalms-roman.ts`). Prefers the
  * weekday-specific entry, then the ferial default (weekday null), then the
  * feast set; returns the psalm portions (not yet intoned).
  */
-export declare function officePsalmPortions(hour: OfficePsalmEntry["hour"], weekday: number): OfficePsalmPortion[];
+export declare function officePsalmPortions(hour: OfficePsalmEntry["hour"], weekday: number, rite?: Rite): OfficePsalmPortion[];
 //# sourceMappingURL=psalm.d.ts.map

package/dist/engines/chant/psalm.js

@@ -2,7 +2,8 @@
 // engines/chant/psalm — psalm and canticle retrieval as intoned Chant[]
 // ---------------------------------------------------------------------------
 import { PSALMS } from "../../data/psalms.js";
-import { OFFICE_PSALMS, } from "../../data/office-psalms.js";
+import { OFFICE_PSALMS, } from "../../data/office-psalms-roman.js";
+import { OFFICE_PSALMS_MONASTIC } from "../../data/office-psalms-monastic.js";
 import { intone } from "./intone.js";
 import { MODE_LABELS } from "./types.js";
 const CANTICLE_NAMES = {
@@ -82,12 +83,13 @@ export function intonePortion(p, mode = 8) {
 }
 /**
  * The little-hours psalmody for one hour on a given weekday (0 = Sunday), from
- * the extracted DO Tridentine scheme (`office-psalms.ts`). Prefers the
+ * the extracted DO Tridentine scheme (`office-psalms-roman.ts`). Prefers the
  * weekday-specific entry, then the ferial default (weekday null), then the
  * feast set; returns the psalm portions (not yet intoned).
  */
-export function officePsalmPortions(hour, weekday) {
-    const forHour = OFFICE_PSALMS.filter((e) => e.hour === hour);
+export function officePsalmPortions(hour, weekday, rite = "romanum") {
+    const scheme = rite === "monasticum" ? OFFICE_PSALMS_MONASTIC : OFFICE_PSALMS;
+    const forHour = scheme.filter((e) => e.hour === hour);
     const exact = forHour.find((e) => e.weekday === weekday && !e.festis);
     const ferial = forHour.find((e) => e.weekday === null && !e.festis);
     const festis = forHour.find((e) => e.festis);

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

@@ -2,7 +2,7 @@ import type { Season, Grade, Feast } from "../cal/types.js";
 export type { Season, Grade, Feast };
 export type OfficeCode = "an" | "al" | "ca" | "co" | "gr" | "hy" | "in" | "of" | "ps" | "re" | "rb" | "se" | "tr" | "tp" | "or";
 export type OrdinaryCode = "ky" | "gl" | "cr" | "sa" | "ag" | "be" | "it" | "as" | "va";
-export type ChantSource = "gr" | "lu" | "la" | "lh";
+export type ChantSource = "gr" | "lu" | "la" | "lh" | "am" | "nr";
 export type CanonicalHour = "matutinum" | "laudes" | "prima" | "tertia" | "sexta" | "nona" | "vesperae" | "completorium";
 export declare const MODE_LABELS: Readonly<Record<string, string>>;
 export declare const OFFICE_LABELS: Readonly<Record<OfficeCode, string>>;
@@ -22,8 +22,11 @@ export interface Chant {
     }[];
     source: {
         book: string;
+        fullTitle?: string | null;
+        edition?: string | null;
         year: number | null;
         editor: string | null;
+        scanSource?: string | null;
         code?: ChantSource | "user";
     };
     ordinary?: OrdinaryCode;
@@ -35,6 +38,35 @@ export interface OrdinaryChant extends Chant {
     ordinarium: string;
     mass: number;
 }
+export interface GenusCount {
+    office: OfficeCode;
+    genus: string;
+    count: number;
+}
+export interface ModeCount {
+    mode: string | null;
+    modus: string | null;
+    count: number;
+}
+export interface SharedCount {
+    code: ChantSource;
+    count: number;
+}
+export interface Corpus {
+    code: ChantSource;
+    book: string;
+    fullTitle: string | null;
+    edition: string | null;
+    year: number | null;
+    editor: string | null;
+    scanSource: string | null;
+    count: number;
+    total: number;
+    unique: number;
+    shared: SharedCount[];
+    genera: GenusCount[];
+    modes: ModeCount[];
+}
 export interface CantusQuery {
     id?: string | string[];
     gabc?: string;
@@ -54,9 +86,13 @@ export interface OrdinariumQuery extends CantusQuery {
     ordinary?: OrdinaryCode;
     mass?: number;
 }
+/** Which rite's Office to assemble. `romanum` (default) is the Tridentine Roman
+ *  cursus; `monasticum` is the Benedictine cursus (Antiphonale Monasticum). */
+export type Rite = "romanum" | "monasticum";
 export interface OfficiumQuery extends CantusQuery {
     feast?: Feast | Feast[];
     hora?: CanonicalHour;
+    rite?: Rite;
 }
 export interface PsalmusQuery {
     psalm?: number | string;