tonus 0.1.0 → 0.1.2

package/BIBLIOGRAPHY.md

@@ -17,6 +17,8 @@ section of the relevant page.
   [docs/chant.md](docs/chant.md#sources)
 - **Versus Psalmorum et Canticorum (Solesmes, No. 839)** — psalm-verse
   formulas → [docs/chant.md](docs/chant.md#sources)
+- **Bloomfield, _Compline_ (github.com/bbloomf/compline, public domain)**
+  — reference dates & chants for the traditional Roman Compline ordo → [docs/chant.md](docs/chant.md#sources)
 
 ## Chant rhythm (score engine)
 

package/dist/data/compline.d.ts

@@ -0,0 +1,38 @@
+import type { Season } from "../engines/cal/types.js";
+/** The invariable spine — chants sung the same every night. */
+export declare const COMPLINE_ORDINARY: {
+    /** Deus in adjutorium — the opening versicle. */
+    readonly opening: "gregobase:501";
+    /** Nunc dimittis — the gospel canticle. */
+    readonly canticle: "gregobase:1346";
+};
+/**
+ * Season → the seasonal Te lucis ante terminum (hymn) and In manus tuas
+ * (short responsory) chant ids. Feast-specific tones (Ascension, Sacred Heart,
+ * BVM octaves, …) are refinements deferred to a later pass; this maps the seven
+ * calendar seasons to their plain seasonal setting.
+ */
+export declare const COMPLINE_SEASONAL: Readonly<Record<Season, {
+    teLucis: string;
+    inManusTuas: string;
+}>>;
+/** The four seasonal Marian antiphons (simple tone). */
+export declare const MARIAN_ANTIPHONS: {
+    readonly alma: "gregobase:1851";
+    readonly ave: "gregobase:2153";
+    readonly reginaCaeli: "gregobase:2290";
+    readonly salve: "gregobase:2435";
+};
+/**
+ * The seasonal Marian antiphon, chosen by the traditional four-way rotation.
+ * The boundaries do not align with the calendar seasons — the Alma → Ave switch
+ * falls on Candlemas (2 February), mid-season — so this uses the feast's season
+ * for the broad divisions and its date for the Candlemas cut.
+ *
+ *   Advent 1 → 1 Feb        Alma Redemptoris Mater
+ *   2 Feb → Holy Wednesday  Ave Regina caelorum
+ *   Eastertide              Regina caeli
+ *   Pentecost → Advent      Salve Regina
+ */
+export declare function marianAntiphonFor(season: Season, date: Date): string;
+//# sourceMappingURL=compline.d.ts.map

package/dist/data/compline.js

@@ -0,0 +1,73 @@
+// data/compline — the Ordo of Compline (completorium)
+//
+// Compline in the traditional Roman rite is nearly invariable: the same spine
+// every night, varying only by liturgical season (the hymn Te lucis and the
+// short responsory In manus tuas) and by the seasonal Marian antiphon at the
+// end. This is an editorial ordo — it references chants already in the corpus
+// by their gregobase: id, it does not carry any GABC of its own (cf. masses.ts,
+// which is likewise a hand-authored profile table, not corpus-extracted).
+//
+// Ordo structure after the traditional Roman Compline; seasonal assignment and
+// the Marian rotation follow standard practice, cross-checked against
+// bbloomf/compline (public domain). See docs/chant.md and BIBLIOGRAPHY.md.
+// Compline's psalmody (Ps 4, 30 vv. 2–6, 90, 133) is not hand-listed here — it
+// comes from the extracted DO Tridentine scheme via
+// `officePsalmPortions("Completorium", …)`. Only the ordo structure and the
+// seasonal/Marian rules are editorial and live in this file.
+/** The invariable spine — chants sung the same every night. */
+export const COMPLINE_ORDINARY = {
+    /** Deus in adjutorium — the opening versicle. */
+    opening: "gregobase:501",
+    /** Nunc dimittis — the gospel canticle. */
+    canticle: "gregobase:1346",
+};
+/**
+ * Season → the seasonal Te lucis ante terminum (hymn) and In manus tuas
+ * (short responsory) chant ids. Feast-specific tones (Ascension, Sacred Heart,
+ * BVM octaves, …) are refinements deferred to a later pass; this maps the seven
+ * calendar seasons to their plain seasonal setting.
+ */
+export const COMPLINE_SEASONAL = Object.freeze({
+    adv: { teLucis: "gregobase:12752", inManusTuas: "gregobase:12702" }, // Advent
+    nat: { teLucis: "gregobase:12379", inManusTuas: "gregobase:13059" }, // Christmastide
+    epi: { teLucis: "gregobase:12897", inManusTuas: "gregobase:13059" }, // after Epiphany
+    quadp: { teLucis: "gregobase:12379", inManusTuas: "gregobase:13059" }, // Septuagesima
+    quad: { teLucis: "gregobase:12673", inManusTuas: "gregobase:13059" }, // Lent
+    pasc: { teLucis: "gregobase:12092", inManusTuas: "gregobase:12649" }, // Paschaltide
+    pent: { teLucis: "gregobase:12379", inManusTuas: "gregobase:13059" }, // after Pentecost
+});
+/** The four seasonal Marian antiphons (simple tone). */
+export const MARIAN_ANTIPHONS = {
+    alma: "gregobase:1851", // Alma Redemptoris Mater — Advent to Candlemas
+    ave: "gregobase:2153", // Ave Regina caelorum — Candlemas to Holy Week
+    reginaCaeli: "gregobase:2290", // Regina caeli — Eastertide
+    salve: "gregobase:2435", // Salve Regina — Trinity to Advent
+};
+/**
+ * The seasonal Marian antiphon, chosen by the traditional four-way rotation.
+ * The boundaries do not align with the calendar seasons — the Alma → Ave switch
+ * falls on Candlemas (2 February), mid-season — so this uses the feast's season
+ * for the broad divisions and its date for the Candlemas cut.
+ *
+ *   Advent 1 → 1 Feb        Alma Redemptoris Mater
+ *   2 Feb → Holy Wednesday  Ave Regina caelorum
+ *   Eastertide              Regina caeli
+ *   Pentecost → Advent      Salve Regina
+ */
+export function marianAntiphonFor(season, date) {
+    if (season === "pasc")
+        return MARIAN_ANTIPHONS.reginaCaeli;
+    if (season === "adv")
+        return MARIAN_ANTIPHONS.alma;
+    if (season === "pent")
+        return MARIAN_ANTIPHONS.salve;
+    // nat / epi / quadp / quad straddle Candlemas (2 February). Alma runs from
+    // Advent through 1 February — so Christmastide and any date before Candlemas
+    // (December or January) is still Alma; 2 February onward is Ave, on through
+    // Holy Week (the tail of `quad`, before Paschaltide takes over).
+    const month = date.getUTCMonth(); // 0 = Jan, 11 = Dec
+    const beforeCandlemas = month === 11 || month === 0 ||
+        (month === 1 && date.getUTCDate() < 2);
+    return beforeCandlemas ? MARIAN_ANTIPHONS.alma : MARIAN_ANTIPHONS.ave;
+}
+//# sourceMappingURL=compline.js.map

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

@@ -0,0 +1,15 @@
+export interface OfficePsalmPortion {
+    psalm: number;
+    from?: number;
+    to?: number;
+}
+export interface OfficePsalmEntry {
+    hour: "Prima" | "Tertia" | "Sexta" | "Nona" | "Completorium";
+    /** 0–6 (0 = Sunday); null for the feast set or hours with no weekday split. */
+    weekday: number | null;
+    /** True for the feast (Festis) psalmody. */
+    festis: boolean;
+    psalms: OfficePsalmPortion[];
+}
+export declare const OFFICE_PSALMS: OfficePsalmEntry[];
+//# sourceMappingURL=office-psalms.d.ts.map

package/dist/data/office-psalms.js

@@ -0,0 +1,28 @@
+// office-psalms.ts — 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
+// Entries: 15
+//
+// The traditional (pre-1911) Roman little-hours psalm distribution. Each entry
+// gives the psalm portions for one hour on one weekday (0 = Sunday), or the
+// feast set (festis: true, weekday: null). A portion is a whole psalm or an
+// inclusive verse range.
+export const OFFICE_PSALMS = [
+    { hour: "Prima", weekday: 0, festis: false, psalms: [{ psalm: 53 }, { psalm: 117 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 1, festis: false, psalms: [{ psalm: 53 }, { psalm: 23 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 2, festis: false, psalms: [{ psalm: 53 }, { psalm: 24 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 3, festis: false, psalms: [{ psalm: 53 }, { psalm: 25 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 4, festis: false, psalms: [{ psalm: 53 }, { psalm: 22 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 5, festis: false, psalms: [{ psalm: 53 }, { psalm: 21 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: 6, festis: false, psalms: [{ psalm: 53 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Prima", weekday: null, festis: true, psalms: [{ psalm: 53 }, { psalm: 118, from: 1, to: 16 }, { psalm: 118, from: 17, to: 32 }] },
+    { hour: "Tertia", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 33, to: 48 }, { psalm: 118, from: 49, to: 64 }, { psalm: 118, from: 65, to: 80 }] },
+    { hour: "Tertia", weekday: null, festis: false, psalms: [{ psalm: 118, from: 33, to: 48 }, { psalm: 118, from: 49, to: 64 }, { psalm: 118, from: 65, to: 80 }] },
+    { hour: "Sexta", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 81, to: 96 }, { psalm: 118, from: 97, to: 112 }, { psalm: 118, from: 113, to: 128 }] },
+    { hour: "Sexta", weekday: null, festis: false, psalms: [{ psalm: 118, from: 81, to: 96 }, { psalm: 118, from: 97, to: 112 }, { psalm: 118, from: 113, to: 128 }] },
+    { hour: "Nona", weekday: 0, festis: false, psalms: [{ psalm: 118, from: 129, to: 144 }, { psalm: 118, from: 145, to: 160 }, { psalm: 118, from: 161, to: 176 }] },
+    { 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

package/dist/data/prime.d.ts

@@ -0,0 +1,20 @@
+import type { Season } from "../engines/cal/types.js";
+/** The invariable spine. */
+export declare const PRIME_ORDINARY: {
+    /** Deus in adjutorium — the opening versicle. */
+    readonly opening: "gregobase:501";
+    /**
+     * Iam lucis orto sidere — Prime's hymn. Its variants are keyed by feast rank
+     * (ferial / Sunday / major feast) rather than by season; the ferial-and-
+     * simple-feast tone is the everyday default.
+     */
+    readonly hymn: "gregobase:11944";
+};
+/**
+ * Season → the seasonal short responsory Christe Fili Dei vivi. Only Advent and
+ * Paschaltide have their own setting; the rest of the year uses "per Annum."
+ */
+export declare const PRIME_SEASONAL: Readonly<Record<Season, {
+    responsory: string;
+}>>;
+//# sourceMappingURL=prime.d.ts.map

package/dist/data/prime.js

@@ -0,0 +1,42 @@
+// data/prime — the Ordo of Prime (prima)
+//
+// Prime, the "first hour," is like Compline mostly fixed and seasonal rather
+// than per-feast. This ordo covers Prime's SUNG parts: the opening, the hymn
+// Iam lucis orto sidere, the fixed psalmody, and the seasonal short responsory
+// Christe Fili Dei vivi. Prime's recited/monotoned parts — the Athanasian Creed
+// (Quicumque vult), the martyrology, the chapter, and the collect — are not
+// 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
+// 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,
+// varying by weekday per DO's Tridentine scheme) is not hand-listed here — it
+// comes from the extracted scheme via `officePsalmPortions("Prima", weekday)`.
+// Only the ordo structure and the seasonal responsory rule are editorial.
+/** The invariable spine. */
+export const PRIME_ORDINARY = {
+    /** Deus in adjutorium — the opening versicle. */
+    opening: "gregobase:501",
+    /**
+     * Iam lucis orto sidere — Prime's hymn. Its variants are keyed by feast rank
+     * (ferial / Sunday / major feast) rather than by season; the ferial-and-
+     * simple-feast tone is the everyday default.
+     */
+    hymn: "gregobase:11944",
+};
+/**
+ * Season → the seasonal short responsory Christe Fili Dei vivi. Only Advent and
+ * Paschaltide have their own setting; the rest of the year uses "per Annum."
+ */
+export const PRIME_SEASONAL = Object.freeze({
+    adv: { responsory: "gregobase:13127" }, // Tempore Adventus
+    nat: { responsory: "gregobase:11818" }, // per Annum
+    epi: { responsory: "gregobase:11818" },
+    quadp: { responsory: "gregobase:11818" },
+    quad: { responsory: "gregobase:11818" },
+    pasc: { responsory: "gregobase:12439" }, // Tempore Paschali
+    pent: { responsory: "gregobase:11818" },
+});
+//# sourceMappingURL=prime.js.map

package/dist/engines/chant/hour.js

@@ -2,15 +2,82 @@
 // engines/chant/hour — Divine Office hour retrieval
 // ---------------------------------------------------------------------------
 import { resolveChant, resolveChants } from "./chant.js";
+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";
 let _roman = null;
 function romanMap() {
     if (!_roman)
         _roman = new Map(OFFICE_ROMAN.map((d) => [d.feastId, d]));
     return _roman;
 }
+// Hours whose result is an ordered sequence (an ordo) rather than a set of
+// chants — they keep assembly order instead of being sorted by incipit.
+const ORDERED_ORDO_HOURS = new Set([
+    "prima", "tertia", "sexta", "nona", "completorium",
+]);
+// The purely seasonal/fixed hours — identical for every feast of a day, so
+// concurrent feasts collapse to one and a no-feast query resolves the default
+// epoch. (Terce/Sext/None are NOT here: their responsory breve is per-feast.)
+const SEASONAL_ORDO_HOURS = new Set([
+    "prima", "completorium",
+]);
+// Compline is fixed and seasonal, not per-feast: it does not use the OfficeDay
+// 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) {
+    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)) {
+        results.push(...intonePortion(p));
+    }
+    const hymn = seasonal && resolveChant(seasonal.teLucis);
+    if (hymn)
+        results.push(hymn);
+    const responsory = seasonal && resolveChant(seasonal.inManusTuas);
+    if (responsory)
+        results.push(responsory);
+    const canticle = resolveChant(COMPLINE_ORDINARY.canticle);
+    if (canticle)
+        results.push(canticle);
+    const marian = resolveChant(marianAntiphonFor(feast.season, feast.date));
+    if (marian)
+        results.push(marian);
+    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
+// lucis, and the seasonal short responsory Christe Fili Dei.
+function primeForFeast(feast) {
+    const seasonal = PRIME_SEASONAL[feast.season];
+    const results = [];
+    const opening = resolveChant(PRIME_ORDINARY.opening);
+    if (opening)
+        results.push(opening);
+    const hymn = resolveChant(PRIME_ORDINARY.hymn);
+    if (hymn)
+        results.push(hymn);
+    for (const p of officePsalmPortions("Prima", feast.weekday)) {
+        results.push(...intonePortion(p));
+    }
+    const responsory = seasonal && resolveChant(seasonal.responsory);
+    if (responsory)
+        results.push(responsory);
+    return results;
+}
 function chantsForFeastHour(feast, hour) {
+    if (hour === "completorium")
+        return complineForFeast(feast);
+    if (hour === "prima")
+        return primeForFeast(feast);
     const map = romanMap();
     const sunday = temporaSundayId(feast.id);
     const day = map.get(feast.id) ?? (sunday ? (map.get(sunday) ?? null) : null);
@@ -36,18 +103,21 @@ function chantsForFeastHour(feast, hour) {
         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);
+    else if (hour === "tertia" || hour === "sexta" || hour === "nona") {
+        // The little hours: their portion of Ps 118 (Terce vv. 33–80, Sext 81–128,
+        // None 129–176, from the extracted DO scheme), then the responsory breve.
+        // The psalmody belongs to a specific day, so it is only included for a real
+        // feast query — not the all-days survey scan (which has no date and would
+        // 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)) {
+                results.push(...intonePortion(p));
+            }
+        }
+        const rb = resolveChant(hour === "tertia" ? day.respBreveTertia
+            : hour === "sexta" ? day.respBreveSexta
+                : day.respBreveNona);
         if (rb)
             results.push(rb);
     }
@@ -79,14 +149,29 @@ export function getHour(query) {
     const hour = query.hora;
     let results;
     if (feasts && hour) {
-        results = feasts.flatMap((f) => chantsForFeastHour(f, 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));
     }
     else if (feasts) {
-        const hours = ["matutinum", "laudes", "tertia", "sexta", "nona", "vesperae"];
+        const hours = [
+            "matutinum", "laudes", "prima", "tertia", "sexta", "nona",
+            "vesperae", "completorium",
+        ];
         results = feasts.flatMap((f) => hours.flatMap((h) => chantsForFeastHour(f, h)));
     }
+    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) : [];
+    }
     else if (hour) {
-        // Hour without feast — scan all office entries
+        // 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) => {
             const mockFeast = { id: day.feastId };
             return chantsForFeastHour(mockFeast, hour);
@@ -119,15 +204,21 @@ export function getHour(query) {
         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);
-    });
+    // The little hours and Compline are ordered ordos — their sequence IS the
+    // content — so they keep assembly order unless the caller explicitly asks for
+    // a sort. The other hours return a set of chants, sorted by incipit.
+    const isOrderedOrdo = query.hora != null && ORDERED_ORDO_HOURS.has(query.hora);
+    if (query.sort || !isOrderedOrdo) {
+        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);

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

@@ -1,7 +1,24 @@
+import { type OfficePsalmEntry, type OfficePsalmPortion } from "../../data/office-psalms.js";
 import { type Chant, type PsalmusQuery } 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.
  */
 export declare function getPsalm(query?: PsalmusQuery): Chant[];
+/**
+ * A contiguous verse range of one psalm, intoned — e.g. `getPsalmRange(30, 2, 6)`
+ * for Ps 30, verses 2–6. Used by the fixed office ordos (Prime, Compline), whose
+ * psalmody takes only a portion of a psalm (Ps 30:2-6; Ps 118 in sections).
+ * `lo`/`hi` are inclusive verse numbers; split verses (3a/3b) are both included.
+ */
+export declare function getPsalmRange(psalm: number, lo: number, hi: number, mode?: number): Chant[];
+/** A psalm portion — whole psalm or an inclusive verse range — intoned. */
+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
+ * 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[];
 //# sourceMappingURL=psalm.d.ts.map

package/dist/engines/chant/psalm.js

@@ -2,6 +2,7 @@
 // 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 { intone } from "./intone.js";
 import { MODE_LABELS } from "./types.js";
 const CANTICLE_NAMES = {
@@ -57,4 +58,39 @@ export function getPsalm(query) {
     const mode = query.mode ?? 8;
     return verses.map((v) => verseToChant(v, mode, query.differentia, query.intonatio));
 }
+/**
+ * A contiguous verse range of one psalm, intoned — e.g. `getPsalmRange(30, 2, 6)`
+ * for Ps 30, verses 2–6. Used by the fixed office ordos (Prime, Compline), whose
+ * psalmody takes only a portion of a psalm (Ps 30:2-6; Ps 118 in sections).
+ * `lo`/`hi` are inclusive verse numbers; split verses (3a/3b) are both included.
+ */
+export function getPsalmRange(psalm, lo, hi, mode = 8) {
+    return PSALMS
+        .filter((v) => {
+        if (v.psalm !== psalm)
+            return false;
+        const n = parseInt(v.verse, 10);
+        return !isNaN(n) && n >= lo && n <= hi;
+    })
+        .map((v) => verseToChant(v, mode));
+}
+/** A psalm portion — whole psalm or an inclusive verse range — intoned. */
+export function intonePortion(p, mode = 8) {
+    return p.from != null && p.to != null
+        ? getPsalmRange(p.psalm, p.from, p.to, mode)
+        : getPsalm({ psalm: p.psalm, mode });
+}
+/**
+ * The little-hours psalmody for one hour on a given weekday (0 = Sunday), from
+ * the extracted DO Tridentine scheme (`office-psalms.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);
+    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);
+    return (exact ?? ferial ?? festis)?.psalms ?? [];
+}
 //# sourceMappingURL=psalm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tonus",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "description": "Medieval music analysis and performance: GABC plainchant exports, liturgical calendar, tuning systems, ephemeris, and the harmony of the spheres",