tonus 0.1.0

package/dist/data/tones.d.ts

@@ -0,0 +1,20 @@
+export interface Differentia {
+    code: string;
+    termination: number[];
+}
+export interface PsalmTone {
+    mode: number;
+    name: string;
+    tenor: number;
+    intonation: number[];
+    flex: number[];
+    mediant: number[];
+    defaultDiff: string;
+    differentiae: Differentia[];
+}
+export declare const TONES: PsalmTone[];
+/** Look up a PsalmTone by mode number (1–8, or 0 for Peregrinus) */
+export declare function getTone(mode: number): PsalmTone;
+/** Look up a differentia by code, falling back to the tone's defaultDiff */
+export declare function getDifferentia(tone: PsalmTone, code?: string): Differentia;
+//# sourceMappingURL=tones.d.ts.map

package/dist/data/tones.js

@@ -0,0 +1,153 @@
+// humana/data/tones — psalm tones (Graduale Romanum appendix)
+// Pitches as MIDI numbers; tone codes follow DO convention: "1g", "6F", "4e".
+// c4 clef reference: f=53 g=55 h=57 i=59 j=60 k=62 l=64 (F3–F4)
+const f = 53, g = 55, h = 57, i = 59, j = 60, k = 62, l = 64;
+const d3 = 50, e3 = 52; // below c4 clef range, needed for Tone II
+export const TONES = [
+    {
+        mode: 1,
+        name: "Tonus I",
+        tenor: h, // A3
+        intonation: [f, h, j], // F-A-C
+        flex: [h, g], // A-G
+        mediant: [j, h, g, h], // C-A-G-A
+        defaultDiff: "1g",
+        differentiae: [
+            { code: "1g", termination: [j, h, g, h, g] }, // standard
+            { code: "1g2", termination: [j, h, j, h, g] }, // alt
+            { code: "1f", termination: [j, i, h, f] },
+            { code: "1D", termination: [h, g, f, f] }, // ending D
+            { code: "1a", termination: [j, k, j, h] }, // high ending
+        ],
+    },
+    {
+        mode: 2,
+        name: "Tonus II",
+        tenor: f, // F3
+        intonation: [d3, f], // D3-F3
+        flex: [f, e3], // F-E
+        mediant: [g, f, e3, f], // G-F-E-F
+        defaultDiff: "2D",
+        differentiae: [
+            { code: "2D", termination: [g, f, e3, d3] }, // ending D
+            { code: "2d", termination: [g, f, e3, d3] }, // same
+            { code: "2e", termination: [g, f, g, e3] },
+            { code: "2f", termination: [g, f, f] },
+        ],
+    },
+    {
+        mode: 3,
+        name: "Tonus III",
+        tenor: i, // B3
+        intonation: [g, i, j], // G-B-C
+        flex: [i, h], // B-A
+        mediant: [k, i, j, i], // D-B-C-B
+        defaultDiff: "3b",
+        differentiae: [
+            { code: "3b", termination: [j, i, h, i] },
+            { code: "3a", termination: [k, j, i, h, i] },
+            { code: "3g", termination: [j, i, h, g] },
+        ],
+    },
+    {
+        mode: 4,
+        name: "Tonus IV",
+        tenor: h, // A3
+        intonation: [f, g, h], // F-G-A
+        flex: [h, f], // A-F
+        mediant: [j, i, h], // C-B-A
+        defaultDiff: "4e",
+        differentiae: [
+            { code: "4e", termination: [h, g, h, f, e3] }, // ending E (standard)
+            { code: "4g", termination: [h, g, f, g] },
+            { code: "4A", termination: [h, i, h, f] },
+            { code: "4a", termination: [i, h, g, h] },
+        ],
+    },
+    {
+        mode: 5,
+        name: "Tonus V",
+        tenor: j, // C4
+        intonation: [h, j], // A-C
+        flex: [j, i], // C-B
+        mediant: [l, k, j], // E-D-C
+        defaultDiff: "5a",
+        differentiae: [
+            { code: "5a", termination: [l, k, j, j] }, // ending F
+            { code: "5f", termination: [k, j, i, j] },
+            { code: "5F", termination: [k, j, h, j] },
+        ],
+    },
+    {
+        mode: 6,
+        name: "Tonus VI",
+        tenor: f, // F3
+        intonation: [d3, e3, f], // D-E-F
+        flex: [f, e3], // F-E
+        mediant: [g, f, e3, f], // G-F-E-F
+        defaultDiff: "6F",
+        differentiae: [
+            { code: "6F", termination: [g, h, g, f] }, // standard ending F
+            { code: "6f", termination: [g, f, e3, f] },
+            { code: "6g", termination: [g, f, g] },
+        ],
+    },
+    {
+        mode: 7,
+        name: "Tonus VII",
+        tenor: j, // C4
+        intonation: [h, i, j], // A-B-C
+        flex: [j, i], // C-B
+        mediant: [k, j, i, j], // D-C-B-C
+        defaultDiff: "7a",
+        differentiae: [
+            { code: "7a", termination: [k, j, i, j] }, // ending G-area
+            { code: "7c", termination: [l, k, j, k, j] },
+            { code: "7b", termination: [l, k, i, j] },
+            { code: "7d", termination: [k, j, h, j] },
+        ],
+    },
+    {
+        mode: 8,
+        name: "Tonus VIII",
+        tenor: j, // C4
+        intonation: [h, j], // A-C
+        flex: [j, h], // C-A
+        mediant: [k, j], // D-C
+        defaultDiff: "8G",
+        differentiae: [
+            { code: "8G", termination: [k, j, h, j] }, // standard ending G
+            { code: "8g", termination: [k, j, i, j] },
+            { code: "8c", termination: [l, k, j, i, j] },
+            { code: "8G2", termination: [k, j, h, g, j] },
+        ],
+    },
+    // ── Tonus Peregrinus ── irregular: two different tenors
+    {
+        mode: 0,
+        name: "Tonus Peregrinus",
+        tenor: j, // C4 (first half tenor)
+        intonation: [h, i, j], // A-B-C
+        flex: [j, i],
+        mediant: [k, i, h, j], // D-B-A-C (descends to A then rises)
+        defaultDiff: "per",
+        differentiae: [
+            { code: "per", termination: [i, h, g, h] }, // second half on A
+        ],
+    },
+];
+/** Look up a PsalmTone by mode number (1–8, or 0 for Peregrinus) */
+export function getTone(mode) {
+    return TONES.find(t => t.mode === mode) ?? TONES.find(t => t.mode === 8);
+}
+/** Look up a differentia by code, falling back to the tone's defaultDiff */
+export function getDifferentia(tone, code) {
+    if (code) {
+        const d = tone.differentiae.find(d => d.code === code);
+        if (d)
+            return d;
+    }
+    return tone.differentiae.find(d => d.code === tone.defaultDiff)
+        ?? tone.differentiae[0];
+}
+//# sourceMappingURL=tones.js.map

package/dist/data/types.d.ts

@@ -0,0 +1,3 @@
+export type { Chant } from "../engines/chant/types.js";
+export type { PsalmVerse } from "../engines/chant/types.js";
+//# sourceMappingURL=types.d.ts.map

package/dist/data/types.js

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

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

@@ -0,0 +1,21 @@
+import { type CalEntry } from "../../data/cal.js";
+import { type RuleAnchors } from "./date.js";
+import { type Feast, type FeastQuery, type Pascha } from "./types.js";
+export declare function getAnchors(year: number): RuleAnchors;
+/**
+ * The movable anchors of a liturgical year (`tonus.pascha`). Easter is
+ * computed by the Gregorian (Gauss/Butcher) computus from 1583 and by the
+ * Julian computus with day-number conversion before that; everything else
+ * anchors to it, except Advent, which anchors to November 27.
+ */
+export declare function getPascha(year: number): Pascha;
+export declare function buildCalendar(year: number): Map<string, CalEntry[]>;
+/**
+ * Calendar lookup (`tonus.festum`). Returns matching feasts sorted
+ * `day asc, rank desc` — for a date, the primary feast plus concurrent
+ * feasts; for a `from`/`to` range, every day flattened; with no query,
+ * the current liturgical year. Dates are UTC-canonical: build them from
+ * ISO strings or `Date.UTC`.
+ */
+export declare function getFeast(query?: FeastQuery): Feast[];
+//# sourceMappingURL=calendar.d.ts.map

package/dist/engines/cal/calendar.js

@@ -0,0 +1,265 @@
+// ---------------------------------------------------------------------------
+// engines/cal/calendar — liturgical feast lookup
+// ---------------------------------------------------------------------------
+import { CAL } from "../../data/cal.js";
+import { MASSES } from "../../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();
+const _anchorCache = new Map();
+// Preferred mass order; ad libitum (mass 0) is handled separately in ordinary.ts.
+const DEFAULT_MASSES = [
+    8, 9, 11, 1, 2, 3, 4, 5, 6, 7, 10, 12, 13, 14, 15, 16, 17, 18,
+];
+export function getAnchors(year) {
+    if (_anchorCache.has(year))
+        return _anchorCache.get(year);
+    const easter = startOfDay(pascha(year));
+    const advent1 = firstSundayOnOrAfter(new Date(Date.UTC(year, 10, 27)));
+    const anchors = {
+        year,
+        easter,
+        ashWednesday: subDays(easter, 46),
+        firstLentSunday: addDays(subDays(easter, 46), 4),
+        septuagesima: subDays(easter, 63),
+        pentecost: addDays(easter, 49),
+        ascension: addDays(easter, 39),
+        adventFirstSunday: advent1,
+        gaudete: addDays(advent1, 14),
+        christmas: new Date(Date.UTC(year, 11, 25)),
+        epiphany: new Date(Date.UTC(year, 0, 6)),
+        baptism: nextSunday(new Date(Date.UTC(year, 0, 7))),
+    };
+    _anchorCache.set(year, anchors);
+    return anchors;
+}
+/**
+ * The movable anchors of a liturgical year (`tonus.pascha`). Easter is
+ * computed by the Gregorian (Gauss/Butcher) computus from 1583 and by the
+ * Julian computus with day-number conversion before that; everything else
+ * anchors to it, except Advent, which anchors to November 27.
+ */
+export function getPascha(year) {
+    if (!Number.isFinite(year)) {
+        throw new RangeError(`pascha requires a finite year, got ${year}`);
+    }
+    const a = getAnchors(Math.trunc(year));
+    const d = (x) => new Date(x.getTime());
+    return {
+        year: Math.trunc(year),
+        septuagesima: d(a.septuagesima),
+        ashWednesday: d(a.ashWednesday),
+        firstLentSunday: d(a.firstLentSunday),
+        palmSunday: subDays(a.easter, 7),
+        goodFriday: subDays(a.easter, 2),
+        easter: d(a.easter),
+        ascension: d(a.ascension),
+        pentecost: d(a.pentecost),
+        trinitySunday: addDays(a.pentecost, 7),
+        corpusChristi: addDays(a.pentecost, 11),
+        adventFirstSunday: d(a.adventFirstSunday),
+        gaudete: d(a.gaudete),
+        christmas: d(a.christmas),
+        epiphany: d(a.epiphany),
+        baptism: d(a.baptism),
+    };
+}
+export function buildCalendar(year) {
+    if (_calCache.has(year))
+        return _calCache.get(year);
+    const anchors = getAnchors(year);
+    const map = new Map();
+    for (const entry of CAL) {
+        for (const { key } of resolveEntryId(entry.id, year, anchors)) {
+            if (!map.has(key))
+                map.set(key, []);
+            map.get(key).push(entry);
+        }
+    }
+    // Lower rank number means higher priority.
+    for (const list of map.values())
+        list.sort((a, b) => entryGradeOrder(a) - entryGradeOrder(b));
+    _calCache.set(year, map);
+    return map;
+}
+// Season boundaries follow the Divinum Officium Tempora stems exactly, so a
+// date's season always matches the stem of any Tempora feast that falls on it
+// (asserted by the stem↔season test):
+//   adv   Advent I Sunday          → Christmas (Dec 25)
+//   nat   Christmas                → epiphanySunday (1st Sun after Epiphany)
+//   epi   epiphanySunday           → Septuagesima (Easter − 63)
+//   quadp Septuagesima Sunday      → Ash Wednesday (Easter − 46)
+//   quad  Ash Wednesday            → Easter
+//   pasc  Easter                   → trinitySunday (Pentecost + 7); the
+//                                     Pentecost octave stays paschal
+//   pent  trinitySunday            → next Advent I Sunday
+// Epi and Nat both anchor on firstSundayOnOrAfter(feast+1) in
+// resolveTemporaStem; epiphanySunday is that boundary between them.
+function epiphanySunday(a) {
+    return firstSundayOnOrAfter(addDays(a.epiphany, 1));
+}
+function trinitySunday(a) {
+    return addDays(a.pentecost, 7);
+}
+function findSeason(date) {
+    const year = date.getUTCFullYear();
+    const a = getAnchors(year);
+    const prev = getAnchors(year - 1);
+    const next = getAnchors(year + 1);
+    const s = (code, start, end) => ({
+        code,
+        start: startOfDay(start),
+        end: startOfDay(end),
+    });
+    if (date >= next.adventFirstSunday && date < next.christmas)
+        return s("adv", next.adventFirstSunday, next.christmas);
+    if (date >= a.adventFirstSunday && date < a.christmas)
+        return s("adv", a.adventFirstSunday, a.christmas);
+    if (date >= prev.christmas && date < epiphanySunday(a))
+        return s("nat", prev.christmas, epiphanySunday(a));
+    if (date >= a.christmas && date < epiphanySunday(next))
+        return s("nat", a.christmas, epiphanySunday(next));
+    if (date >= epiphanySunday(a) && date < a.septuagesima)
+        return s("epi", epiphanySunday(a), a.septuagesima);
+    if (date >= a.septuagesima && date < a.ashWednesday)
+        return s("quadp", a.septuagesima, a.ashWednesday);
+    if (date >= a.ashWednesday && date < a.easter)
+        return s("quad", a.ashWednesday, a.easter);
+    if (date >= a.easter && date < trinitySunday(a))
+        return s("pasc", a.easter, trinitySunday(a));
+    if (date >= trinitySunday(a) && date < next.adventFirstSunday)
+        return s("pent", trinitySunday(a), next.adventFirstSunday);
+    return s("epi", epiphanySunday(a), a.septuagesima);
+}
+function selectMasses(id, grade, season, date) {
+    const dowCode = date.getUTCDay() === 0 ? "dominica" : "feria";
+    const requireBvm = BVM_FEAST_IDS.has(id);
+    const matches = [];
+    for (const num of DEFAULT_MASSES) {
+        const mass = MASSES.get(num);
+        if (!mass)
+            continue;
+        if (requireBvm !== mass.bvm)
+            continue;
+        if (!mass.seasons.includes(season))
+            continue;
+        if (!mass.grades.includes(grade))
+            continue;
+        if (!mass.days.includes(dowCode))
+            continue;
+        matches.push(num);
+    }
+    return matches;
+}
+function calEntryToFeast(entry, season, d) {
+    const id = entry.id ?? "";
+    // All 642 entries carry a ritus; "Feria" is a defensive floor only.
+    const ritus = entry.ritus ?? "Feria";
+    const grade = entryGrade(id, ritus);
+    return {
+        id,
+        nomen: entry.name,
+        ritus,
+        grade,
+        season: season.code,
+        tempus: TEMPUS_NAMES[season.code],
+        seasonStart: season.start,
+        seasonEnd: season.end,
+        date: d,
+        weekday: d.getUTCDay(),
+        masses: selectMasses(id, grade, season.code, d),
+        marian: BVM_FEAST_IDS.has(id),
+        apostolic: APOSTOLIC_FEAST_IDS.has(id),
+    };
+}
+// Precedence order of a raw CalEntry (for same-day sorting before conversion).
+function entryGradeOrder(entry) {
+    return gradeOrder(entryGrade(entry.id, entry.ritus ?? "Feria"));
+}
+function feastsForDate(date) {
+    const d = startOfDay(date);
+    const key = isoDate(d);
+    const year = d.getUTCFullYear();
+    // Tempora anchored in the previous year can spill into January (e.g.
+    // Nat2-0, the Sunday of the Holy Name), so the prior year's calendar is
+    // consulted too.
+    const entries = [
+        ...(buildCalendar(year).get(key) ?? []),
+        ...(buildCalendar(year - 1).get(key) ?? []),
+    ];
+    if (!entries.length)
+        return [];
+    entries.sort((a, b) => entryGradeOrder(a) - entryGradeOrder(b));
+    const season = findSeason(d);
+    return entries.map((e) => calEntryToFeast(e, season, d));
+}
+/**
+ * Calendar lookup (`tonus.festum`). Returns matching feasts sorted
+ * `day asc, rank desc` — for a date, the primary feast plus concurrent
+ * feasts; for a `from`/`to` range, every day flattened; with no query,
+ * the current liturgical year. Dates are UTC-canonical: build them from
+ * ISO strings or `Date.UTC`.
+ */
+export function getFeast(query) {
+    if (!query || Object.keys(query).length === 0) {
+        return feastsForDate(DEFAULT_EPOCH);
+    }
+    let results;
+    if (query.date) {
+        results = feastsForDate(query.date);
+    }
+    else if (query.from != null || query.to != null) {
+        if (query.from == null || query.to == null) {
+            throw new RangeError("festum range requires both from and to");
+        }
+        if (query.to.getTime() < query.from.getTime()) {
+            throw new RangeError("festum range: to must be >= from");
+        }
+        results = [];
+        let d = startOfDay(query.from);
+        const end = startOfDay(query.to);
+        while (d <= end) {
+            results.push(...feastsForDate(d));
+            d = addDays(d, 1);
+        }
+    }
+    else {
+        // Full calendar scan for the default liturgical year range (the year
+        // containing DEFAULT_EPOCH — Guido d'Arezzo's era). The liturgical year
+        // begins at Advent, so before Advent the range anchors to the previous
+        // civil year's first Advent Sunday.
+        const today = startOfDay(DEFAULT_EPOCH);
+        let year = today.getUTCFullYear();
+        if (today < getAnchors(year).adventFirstSunday)
+            year -= 1;
+        const startDate = getAnchors(year).adventFirstSunday;
+        const endDate = getAnchors(year + 1).adventFirstSunday;
+        results = [];
+        let d = startDate;
+        while (d < endDate) {
+            results.push(...feastsForDate(d));
+            d = addDays(d, 1);
+        }
+    }
+    if (query.nomen) {
+        const n = query.nomen.toLowerCase();
+        results = results.filter((f) => f.nomen.toLowerCase().includes(n));
+    }
+    if (query.season) {
+        results = results.filter((f) => f.season === query.season);
+    }
+    if (query.grade !== undefined) {
+        results = results.filter((f) => f.grade === query.grade);
+    }
+    if (query.marian !== undefined) {
+        results = results.filter((f) => f.marian === query.marian);
+    }
+    if (query.apostolic !== undefined) {
+        results = results.filter((f) => f.apostolic === query.apostolic);
+    }
+    // Sort: day asc, rank desc (lower rank number = higher priority, so asc)
+    results.sort((a, b) => a.date.getTime() - b.date.getTime() ||
+        gradeOrder(a.grade) - gradeOrder(b.grade));
+    return results;
+}
+//# sourceMappingURL=calendar.js.map

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

@@ -0,0 +1,31 @@
+export interface RuleAnchors {
+    year: number;
+    easter: Date;
+    ashWednesday: Date;
+    firstLentSunday: Date;
+    septuagesima: Date;
+    pentecost: Date;
+    ascension: Date;
+    adventFirstSunday: Date;
+    gaudete: Date;
+    christmas: Date;
+    epiphany: Date;
+    baptism: Date;
+}
+export { DEFAULT_EPOCH } from "../epoch.js";
+export declare function isoDate(date: Date): string;
+export declare function startOfDay(date: Date): Date;
+export declare function addDays(date: Date, days: number): Date;
+export declare function subDays(date: Date, days: number): Date;
+export declare function firstSundayOnOrAfter(date: Date): Date;
+export declare function nextSunday(date: Date): Date;
+export declare function parseMonthDay(year: number, mmdd: string): Date;
+export declare function pascha(year: number): Date;
+export interface Placement {
+    date: Date;
+    key: string;
+}
+export declare function resolveEntryId(id: string, year: number, anchors: RuleAnchors): Placement[];
+/** For a tempora weekday ID like "Adv1-3", return the Sunday "Adv1-0". Null for non-tempora or already a Sunday. */
+export declare function temporaSundayId(id: string): string | null;
+//# sourceMappingURL=date.d.ts.map

package/dist/engines/cal/date.js

@@ -0,0 +1,141 @@
+// ---------------------------------------------------------------------------
+// engines/cal/date — date math, computus, and liturgical calendar rule resolution
+// ---------------------------------------------------------------------------
+// Re-exported for cal consumers; the canonical definition and rationale live
+// in engines/epoch (it is shared with the planet engine).
+export { DEFAULT_EPOCH } from "../epoch.js";
+// ── Date math ──
+export function isoDate(date) {
+    return date.toISOString().slice(0, 10);
+}
+export function startOfDay(date) {
+    // Canonical form is UTC midnight, so dates from ISO strings like
+    // new Date("2025-12-25") behave identically in every timezone.
+    const y = date.getUTCFullYear(), m = date.getUTCMonth(), d = date.getUTCDate();
+    return new Date(Date.UTC(y, m, d));
+}
+export function addDays(date, days) {
+    const d = new Date(date);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d;
+}
+export function subDays(date, days) {
+    return addDays(date, -days);
+}
+export function firstSundayOnOrAfter(date) {
+    const d = startOfDay(date);
+    return addDays(d, (7 - d.getUTCDay()) % 7);
+}
+export function nextSunday(date) {
+    const d = startOfDay(date);
+    return addDays(d, (7 - d.getUTCDay()) % 7 || 7);
+}
+export function parseMonthDay(year, mmdd) {
+    const [m, d] = mmdd.split("-").map(Number);
+    if (!m || !d)
+        throw new Error(`Invalid month-day: ${mmdd}`);
+    return new Date(Date.UTC(year, m - 1, d));
+}
+// ── Easter ──
+export function pascha(year) {
+    if (year < 1583)
+        return paschaJulian(year);
+    const t = Math.trunc;
+    const G = year % 19;
+    const C = t(year / 100);
+    const H = (C - t(C / 4) - t((8 * C + 13) / 25) + 19 * G + 15) % 30;
+    const I = H - t(H / 28) * (1 - t(29 / (H + 1)) * t((21 - G) / 11));
+    const J = (year + t(year / 4) + I + 2 - C + t(C / 4)) % 7;
+    const L = I - J;
+    const month = 3 + t((L + 40) / 44);
+    const day = L + 28 - 31 * t(month / 4);
+    return new Date(Date.UTC(year, month - 1, day));
+}
+function paschaJulian(year) {
+    const a = year % 4, b = year % 7, c = year % 19;
+    const d = (19 * c + 15) % 30;
+    const e = (2 * a + 4 * b - d + 34) % 7;
+    const month = Math.floor((d + e + 114) / 31);
+    const day = ((d + e + 114) % 31) + 1;
+    return julianToGregorian(year, month, day);
+}
+function julianToJdn(year, month, day) {
+    const a = Math.floor((14 - month) / 12);
+    const y = year + 4800 - a;
+    const m = month + 12 * a - 3;
+    return (day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - 32083);
+}
+function julianToGregorian(y, m, d) {
+    const jdn = julianToJdn(y, m, d);
+    let l = jdn + 68569;
+    const n = Math.floor((4 * l) / 146097);
+    l -= Math.floor((146097 * n + 3) / 4);
+    const i = Math.floor((4000 * (l + 1)) / 1461001);
+    l = l - Math.floor((1461 * i) / 4) + 31;
+    const j = Math.floor((80 * l) / 2447);
+    const day = l - Math.floor((2447 * j) / 80);
+    l = Math.floor(j / 11);
+    const month = j + 2 - 12 * l;
+    const year = 100 * (n - 49) + i + l;
+    return new Date(Date.UTC(year, month - 1, day));
+}
+function place(date) {
+    return { date, key: isoDate(date) };
+}
+export function resolveEntryId(id, year, anchors) {
+    if (/^\d{2}-\d{2}$/.test(id)) {
+        return [place(startOfDay(parseMonthDay(year, id)))];
+    }
+    return [place(resolveTemporaStem(id, anchors))];
+}
+function resolveTemporaStem(stem, anchors) {
+    // Stem format: PREFIX + week + "-" + weekday (0=Sun … 6=Sat)
+    // e.g. Adv1-0, Pasc3-4, Pent12-2, Quad2-5, Quadp1-0, Nat1-0, Epi1-0
+    const m = stem.match(/^([A-Za-z]+)(\d+)-(\d+)$/);
+    if (!m)
+        throw new Error(`Unrecognized tempora stem: ${stem}`);
+    const prefix = m[1];
+    const week = parseInt(m[2], 10);
+    const weekday = parseInt(m[3], 10);
+    let base;
+    switch (prefix) {
+        case "Adv":
+            base = addDays(anchors.adventFirstSunday, (week - 1) * 7);
+            break;
+        case "Nat":
+            base = firstSundayOnOrAfter(addDays(anchors.christmas, 1));
+            if (week > 1)
+                base = addDays(base, (week - 1) * 7);
+            break;
+        case "Epi":
+            base = firstSundayOnOrAfter(addDays(anchors.epiphany, 1));
+            if (week > 1)
+                base = addDays(base, (week - 1) * 7);
+            break;
+        case "Quadp":
+            // Quadp1-0 = Septuagesima Sunday
+            base = addDays(anchors.septuagesima, (week - 1) * 7);
+            break;
+        case "Quad":
+            // Quad1-0 = first Sunday of Lent (4 days after Ash Wednesday)
+            base = addDays(anchors.ashWednesday, 4 + (week - 1) * 7);
+            break;
+        case "Pasc":
+            // Pasc0-0 = Easter Sunday; Pasc1-0 = +7, etc.
+            base = addDays(anchors.easter, week * 7);
+            break;
+        case "Pent":
+            // Pent01-0 = Trinity Sunday (Pentecost + 7 days)
+            base = addDays(anchors.pentecost, week * 7);
+            break;
+        default:
+            throw new Error(`Unknown tempora prefix: ${prefix}`);
+    }
+    return addDays(base, weekday);
+}
+/** For a tempora weekday ID like "Adv1-3", return the Sunday "Adv1-0". Null for non-tempora or already a Sunday. */
+export function temporaSundayId(id) {
+    const m = id.match(/^([A-Za-z]+\d+)-([1-6])$/);
+    return m ? `${m[1]}-0` : null;
+}
+//# sourceMappingURL=date.js.map