Trim TODO.md's Open Work section down to actual open items

Cut the intro/priority blurb, dropped the epilogue prose after
"none currently open" (that detail lives in the dated log below),
stripped New Features down to just the features, and removed the
Known Simplifications list entirely since it isn't open work — that
detail already lives as comments in temporal-categories.yml.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGsATZvfnpQ81HQuoF5JuL

.gitignore

@@ -2,3 +2,7 @@ node_modules
 dist
 dev-dist
 *.local
+
+CLAUDE.md
+MEMORY.md
+.claude/

README.md

@@ -0,0 +1,72 @@
+# vu
+
+A static, offline-first PWA for praying the Divine Office — Matins, Lauds, Prime, Terce, Sext,
+None, Vespers, and Compline — in bilingual Latin/English, for any given date.
+
+This isn't a reconstruction of any single historical breviary. It's a personal design that
+draws on several historical sources without reproducing any one of them exactly: hour
+structure chiefly from the Monastic Tridentinum (1617), precedence/rubrics from Divino
+Afflatu, and a calendar merged from both the Tridentine 1906 and Divino Afflatu calendars,
+with more generous handling of commemorations and octaves than any one historical rite used.
+See `CLAUDE.md` (gitignored, not shipped in this repo) or the project's own notes for the full
+rationale if you're extending it.
+
+There's no backend and no database — everything is a pre-built static bundle, and the app is
+designed to keep working fully offline once it's been loaded once.
+
+## Development
+
+Requires Node.js (developed against Node 20+).
+
+```sh
+npm install
+npm run dev        # start the Vite dev server
+npm run build       # type-check (tsc --noEmit) and produce a production build in dist/
+npm run preview     # serve the production build locally
+npm test            # run the test suite (vitest)
+```
+
+Run a single test file or a subset by name:
+
+```sh
+npx vitest run tests/hours/vespers.test.ts
+npx vitest run -t "some test name"
+```
+
+## Running in production
+
+The app is entirely static once built, so "running it" just means serving `dist/` — any static
+file host works, as long as it falls back to `index.html` for unknown paths (the app does its
+own client-side routing for URLs like `/2026-08-09/prime`).
+
+### Docker
+
+A `Dockerfile` builds the static bundle with Node and serves it with Caddy:
+
+```sh
+docker build -t vu .
+docker run -p 8080:80 vu
+```
+
+Or with Docker Compose (`docker-compose.yml` is included):
+
+```sh
+docker compose up -d --build
+```
+
+This serves the app on `http://localhost:8080`. Put a reverse proxy/TLS terminator in front of
+it for a real deployment; the container itself just listens on port 80 internally and has no
+configuration, secrets, or external dependencies.
+
+### Without Docker
+
+Any static file server works — build the app, then serve `dist/` with SPA-style fallback
+routing. For example, with Caddy directly:
+
+```sh
+npm run build
+caddy file-server --root dist --listen :8080
+```
+
+(For a real deployment you'll want a fallback rule so unknown paths resolve to `index.html` —
+see the `Caddyfile` in this repo for the pattern.)

docker-compose.yml

@@ -0,0 +1,10 @@
+# Generic production compose file — builds the static bundle and serves it
+# with Caddy on port 8080. Not tied to any particular host's network/proxy
+# setup; put a reverse proxy or TLS terminator in front of it as needed.
+services:
+  vu:
+    build: .
+    container_name: vu
+    restart: unless-stopped
+    ports:
+      - "8080:80"

src/app-state.ts

@@ -16,9 +16,22 @@ export function todayIso(): string {
   return `${yyyy}-${mm}-${dd}`;
 }
 
+/** Which hour to default to when the URL doesn't specify one, based on local wall-clock time. */
+export function defaultHourForTime(date: Date): HourId {
+  const h = date.getHours();
+  if (h < 6) return 'matins';
+  if (h < 8) return 'lauds';
+  if (h < 9) return 'prime';
+  if (h < 12) return 'terce';
+  if (h < 15) return 'sext';
+  if (h < 17) return 'none';
+  if (h < 21) return 'vespers';
+  return 'compline';
+}
+
 const state: AppState = {
   date: todayIso(),
-  selectedHour: 'prime',
+  selectedHour: defaultHourForTime(new Date()),
   languages: ['en'],
 };
 
@@ -43,14 +56,35 @@ export function setDate(date: string): void {
   notify();
 }
 
+/**
+ * Which hour the "Today" link should point to: if we're already viewing
+ * today, the current time-of-day default (as if freshly visiting `/vu`
+ * right now); otherwise the hour currently selected, unchanged. Shared by
+ * `goToToday()` and the link's `href` (`day-nav.ts`) so a plain click and
+ * a right-click-open-in-new-tab land on the same target.
+ */
+export function todayTargetHour(): HourId {
+  return state.date === todayIso() ? defaultHourForTime(new Date()) : state.selectedHour;
+}
+
 export function goToToday(): void {
-  setDate(todayIso());
+  const today = todayIso();
+  const hour = todayTargetHour();
+  if (state.date === today) {
+    setSelectedHour(hour);
+  } else {
+    setDate(today);
+  }
+}
+
+export function addDays(date: string, days: number): string {
+  const d = new Date(`${date}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
 }
 
 export function shiftDate(days: number): void {
-  const d = new Date(`${state.date}T00:00:00Z`);
-  d.setUTCDate(d.getUTCDate() + days);
-  setDate(d.toISOString().slice(0, 10));
+  setDate(addDays(state.date, days));
 }
 
 export function setSelectedHour(hourId: HourId): void {

src/calendar/collision.ts

@@ -0,0 +1,40 @@
+// Resolves two sanctoral candidates wanting the same day — the case
+// calendar/feasts.ts explicitly doesn't cover (it just picks the
+// higher-ranked of several native candidates and drops the rest) and that
+// calendar/commemorations.ts doesn't cover either (that's temporal-vs-
+// sanctoral, this is sanctoral-vs-sanctoral). This is specifically what a
+// transferred feast (calendar/transfer.ts) runs into when its landing day
+// already has a native saint — never triggered by a plain ferial landing,
+// since a genuinely empty day isn't a collision at all.
+//
+// Same ordering as commemorations.ts's FeastClass scale, which is exactly
+// the point: `duplex > semiduplex > vigil > simplex` is that scale, not a
+// separate one — see calendar/types.ts's FeastClass doc comment.
+import type { Commemoration, DayWinner, SanctoralIdentity } from './types';
+import { compareFeastClass } from './commemorations';
+
+export interface CollisionResult {
+  winner: DayWinner;
+  commemorations: Commemoration[];
+}
+
+function asWinner(candidate: SanctoralIdentity): DayWinner {
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
+}
+
+function asCommemoration(candidate: SanctoralIdentity): Commemoration {
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
+}
+
+/**
+ * `incoming` is the transferred candidate; `native` is whoever already
+ * occupies the landing day. The loser is always commemorated — unlike
+ * commemorations.ts's Sunday rules, there's no rank threshold below which
+ * it gets nothing; a real named feast landing anywhere always leaves a
+ * trace. Ties favor `native` — the incoming feast is the guest here.
+ */
+export function resolveCollision(incoming: SanctoralIdentity, native: SanctoralIdentity): CollisionResult {
+  const winner = compareFeastClass(incoming.rank, native.rank) > 0 ? incoming : native;
+  const loser = winner === incoming ? native : incoming;
+  return { winner: asWinner(winner), commemorations: [asCommemoration(loser)] };
+}

src/calendar/commemorations.ts

@@ -1,5 +1,224 @@
-// Precedence/occurrence rules for when a lower-ranked feast is commemorated
-// rather than fully displaced by the day's winning feast. Deliberately not
-// designed yet — see plan point 5 ("calendar rules are expected to iterate").
-// Unused until milestone 4.
-export {};
+// Precedence/occurrence resolution: given a day's temporal-cycle standing
+// (calendar/types.ts's TemporalCategory) and a candidate sanctoral feast (if
+// any), which one is actually kept, what (if anything) is commemorated
+// alongside it, and whether the candidate needs to be transferred to an
+// adjacent day instead (see calendar/transfer.ts for what actually happens
+// with that signal).
+//
+// Modeled as explicit rules per category, not a numeric-weight comparison
+// like the reference engine's occurrence()/concurrence() — see
+// data/calendar/temporal-categories.yml's header for why. Verified in part
+// against real dates: the Sunday-vs-Duplex threshold was corrected after
+// finding St. Anthony Abbot, plain Duplex, outright winning against an
+// ordinary Sunday in the real Monastic 1617 engine, and privileged-feria
+// was later split into two real tiers after finding St. Gregory the Great,
+// also plain Duplex, outright winning against a Lenten Ember Saturday
+// (which the original single-tier model wrongly forbade) while St. Mark,
+// Duplex II. classis, only ever gets commemorated — never wins outright —
+// within the Easter Octave. The rest is the result of a design discussion,
+// not yet independently verified against a primary source.
+
+import type { Commemoration, DayWinner, FeastClass, SanctoralIdentity, TemporalCategory } from './types';
+
+const FEAST_CLASS_ORDER: FeastClass[] = [
+  'simplex',
+  'vigil',
+  'semiduplex',
+  'duplex',
+  'duplex-majus',
+  'duplex-2-classis',
+  'duplex-1-classis',
+];
+
+export function compareFeastClass(a: FeastClass, b: FeastClass): number {
+  return FEAST_CLASS_ORDER.indexOf(a) - FEAST_CLASS_ORDER.indexOf(b);
+}
+
+export function isAtLeast(rank: FeastClass, threshold: FeastClass): boolean {
+  return compareFeastClass(rank, threshold) >= 0;
+}
+
+/**
+ * The minimum rank a real sanctoral candidate needs to win each temporal
+ * category outright, per `decideOccurrence`'s own branches above —
+ * factored out so calendar/octaves.ts can ask the identical question of an
+ * *octave*'s own effective standing (not a real occurring saint) on a day
+ * where nothing else won. `undefined` where nothing ever wins outright no
+ * matter how high-ranked (`privileged-feria-major`/`privileged-sunday` —
+ * Ash Wednesday, Holy Week, a privileged Sunday — only ever get a
+ * commemoration at best, per those branches above). `ordinary-feria` has
+ * no real threshold at all (any real content wins), included here as
+ * `'simplex'` (the weakest real rank) only for completeness — callers
+ * needing that case already have their own unconditional path and don't
+ * need to call this. */
+export function minimumOutrightWinningRank(category: TemporalCategory): FeastClass | undefined {
+  switch (category) {
+    case 'ordinary-feria':
+      return 'simplex';
+    case 'privileged-feria-minor':
+      return 'semiduplex';
+    case 'privileged-feria':
+    case 'ordinary-sunday':
+      return 'duplex';
+    case 'privileged-feria-major':
+    case 'privileged-sunday':
+      return undefined;
+  }
+}
+
+/** Vigils belong to the day *before* their feast, so an impeded vigil is
+ * shifted backward rather than forward like everything else — see
+ * calendar/transfer.ts. */
+function transferDirectionOf(rank: FeastClass): 'forward' | 'backward' {
+  return rank === 'vigil' ? 'backward' : 'forward';
+}
+
+export interface OccurrenceResult {
+  /** This day's own resolution, with the candidate absent if it's being transferred. */
+  winner: DayWinner;
+  commemorations: Commemoration[];
+  /** Set when `sanctoral` doesn't win or get commemorated here at all — it
+   * needs to be resolved against an adjacent day instead. */
+  transfer?: { candidate: SanctoralIdentity; direction: 'forward' | 'backward' };
+}
+
+function sanctoralCommemoration(candidate: SanctoralIdentity): Commemoration {
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
+}
+
+function sanctoralWinner(candidate: SanctoralIdentity): DayWinner {
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
+}
+
+/**
+ * `temporalId` is this day's own temporal-propers id (see
+ * calendar/temporal-id.ts) — needed so a temporal winner or commemoration
+ * can actually be looked up later (`propers.getTemporalProper`), not just
+ * named "temporal" in the abstract.
+ */
+export function decideOccurrence(
+  temporal: TemporalCategory,
+  temporalId: string,
+  sanctoral: SanctoralIdentity | null,
+): OccurrenceResult {
+  const temporalWinner: DayWinner = { kind: 'temporal', id: temporalId };
+  if (!sanctoral) {
+    return { winner: temporalWinner, commemorations: [] };
+  }
+
+  switch (temporal) {
+    case 'ordinary-feria':
+      // An ordinary feria has no standing of its own to defend — any real
+      // feast, however low-ranked, is kept in its place.
+      return { winner: sanctoralWinner(sanctoral), commemorations: [] };
+
+    case 'privileged-feria-minor':
+      // Advent's own ordinary ferias (verified: St. Bibiana, Simplex,
+      // merely commemorated under an Advent feria; St. Nicholas,
+      // Semiduplex, wins outright with the feria commemorated in return).
+      // Weaker than `privileged-feria`'s Duplex+ threshold — Semiduplex is
+      // already enough here — and unlike every other feria tier, nothing
+      // ever transfers: whichever side loses still gets a commemoration.
+      if (isAtLeast(sanctoral.rank, 'semiduplex')) {
+        return { winner: sanctoralWinner(sanctoral), commemorations: [{ kind: 'temporal', id: temporalId }] };
+      }
+      return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+
+    case 'privileged-feria':
+      // The lesser of the two privileged-feria tiers (Ember days outside
+      // Holy Week/the Easter Octave, etc.) — behaves exactly like an
+      // ordinary Sunday: real standing of its own, but not enough to
+      // resist a sufficiently ranked feast the way privileged-feria-major
+      // does.
+      if (isAtLeast(sanctoral.rank, 'duplex')) {
+        return { winner: sanctoralWinner(sanctoral), commemorations: [{ kind: 'temporal', id: temporalId }] };
+      }
+      if (sanctoral.rank === 'simplex') {
+        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      }
+      return {
+        winner: temporalWinner,
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
+      };
+
+    case 'privileged-feria-major':
+      // Ash Wednesday, Holy Week, the Easter Octave, Low Sunday, the
+      // Vigils of Christmas/Pentecost — never displaced, and never gives
+      // even a bare commemoration to any rank, same as privileged-sunday.
+      // The "duplex-majus+ still gets a nod" branch this case used to
+      // have was wrong, not just unverified: the one case that seemed to
+      // support it (St. Mark, Duplex II. classis, "merely commemorated"
+      // within the Easter Octave) turns out to have been a misreading —
+      // live-verified 2026-09-01, direct instruction ("you dont
+      // commemorate -anything- from palm sunday through low sunday"),
+      // confirmed with two more dates on top of the Annunciation/Palm-
+      // Easter-Sunday evidence already in the privileged-sunday case
+      // below: the Annunciation (Duplex I. classis) transfers with zero
+      // commemoration on Holy Thursday itself in years it lands there
+      // (2027/2032/2043), and Chair of St. Peter at Antioch (Duplex
+      // majus) transfers off Ash Wednesday the same way (2034) — so the
+      // exception was wrong for Ash Wednesday too, not just Holy Week.
+      return {
+        winner: temporalWinner,
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
+      };
+
+    case 'ordinary-sunday':
+      if (isAtLeast(sanctoral.rank, 'duplex')) {
+        // Duplex+ wins outright; the Sunday itself is commemorated in return.
+        return { winner: sanctoralWinner(sanctoral), commemorations: [{ kind: 'temporal', id: temporalId }] };
+      }
+      if (sanctoral.rank === 'simplex') {
+        // Too minor to warrant its own day, but a plain commemoration
+        // doesn't cheapen it the way it would a Semiduplex.
+        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      }
+      // Semiduplex or Vigil: no room here at all, in either direction —
+      // per direct instruction, an ordinary Sunday's own standing pushes
+      // a Semiduplex feast off to the next open day (typically the
+      // Monday right after) rather than downgrading it to a bare
+      // commemoration. This `transfer` signal is only half of the
+      // mechanism: it's just this day noting "I couldn't hold onto this
+      // candidate." The other half — a later day actually claiming a
+      // transferred-in candidate — lives entirely in calendar/index.ts's
+      // resolveDay: for *every* date it resolves, it independently
+      // recomputes `resolveNativeOccurrence` for both the day before and
+      // the day after, checks whether *that* neighbor's own native
+      // occurrence produced a `transfer` pointed this direction, and only
+      // then folds it in via `applyIncomingTransfer`. So "Monday looks
+      // back at the sanctoral calendar to see if Sunday's own candidate
+      // needs a home" isn't a separate mechanism to build — it's the
+      // existing generic transfer-consumption check, which already runs
+      // for every day regardless of category.
+      return {
+        winner: temporalWinner,
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
+      };
+
+    case 'privileged-sunday':
+      // A privileged Sunday wants nothing at all, no matter how high the
+      // candidate ranks — not even the bare commemoration an ordinary
+      // Sunday would allow a Simplex, and no exception for duplex-majus+ —
+      // everything transfers. Live-verified 2026-09-01, three independent
+      // dates: the Immaculate Conception (Duplex I. classis) transfers off
+      // Advent II with no commemoration at all (real dates 2024/2030/2041),
+      // and the Annunciation (also Duplex I. classis) transfers off both
+      // Palm Sunday and Easter Sunday itself the same way (2029/2035/2040/
+      // 2046) — confirmed by direct instruction as the correct behavior,
+      // correcting an earlier, never-actually-verified "duplex-majus+
+      // still gets a nod" guess. (Where a transferred candidate actually
+      // lands is a separate, still-generic `transferDirectionOf`/next-
+      // open-day mechanism — the Annunciation's own real rule of jumping
+      // *past* the whole Easter Octave rather than landing inside it is a
+      // known follow-on, blocked on the not-yet-built Easter-octave
+      // mechanism; see TODO.md.)
+      return {
+        winner: temporalWinner,
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
+      };
+  }
+}

src/calendar/date-math.ts

@@ -0,0 +1,32 @@
+// Small ISO-date ("YYYY-MM-DD") arithmetic helpers shared by easter.ts and
+// temporal.ts. Parsed/formatted as UTC midnight throughout, same convention
+// as weekday.ts, so results don't shift with the caller's local timezone.
+
+export interface CalendarDate {
+  year: number;
+  month: number; // 1-12
+  day: number;
+}
+
+export function toIsoDate(date: CalendarDate): string {
+  const mm = String(date.month).padStart(2, '0');
+  const dd = String(date.day).padStart(2, '0');
+  return `${date.year}-${mm}-${dd}`;
+}
+
+export function addDays(isoDate: string, days: number): string {
+  const d = new Date(`${isoDate}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
+}
+
+export function daysBetween(fromIsoDate: string, toIsoDate: string): number {
+  const from = new Date(`${fromIsoDate}T00:00:00Z`).getTime();
+  const to = new Date(`${toIsoDate}T00:00:00Z`).getTime();
+  return Math.round((to - from) / 86_400_000);
+}
+
+/** 0 = Sunday, ..., 6 = Saturday. */
+export function dayOfWeek(isoDate: string): number {
+  return new Date(`${isoDate}T00:00:00Z`).getUTCDay();
+}

src/calendar/day-label.ts

@@ -0,0 +1,720 @@
+// "Day being celebrated" label — combines an ordinal week-within-season
+// label (pure date arithmetic on the season anchors already computed
+// elsewhere in calendar/) with a feast name when
+// calendar/commemorations.ts's occurrence decision says one applies.
+//
+// Counting convention is Trinity-counted ("Nth Sunday/week after Trinity"),
+// not Divinum Officium's own "after Pentecost" counting — a deliberate
+// choice, one week off from Pentecost-counting for the same date. Meant to
+// become a configurable choice later (the same day->id indirection
+// philosophy already used for the sanctoral calendar), not hardcoded here
+// forever — just not built yet.
+//
+// Bilingual: every label is built as a `Bi` (`{en, la}`) pair throughout.
+// Proper names (a saint's name, an octave's name, a named temporal feast's
+// name) carry an optional `nameLa` field alongside the required English
+// `name` — see calendar/types.ts's `SanctoralIdentity.nameLa` doc comment.
+// Authored for essentially every saint/octave/named-feast as of 2026-08-31
+// (see TODO.md); `biName` still falls back to the English string as the
+// `la` value for the rare unauthored case (same "surface real text rather
+// than block on missing" convention used elsewhere in this app), rather
+// than leaving Latin mode showing blanks. The closed, mechanism-level
+// vocabulary here (weekdays, ranks, season/ordinal phrasing) has always
+// had real Latin authored, independent of this.
+import type { FeastClass, LiturgicalDay, TemporalCategory, Weekday } from './types';
+import { easterSunday } from './easter';
+import { adventStart, firstSundayStrictlyAfter, sundayOnOrBefore } from './temporal';
+import { addDays, daysBetween, toIsoDate } from './date-math';
+import { getTemporalFeastRecord } from './temporal-feasts';
+import { activeOctavesFor, octaveGoverningPrivilegedDay, resolveActiveOctave, type ActiveOctave } from './octaves';
+import { resolveTemporalId } from './temporal-id';
+
+interface Bi {
+  en: string;
+  la: string;
+  [lang: string]: string;
+}
+
+function bi(en: string, la: string): Bi {
+  return { en, la };
+}
+
+/** A proper name (saint, octave, named temporal feast) with an optional
+ * authored Latin form — falls back to the English string when `nameLa`
+ * hasn't been authored yet, same convention as `biFallback` above. */
+function biName(name: string, nameLa: string | undefined): Bi {
+  return { en: name, la: nameLa ?? name };
+}
+
+function joinBi(items: Bi[], sep = ' — '): Bi {
+  return { en: items.map((i) => i.en).join(sep), la: items.map((i) => i.la).join(sep) };
+}
+
+/**
+ * The 6 Ember-day ids (calendar/ember-days.ts) are deliberately *not* in
+ * temporal-feasts.ts's named-feast table — they're privileged ferias, not
+ * rank-contesting movable feasts (see that file's own doc comment), and
+ * that table's `getTemporalFeastRecord` also doubles as resolve-
+ * common.ts's `isFerialOrVigil` bareness check, so adding them there
+ * would silently turn off their own ferial Preces (their `[Rule]` block
+ * is literally "Preces Feriales"). A small standalone lookup here instead
+ * — Latin names read straight from each day's own `[Officium]` header
+ * (Tempora/093-{3,5,6}.txt, Tempora/Adv3-{3,5,6}.txt).
+ *
+ * Without this, an Ember day never named itself anywhere in the UI: not
+ * as the primary label when it wins outright (fell through to the plain
+ * "Wednesday in the Nth week after Trinity"/"In the Nth week of Advent"
+ * wording with no Ember mention at all), and not as a commemoration when
+ * demoted (collectCommemorations's temporal branch only ever matched
+ * `resolveTemporalId(day.date)`, never an Ember-relabeled id) — live-
+ * verified as a real, user-visible gap, 2026-09-03.
+ */
+const EMBER_DAY_NAMES: Record<string, Bi> = {
+  'ember-september-wednesday': bi('Ember Wednesday in September', 'Feria Quarta Quattuor Temporum Septembris'),
+  'ember-september-friday': bi('Ember Friday in September', 'Feria Sexta Quattuor Temporum Septembris'),
+  'ember-september-saturday': bi('Ember Saturday in September', 'Sabbato Quattuor Temporum Septembris'),
+  'ember-advent-wednesday': bi('Ember Wednesday in Advent', 'Feria IV Quattuor Temporum in Adventu'),
+  'ember-advent-friday': bi('Ember Friday in Advent', 'Feria VI Quattuor Temporum in Adventu'),
+  'ember-advent-saturday': bi('Ember Saturday in Advent', 'Sabbato Quattuor Temporum in Adventu'),
+};
+
+export function emberDayLabel(id: string): Bi | undefined {
+  return EMBER_DAY_NAMES[id];
+}
+
+function capitalize(text: string): string {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function ordinal(n: number): string {
+  const mod100 = n % 100;
+  if (mod100 >= 11 && mod100 <= 13) {
+    return `${n}th`;
+  }
+  switch (n % 10) {
+    case 1:
+      return `${n}st`;
+    case 2:
+      return `${n}nd`;
+    case 3:
+      return `${n}rd`;
+    default:
+      return `${n}th`;
+  }
+}
+
+// Feminine Latin ordinal adjectives (agreeing with "Dominica"/"Hebdomada"/
+// "die", all feminine) — covers 1st through 24th, the full range this app
+// ever counts to (Trinitytide's fixed last week is the 23rd). Not a general
+// Latin-numerals utility, just this app's own closed display vocabulary.
+const ORDINAL_LA = [
+  '',
+  'prima',
+  'secunda',
+  'tertia',
+  'quarta',
+  'quinta',
+  'sexta',
+  'septima',
+  'octava',
+  'nona',
+  'decima',
+  'undecima',
+  'duodecima',
+  'decima tertia',
+  'decima quarta',
+  'decima quinta',
+  'decima sexta',
+  'decima septima',
+  'decima octava',
+  'decima nona',
+  'vicesima',
+  'vicesima prima',
+  'vicesima secunda',
+  'vicesima tertia',
+  'vicesima quarta',
+];
+
+function ordinalLa(n: number): string {
+  return ORDINAL_LA[n] ?? `${n}a`;
+}
+
+const WEEKDAY_LABELS: Record<Weekday, Bi> = {
+  sunday: bi('Sunday', 'Dominica'),
+  monday: bi('Monday', 'Feria Secunda'),
+  tuesday: bi('Tuesday', 'Feria Tertia'),
+  wednesday: bi('Wednesday', 'Feria Quarta'),
+  thursday: bi('Thursday', 'Feria Quinta'),
+  friday: bi('Friday', 'Feria Sexta'),
+  saturday: bi('Saturday', 'Sabbato'),
+};
+
+function weekdayLabel(day: LiturgicalDay): Bi {
+  return WEEKDAY_LABELS[day.weekday];
+}
+
+interface OrdinalSeason {
+  /** ISO date of the season's own anchor day, for a given calendar year. */
+  anchorDate(year: number): string;
+  /** Advent: the anchor Sunday itself is "week 1". Trinity/Epiphany/Easter/
+   * Lent: the anchor is its own named day, excluded from the count — the
+   * numbered weeks start the following Sunday. */
+  includeAnchorWeek: boolean;
+  /** Used in "Weekday after {anchorName}" for the anchor's own partial week,
+   * and as the anchor day's own standalone name. */
+  anchorName: Bi;
+  /** Used in "the Nth Sunday/week {preposition} {ordinalName}". For
+   * `preposition: 'of'`, `ordinalName.la` is already the correct genitive
+   * form (glued directly after the ordinal, no linking word — Latin
+   * idiom). For `preposition: 'after'`, `ordinalName.la` is the form used
+   * after "post" (traditionally accusative, or an idiomatic fixed phrase
+   * like "post Cineres"). */
+  ordinalName: Bi;
+  preposition: 'after' | 'of';
+  /** The season's own anchor day's rank, if it sits on the closed
+   * pre-1955 duplex scale at all — Ash Wednesday (Lent's anchor) doesn't;
+   * a privileged feria has no duplex-scale rank, so it's left undefined
+   * and shows no parenthetical, same "omit rather than guess" convention
+   * `formatRank`/`status` fields use elsewhere. */
+  anchorRank?: FeastClass;
+  /** Advent and Lent only: once the header always shows the day's weekday
+   * on its own, repeating it at the front of this label is redundant — so
+   * those two seasons drop it here, in both languages. Every other season
+   * keeps the weekday prefix (explicit, narrower scope decision). */
+  dropWeekdayPrefix?: boolean;
+}
+
+const ORDINAL_SEASONS: Partial<Record<string, OrdinalSeason>> = {
+  advent: {
+    anchorDate: adventStart,
+    includeAnchorWeek: true,
+    anchorName: bi('Advent', 'Adventus'),
+    // Genitive of 4th-declension "adventus" is also "Adventus" — no
+    // linking word needed: "Hebdomada II Adventus".
+    ordinalName: bi('Advent', 'Adventus'),
+    preposition: 'of',
+    dropWeekdayPrefix: true,
+  },
+  epiphanytide: {
+    anchorDate: (year) => `${year}-01-06`,
+    includeAnchorWeek: false,
+    anchorName: bi('Epiphany', 'Epiphania'),
+    // Accusative, for "post Epiphaniam".
+    ordinalName: bi('Epiphany', 'Epiphaniam'),
+    preposition: 'after',
+    anchorRank: 'duplex-1-classis',
+  },
+  lent: {
+    anchorDate: (year) => addDays(toIsoDate(easterSunday(year)), -46),
+    includeAnchorWeek: false,
+    anchorName: bi('Ash Wednesday', 'Feria Quarta Cinerum'),
+    // Genitive of 1st-declension "Quadragesima": "Hebdomada II
+    // Quadragesimae". The pre-Lent-I days use the real traditional idiom
+    // "post Cineres" instead (see temporalLabel below), not this field.
+    ordinalName: bi('Lent', 'Quadragesimae'),
+    preposition: 'of',
+    dropWeekdayPrefix: true,
+  },
+  eastertide: {
+    anchorDate: (year) => toIsoDate(easterSunday(year)),
+    includeAnchorWeek: false,
+    anchorName: bi('Easter', 'Pascha'),
+    // "Pascha" is indeclinable — same form after "post".
+    ordinalName: bi('Easter', 'Pascha'),
+    preposition: 'after',
+    anchorRank: 'duplex-1-classis',
+  },
+  trinitytide: {
+    anchorDate: (year) => addDays(toIsoDate(easterSunday(year)), 56),
+    includeAnchorWeek: false,
+    anchorName: bi('Trinity Sunday', 'Dominica Sanctissimae Trinitatis'),
+    // Accusative, for "post Sanctissimam Trinitatem" — this app's own
+    // Trinity-counted convention (see file header), not the historical
+    // Pentecost-counted "post Pentecosten".
+    ordinalName: bi('Trinity', 'Sanctissimam Trinitatem'),
+    preposition: 'after',
+    anchorRank: 'duplex-1-classis',
+  },
+};
+
+/** The anchor day itself (Ash Wednesday, Epiphany, Easter Sunday, Trinity
+ * Sunday) is its own named day, not "day after itself" — and outranks
+ * everything else this module computes (an active octave, an ordinal week
+ * label), since it's the day's real primary identity in the live engine
+ * too (e.g. Trinity Sunday is also technically day 8 of Pentecost's own
+ * octave, but nobody calls it that). Advent's own anchor (Advent I Sunday)
+ * doesn't take this branch — it's already "the 1st Sunday of Advent" via
+ * the ordinal path below. */
+function anchorDayName(day: LiturgicalDay, withRank = true): Bi | undefined {
+  const config = ORDINAL_SEASONS[day.season];
+  if (!config || config.includeAnchorWeek) {
+    return undefined;
+  }
+  const year = Number(day.date.slice(0, 4));
+  if (day.date === config.anchorDate(year)) {
+    return withRank && config.anchorRank
+      ? bi(`${config.anchorName.en} (${formatRank(config.anchorRank).en})`, `${config.anchorName.la} (${formatRank(config.anchorRank).la})`)
+      : config.anchorName;
+  }
+  return undefined;
+}
+
+/** The fixed final Sunday of the liturgical year (temporal-id.ts's
+ * `post-pentecost-24`) always carries "Sunday XXIV after Pentecost"'s own
+ * formulary, regardless of how many Sundays actually elapsed since
+ * Trinity — confirmed by scanning every year 1900-2100, every single one
+ * lands on this id for its own last Sunday before Advent, never a raw
+ * elapsed-week count. This app's Trinity-counted display is one week off
+ * from that Pentecost-counted id (Trinity Sunday itself = post-pentecost-
+ * 01 = the display's own uncounted anchor day), so the fixed display
+ * ordinal here is XXIV - 1 = 23, not whatever a plain "weeks since
+ * Trinity" calculation would produce. */
+const FIXED_LAST_SUNDAY_ORDINAL = 23;
+
+/**
+ * Trinitytide's ordinal display can't be pure "weeks since Trinity's own
+ * first Sunday" arithmetic once the season gets late enough — see
+ * temporal-id.ts's own post-Pentecost-XXIII-plus branch. Two cases, both
+ * driven by `resolveTemporalId` directly (the same mechanism the content
+ * layer already trusts, rather than re-deriving the wdist arithmetic here
+ * a second time, so the label can never disagree with what's actually
+ * rendered underneath):
+ *   - A resumed post-Epiphany Sunday/week (an overflow year's skipped
+ *     Epiphany Sundays, reappearing here) — reads "after Epiphany", not
+ *     the next Trinity-counted number in line.
+ *   - The fixed final Sunday/week of the year itself — always the fixed
+ *     23rd-after-Trinity ordinal (see FIXED_LAST_SUNDAY_ORDINAL above),
+ *     every year, not just overflow ones.
+ * Only ever fires within trinitytide, since that's the only season
+ * resolveTemporalId can return either of these ids for a date outside
+ * their own native season. Trinitytide isn't in the weekday-drop set, so
+ * both languages keep their weekday prefix here.
+ */
+function trinitytideOverrideLabel(day: LiturgicalDay): Bi | undefined {
+  if (day.season !== 'trinitytide') {
+    return undefined;
+  }
+  const id = resolveTemporalId(day.date);
+  const weekdayName = weekdayLabel(day);
+
+  const epiphanyMatch = id.match(/^post-epiphany-(\d)$/);
+  if (epiphanyMatch) {
+    const n = Number(epiphanyMatch[1]);
+    return day.weekday === 'sunday'
+      ? bi(`The ${ordinal(n)} Sunday after Epiphany`, `Dominica ${ordinalLa(n)} post Epiphaniam`)
+      : bi(`${weekdayName.en} in the ${ordinal(n)} week after Epiphany`, `${weekdayName.la} in hebdomada ${ordinalLa(n)} post Epiphaniam`);
+  }
+
+  if (id === 'post-pentecost-24') {
+    return day.weekday === 'sunday'
+      ? bi(
+          `The ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} Sunday after Trinity`,
+          `Dominica ${ordinalLa(FIXED_LAST_SUNDAY_ORDINAL)} post Sanctissimam Trinitatem`,
+        )
+      : bi(
+          `${weekdayName.en} in the ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} week after Trinity`,
+          `${weekdayName.la} in hebdomada ${ordinalLa(FIXED_LAST_SUNDAY_ORDINAL)} post Sanctissimam Trinitatem`,
+        );
+  }
+
+  return undefined;
+}
+
+function temporalLabel(day: LiturgicalDay): Bi {
+  const trinitytideOverride = trinitytideOverrideLabel(day);
+  if (trinitytideOverride) {
+    return trinitytideOverride;
+  }
+
+  const weekdayName = weekdayLabel(day);
+  const config = ORDINAL_SEASONS[day.season];
+  if (!config) {
+    // No ordinal convention modeled for this season (Septuagesima-tide,
+    // Passiontide, Ascensiontide, Pentecost, Christmastide, the
+    // Corpus-Christi/Sacred-Heart single-day seasons) — their few days
+    // mostly have their own proper names rather than ordinal counting, so
+    // this fallback is expected to be seen, not a gap to fill later. No
+    // authored Latin season name exists for these yet, so `la` falls back
+    // to the same English season word.
+    const seasonName = capitalize(day.season.replace(/-/g, ' '));
+    return bi(`${weekdayName.en} in ${seasonName}`, `${weekdayName.la} in ${seasonName}`);
+  }
+
+  const year = Number(day.date.slice(0, 4));
+  const anchor = config.anchorDate(year);
+  const anchorName = anchorDayName(day);
+  if (anchorName) {
+    return anchorName;
+  }
+
+  const firstNumberedSunday = config.includeAnchorWeek ? anchor : firstSundayStrictlyAfter(anchor);
+  if (day.date < firstNumberedSunday) {
+    // Lent's own pre-Lent-I days use the real traditional idiom "post
+    // Cineres" rather than the season's genitive `ordinalName` (which is
+    // built for the "of Lent" construction, not "after Ash Wednesday").
+    const afterAnchorLa = day.season === 'lent' ? 'Cineres' : config.anchorName.la;
+    return config.dropWeekdayPrefix
+      ? bi(`After ${config.anchorName.en}`, `Post ${afterAnchorLa}`)
+      : bi(`${weekdayName.en} after ${config.anchorName.en}`, `${weekdayName.la} post ${afterAnchorLa}`);
+  }
+
+  const weeksSince = daysBetween(firstNumberedSunday, sundayOnOrBefore(day.date)) / 7;
+  const ordinalStr = ordinal(weeksSince + 1);
+  const ordinalStrLa = ordinalLa(weeksSince + 1);
+  if (day.weekday === 'sunday') {
+    return config.preposition === 'of'
+      ? bi(`The ${ordinalStr} Sunday of ${config.ordinalName.en}`, `Dominica ${ordinalStrLa} ${config.ordinalName.la}`)
+      : bi(`The ${ordinalStr} Sunday after ${config.ordinalName.en}`, `Dominica ${ordinalStrLa} post ${config.ordinalName.la}`);
+  }
+  const weekPhraseLa =
+    config.preposition === 'of' ? `hebdomada ${ordinalStrLa} ${config.ordinalName.la}` : `hebdomada ${ordinalStrLa} post ${config.ordinalName.la}`;
+  return config.dropWeekdayPrefix
+    ? bi(`In the ${ordinalStr} week ${config.preposition} ${config.ordinalName.en}`, `In ${weekPhraseLa}`)
+    : bi(`${weekdayName.en} in the ${ordinalStr} week ${config.preposition} ${config.ordinalName.en}`, `${weekdayName.la} in ${weekPhraseLa}`);
+}
+
+/** "Third Day within the Octave of St. Lawrence" for an ordinary mid-octave
+ * day ("Tertia die infra Octavam S. Laurentii Martyris"), or plain "Octave
+ * of St. Lawrence" for the octave's own closing day ("In Octava S.
+ * Laurentii Martyris") — real DO Latin distinguishes "infra octavam"
+ * (within the octave, days 2-7) from "in octava" (on the octave day
+ * itself, day 8), live-verified: Aug 17 (St. Lawrence's closing day)
+ * titles itself "In Octava S. Laurentii Martyris", not "Octava die infra
+ * Octavam...". Day 1 shouldn't normally reach either branch (that day's
+ * own winner is the feast itself, handled above before this is ever
+ * called) — kept simple rather than special-cased for that rare edge case
+ * (see applyOctaves's own `isOwnStartDay` comment in calendar/index.ts for
+ * when it can happen). Falls back to the English name for `la` too when
+ * the octave's own record has no authored `nameLa` yet (see file header). */
+function octaveCoreName(octave: ActiveOctave): Bi {
+  const name = biName(octave.name, octave.nameLa);
+  return octave.isClosingDay
+    ? bi(`Octave of ${name.en}`, `In Octava ${name.la}`)
+    : bi(`${ordinal(octave.dayNumber)} Day within the Octave of ${name.en}`, `${ordinalLa(octave.dayNumber)} die infra Octavam ${name.la}`);
+}
+
+function octaveLabel(octave: ActiveOctave): Bi {
+  const core = octaveCoreName(octave);
+  const rank = formatRank(octave.wins);
+  return bi(`${core.en} (${rank.en})`, `${core.la} (${rank.la})`);
+}
+
+/** Same phrasing as `octaveLabel`, but without the parenthesized rank —
+ * the real DO commemoration line for a displaced octave day carries no
+ * rank at all (e.g. Aug 19's real Divino Afflatu 1954 commemoration reads
+ * plain "Quinta die infra Octavam S. Assumptionis Beatæ Mariæ Virginis",
+ * no "~ Semiduplex"). `octaveLabel`'s own rank parenthetical only belongs
+ * to an octave day when it's the day's own primary winner (rank is what
+ * it *won as*, not a fact worth restating once a duplex-or-higher saint
+ * has displaced it and it's just riding along as a commemoration
+ * instead). */
+function octaveCommemorationLabel(octave: ActiveOctave): Bi {
+  return octaveCoreName(octave);
+}
+
+/** Real Divino Afflatu phrasing for a commemoration that only exists
+ * because Vespers/Compline crossed a day boundary — "commemoratio de
+ * præcedenti" (today, riding along on tomorrow's anticipated First
+ * Vespers) or "commemoratio de sequenti" (tomorrow, riding along on
+ * today's kept Second Vespers), per horascommon.pl. See
+ * `Commemoration`'s `vespersNote` field (calendar/types.ts) and
+ * calendar/vespers.ts's two `commemorationOfDisplaced*` functions, the
+ * only place that sets it. */
+const CROSS_DAY_VESPERS_LABELS: Record<'today' | 'tomorrow', Bi> = {
+  today: bi('of today', 'de præcedenti'),
+  tomorrow: bi('of tomorrow', 'de sequenti'),
+};
+
+/** Every commemoration on `day`, resolved to display strings and grouped
+ * by kind — the single place that decides both "is this commemoration
+ * eligible to show at all here" and "how is it formatted", so every
+ * caller below shares the same answer instead of each hand-rolling its
+ * own filter/format pass (that duplication is exactly how Aug 19's octave
+ * phrasing, Aug 17's closing-day title, and Aug 16's missing Sunday
+ * commemoration ended up as three separate bugs instead of one). Callers
+ * still decide their own *order* — e.g. the octave-headline branch wants
+ * octaves before a commemorated saint, while a plain Sunday/feria wants a
+ * commemorated saint *before* its own temporal label — since that
+ * ordering reflects a real, deliberate liturgical convention per branch,
+ * not an accident to unify away.
+ *
+ * - `sanctoral`: every commemorated saint, plain name, no rank (multiple
+ *   real ones can coexist — e.g. two colliding saints on the same date —
+ *   this app's own "generous commemorations" design keeps every one of
+ *   them, not just the first). `la` uses the saint's own `nameLa` when
+ *   authored, else falls back to the same English name (see file header).
+ * - `temporal`: the day's own real Sunday/feria identity, if
+ *   `decideOccurrence` demoted it to a commemoration (`ordinary-sunday`/
+ *   `privileged-feria`/`privileged-feria-minor`) — matched by id against
+ *   `resolveTemporalId(day.date)` specifically, not "any temporal-kind
+ *   commemoration present", so unrelated side-notes like
+ *   `applyEpiphany6Commemoration`'s fixed `post-epiphany-6` don't get
+ *   mistaken for it. Rendered via `anchorDayName`/`temporalLabel`, the
+ *   same machinery a primary temporal label uses, minus the rank.
+ * - `octave`: every active octave other than `excludeOctaveId` (the
+ *   octave already serving as the day's own headline, if any) — only
+ *   when `showOctaves` is true. Live-verified this is *not* simply "is an
+ *   octave active": on a Sunday or privileged feria a saint won outright
+ *   against, an unrelated active octave isn't commemorated at all (Aug
+ *   16's St. Joachim names only the Sunday, not St. Lawrence's/the
+ *   Assumption's octaves, even though both are technically active) —
+ *   octaves are only shown on `ordinary-feria` (no real standing of its
+ *   own to prefer instead) or when the octave itself is governing the
+ *   headline. Rendered via `octaveCommemorationLabel` — the "Nth Day
+ *   within the Octave of X" phrasing, no rank.
+ */
+function collectCommemorations(
+  day: LiturgicalDay,
+  opts: { showOctaves: boolean; excludeOctaveId?: string },
+): { sanctoral: Bi[]; temporal: Bi[]; octaves: Bi[] } {
+  const temporalId = resolveTemporalId(day.date);
+  const activeOctaves = opts.showOctaves ? activeOctavesFor(day.date) : [];
+  const sanctoral: Bi[] = [];
+  const temporal: Bi[] = [];
+  const octaves: Bi[] = [];
+  for (const c of day.commemorations) {
+    if (c.kind === 'sanctoral') {
+      const name = biName(c.name, c.nameLa);
+      if (c.vespersNote) {
+        sanctoral.push(bi(`${name.en} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].en})`, `${name.la} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].la})`));
+      } else if (c.transferredFrom) {
+        // Same "arrived via transfer, not natively due here" signal as a
+        // transferred-in *winner* gets — a reader shouldn't need to already
+        // know this saint's real date to realize a mere commemoration here
+        // is standing in for a transfer, not this date's own natural
+        // sanctoral standing.
+        sanctoral.push(bi(`${name.en} (${TRANSFERRED_LABEL.en})`, `${name.la} (${TRANSFERRED_LABEL.la})`));
+      } else {
+        sanctoral.push(name);
+      }
+    } else if (c.kind === 'temporal') {
+      // `c.id === temporalId` (the plain governing weekday, e.g. "Saturday
+      // in the 15th week after Trinity") is deliberately never shown here:
+      // this function only ever runs to list *secondary* identities
+      // alongside an already-displayed primary winner (a plain temporal
+      // day that wins outright never reaches `day.commemorations` at all —
+      // its own name is the header itself, via a different branch of
+      // `getDayLabel`). Once something else is already being celebrated,
+      // restating "this is also just the Nth ordinary weekday" tells the
+      // reader nothing they don't already know from the winner+rank shown
+      // — unlike a *named* temporal identity (an Ember day, a vigil), which
+      // genuinely adds information. Not Ember-specific (a 2026-09-05 first
+      // pass wrongly scoped this to "only when an Ember commemoration is
+      // also present" — user, 2026-09-05: "it has nothing to do with
+      // ember-ness"); this plain generic label is dropped unconditionally
+      // whenever it shows up as a mere commemoration, Ember day or not.
+      if (c.id !== temporalId) {
+        const emberName = emberDayLabel(c.id);
+        if (emberName) {
+          temporal.push(emberName);
+        }
+      }
+    } else if (opts.showOctaves && c.id !== opts.excludeOctaveId) {
+      const octave = activeOctaves.find((a) => a.id === c.id);
+      octaves.push(octave ? octaveCommemorationLabel(octave) : biName(c.name, c.nameLa));
+    }
+  }
+  return { sanctoral, temporal, octaves };
+}
+
+const RANK_LABELS: Record<FeastClass, Bi> = {
+  simplex: bi('Simplex', 'Simplex'),
+  vigil: bi('Vigil', 'Vigilia'),
+  semiduplex: bi('Semiduplex', 'Semiduplex'),
+  duplex: bi('Duplex', 'Duplex'),
+  'duplex-majus': bi('Duplex Majus', 'Duplex Majus'),
+  'duplex-2-classis': bi('Duplex II Class', 'Duplex II. Classis'),
+  'duplex-1-classis': bi('Duplex I Class', 'Duplex I. Classis'),
+};
+
+/** The day's own winning saint's rank, parenthesized after their name —
+ * rank was previously shown nowhere in this app's UI at all, for any
+ * saint. Only the day's own *winner* gets this treatment, not every
+ * commemoration, matching the "winner is primary, commemorations are
+ * secondary" distinction this file already draws throughout. */
+function formatRank(rank: FeastClass): Bi {
+  return RANK_LABELS[rank];
+}
+
+/** Sundays/ferias aren't on the `FeastClass` duplex scale at all (that
+ * scale is for feasts), so this is a separate, plain-string lookup rather
+ * than another `formatRank` case — used for the final ordinal-temporal-
+ * label fallback (weekdays, Sundays with no named-feast/anchor-day/octave
+ * standing of their own). Pre-1955, an ordinary Sunday's own rank is
+ * Semiduplex regardless of whether it's additionally "privileged"
+ * (privilege is about resisting supersession, a property of
+ * `temporalCategory`, not a higher spot on the duplex scale) — so both
+ * Sunday categories share one label here. Both "Semiduplex" and "Feria"
+ * are already the real Latin words, so `en`/`la` coincide here too. */
+const TEMPORAL_CATEGORY_RANK_LABELS: Record<TemporalCategory, Bi> = {
+  'ordinary-sunday': bi('Semiduplex', 'Semiduplex'),
+  'privileged-sunday': bi('Semiduplex', 'Semiduplex'),
+  'ordinary-feria': bi('Feria', 'Feria'),
+  'privileged-feria-minor': bi('Feria', 'Feria'),
+  'privileged-feria': bi('Feria', 'Feria'),
+  'privileged-feria-major': bi('Feria', 'Feria'),
+};
+
+/**
+ * Explicit "which Vespers is this" status, for the Vespers hour header —
+ * distinct from `getDayLabel`'s name/rank/commemoration text, which is
+ * silent about *why* a given identity governs tonight (a reader has to
+ * already know, e.g., that St. Zephyrinus falls on tomorrow's date to
+ * realize this evening is anticipating him). Pass the result of
+ * `calendar/vespers.ts`'s `resolveEveningDay`, not a plain `resolveDay`,
+ * plus the originally-requested date — comparing the two directly (rather
+ * than checking `winner.vespersFrom`, which only ever gets set for a
+ * *sanctoral* tomorrow-winner, see `vespers.ts`'s `tagVespersFrom`) is
+ * what makes this correct even when tomorrow's winner is `temporal` (e.g.
+ * an ordinary Sunday winning outright over a merely-commemorated Simplex
+ * saint) — a case `winner.vespersFrom` can never detect since that field
+ * doesn't exist on the temporal variant of `DayWinner` at all.
+ */
+export function getVespersStatusLabel(day: LiturgicalDay, requestedDate: string): Bi {
+  if (day.date !== requestedDate) {
+    return bi('First Vespers (of tomorrow)', 'Vesperæ de sequenti');
+  }
+  return bi('Second Vespers (of today)', 'Vesperæ de hodierno');
+}
+
+/** Appended after a transferred-in winner's name/rank, before any
+ * commemorations — same shape as a rank parenthetical. Distinct wording
+ * from `TRANSFERRED_AWAY_LABEL` below on purpose: this winner's own rank
+ * parenthetical sits right next to it ("St. X (Duplex, transferred)"), so
+ * plain "transferred" already reads as "arrived via transfer" in context —
+ * but on the origin date there's no rank alongside it to anchor that
+ * reading, so the away-note spells out the direction explicitly instead of
+ * relying on that same subtlety a first-time reader wouldn't have. */
+const TRANSFERRED_LABEL = bi('transferred', 'translata');
+
+/** See `TRANSFERRED_LABEL`'s doc comment for why this is worded differently. */
+const TRANSFERRED_AWAY_LABEL = bi('transferred away', 'translata alio');
+
+/** "St. X (transferred away)" note for a date whose own native sanctoral
+ * candidate (`day.transferredAway`) couldn't be kept here — appended after
+ * everything else `getDayLabel` already found for this date's real
+ * winner/commemorations, since the departure is a footnote about a
+ * *different* saint, not part of this date's own identity. Deliberately
+ * names no landing date (see `transferredAway`'s own doc comment) — the
+ * point is just to tell a reader "not an omission, this office moved
+ * elsewhere," not to claim a specific destination that a later, unmodeled
+ * transfer chain could make wrong. */
+function transferredAwayNote(day: LiturgicalDay): Bi | undefined {
+  if (!day.transferredAway) {
+    return undefined;
+  }
+  const name = biName(day.transferredAway.candidate.name, day.transferredAway.candidate.nameLa);
+  return bi(`${name.en} (${TRANSFERRED_AWAY_LABEL.en})`, `${name.la} (${TRANSFERRED_AWAY_LABEL.la})`);
+}
+
+function withTransferNote(day: LiturgicalDay, label: Partial<Record<string, string>>): Partial<Record<string, string>> {
+  const note = transferredAwayNote(day);
+  if (!note) {
+    return label;
+  }
+  return { en: `${label.en} — ${note.en}`, la: `${label.la} — ${note.la}` };
+}
+
+/**
+ * The full "day being celebrated" label: the day's own primary identity
+ * (a sanctoral winner, a named temporal feast, a season's own anchor day,
+ * an octave governing the day, or the plain ordinal temporal label — in
+ * that precedence order) plus whatever `collectCommemorations` finds
+ * eligible to ride along with it. Each branch below only decides two
+ * things: what the primary label is, and what commemoration *groups* are
+ * eligible here and in what order — the actual filtering/formatting work
+ * is `collectCommemorations`'s alone, shared by every branch. Returns a
+ * `Partial<Record<string, string>>` keyed by language code (`en`/`la`),
+ * the same convention `hours/types.ts`'s `ResolvedText`/`ResolvedVerse`
+ * already use.
+ */
+export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>> {
+  if (day.winner.kind === 'sanctoral') {
+    // Octaves only ride along here on `ordinary-feria` — a day with real
+    // standing of its own (a Sunday, a privileged feria) doesn't mention
+    // an unrelated active octave even though it's technically active
+    // (live-verified: Aug 16, 2026, St. Joachim wins outright on a Sunday
+    // that's also within both St. Lawrence's and the Assumption's octave
+    // windows, and Divino Afflatu 1954's own commemoration line names
+    // only the Sunday, no octave).
+    const { sanctoral, temporal, octaves } = collectCommemorations(day, {
+      showOctaves: day.temporalCategory === 'ordinary-feria',
+    });
+    const rank = formatRank(day.winner.rank);
+    const winnerName = biName(day.winner.name, day.winner.nameLa);
+    const winner = day.winner.transferredFrom
+      ? bi(`${winnerName.en} (${rank.en}, ${TRANSFERRED_LABEL.en})`, `${winnerName.la} (${rank.la}, ${TRANSFERRED_LABEL.la})`)
+      : bi(`${winnerName.en} (${rank.en})`, `${winnerName.la} (${rank.la})`);
+    return withTransferNote(day, joinBi([winner, ...temporal, ...sanctoral, ...octaves]));
+  }
+
+  // A named temporal feast (Christmas, Pentecost, Marian Saturday, ...)
+  // shows its own name rather than the ordinal week label — same
+  // "winner displaces, doesn't combine" rule a sanctoral winner gets
+  // above. Most temporal ids don't have a record at all (see
+  // temporal-feasts.ts) and fall through further down.
+  const namedFeast = getTemporalFeastRecord(day.winner.id);
+  if (namedFeast) {
+    const name = biName(namedFeast.name, namedFeast.nameLa);
+    const primary = namedFeast.rank
+      ? bi(`${name.en} (${formatRank(namedFeast.rank).en})`, `${name.la} (${formatRank(namedFeast.rank).la})`)
+      : name;
+    const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+    return withTransferNote(day, joinBi([primary, ...sanctoral]));
+  }
+
+  // A season's own named anchor day (Trinity Sunday, Easter, Ash
+  // Wednesday, Epiphany) outranks an active octave, same reasoning as
+  // anchorDayName's own doc comment — checked before the octave case
+  // below since Trinity Sunday, e.g., also happens to be day 8 of
+  // Pentecost's octave, and the anchor name is what actually governs.
+  // Winner first, same as every other branch here — the anchor day is
+  // what's actually being celebrated even when a lesser saint rides along.
+  const anchorName = anchorDayName(day);
+  if (anchorName) {
+    const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+    return withTransferNote(day, joinBi([anchorName, ...sanctoral]));
+  }
+
+  // An active octave (St. Lawrence's, ...) is this day's real primary
+  // identity in the live engine, not a footnote — e.g. "Tertia die infra
+  // Octavam S. Laurentii Martyris", not "Wednesday in the 11th week after
+  // Trinity" — but *only* when the temporal day itself has no standing of
+  // its own (`ordinary-feria`), or a foreign octave's own effective rank
+  // is strong enough to clear a privileged day's real threshold anyway
+  // (`octaveGoverningPrivilegedDay` — the Immaculate Conception's own
+  // octave outright winning several of its days against Advent's
+  // privileged-feria-minor ferias, live-verified: Dec 9/10/12/14 at the
+  // octave's ordinary Semiduplex, Dec 15 at its own elevated Duplex majus
+  // closing day). Same gate as hours/resolve-common.ts's
+  // resolveOfficeWinner and for the same reason: live-verified
+  // counterexample is the Christmas Octave's own stack (Dec 30, e.g.,
+  // `privileged-feria-minor`), where the real title stays the temporal
+  // Sunday's own ("De Dominica Infra Octavam Nativitatis") with no octave
+  // name in it at all, regardless of rank — `octaveGoverningPrivilegedDay`
+  // excludes `christmastide` for exactly this reason (see its own doc
+  // comment) — this label agreeing with resolveOfficeWinner about which
+  // one wins is what makes "the office is Lawrence's" and "the label says
+  // Lawrence" consistent instead of two independent guesses that can
+  // disagree. When more than one octave is active at once
+  // (resolveActiveOctave), the highest-ranked wins the headline (ties
+  // broken by whichever started more recently) — every other active
+  // octave still gets named too, not dropped: live-verified real case,
+  // Aug 17 -- St. Lawrence's own elevated closing day wins the headline,
+  // but the Assumption's own day 3 (a real, distinct, simultaneously-
+  // active octave, not a duplicate of Lawrence's) still belongs in the
+  // label alongside St. Hyacinth's commemoration.
+  const activeOctave =
+    day.temporalCategory === 'ordinary-feria' ? resolveActiveOctave(day.date) : octaveGoverningPrivilegedDay(day);
+  if (activeOctave) {
+    const { sanctoral, octaves } = collectCommemorations(day, { showOctaves: true, excludeOctaveId: activeOctave.id });
+    const primary = octaveLabel(activeOctave);
+    return withTransferNote(day, joinBi([primary, ...octaves, ...sanctoral]));
+  }
+
+  const temporalRank = TEMPORAL_CATEGORY_RANK_LABELS[day.temporalCategory];
+  const label = (day.winner.kind === 'temporal' ? emberDayLabel(day.winner.id) : undefined) ?? temporalLabel(day);
+  const temporal = bi(`${label.en} (${temporalRank.en})`, `${label.la} (${temporalRank.la})`);
+  const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+  return withTransferNote(day, joinBi([temporal, ...sanctoral]));
+}

src/calendar/easter.ts

@@ -1,8 +1,29 @@
 // Computus (the date of Easter, and everything the temporal cycle hangs off
 // of it — Septuagesima, Ash Wednesday, Ascension, Pentecost, Trinity Sunday).
-// Not implemented yet: unused until milestone 4 (Lauds/Vespers), which is the
-// first hour content that actually varies by season. Deliberately left empty
-// rather than half-built ahead of need — see the "content stores" section of
-// the plan for why calendar-rule logic is being kept swappable rather than
-// front-loaded.
-export {};
+//
+// This is the Anonymous Gregorian algorithm (a.k.a. Meeus/Jones/Butcher),
+// valid for the whole Gregorian era (1583 onward). Hand-rolled rather than
+// pulling in a dependency: it's ~15 lines of pure integer arithmetic with a
+// long history of independent verification (see calendar/easter.test.ts),
+// not something that benefits from a library's abstraction or maintenance
+// surface for an app with zero runtime dependencies otherwise.
+import type { CalendarDate } from './date-math';
+
+export function easterSunday(year: number): CalendarDate {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const n = h + l - 7 * m + 114;
+  const month = Math.floor(n / 31);
+  const day = (n % 31) + 1;
+  return { year, month, day };
+}

src/calendar/ember-days.ts

@@ -0,0 +1,72 @@
+// Ember days (Quatuor Temporum) are privileged ferias, not named feasts —
+// structurally different from calendar/movable-feasts.ts's rank-contest
+// table. The precedence side (whether an occurring saint outranks the
+// feria) is already handled generically by resolveTemporalCategory
+// (September Ember days get their own `privileged-feria-minor` entry
+// there; Advent Ember days inherit Advent's own season default) feeding
+// the ordinary decideOccurrence contest -- this file ONLY handles content
+// identity: relabeling the day's own temporal id so an Ember day's real,
+// distinct proper content (collect, Matins readings) gets found instead
+// of inheriting whatever Sunday governs that week, the same way
+// applyMarianSaturday/applyChristmasOctaveSunday relabel a feria's own id
+// for the same reason.
+import type { Commemoration, DayWinner } from './types';
+import { septemberEmberDayOffset, adventEmberDayOffset } from './temporal';
+import { activeOctavesFor } from './octaves';
+
+const SEPTEMBER_EMBER_IDS: Record<number, string> = {
+  3: 'ember-september-wednesday',
+  5: 'ember-september-friday',
+  6: 'ember-september-saturday',
+};
+const ADVENT_EMBER_IDS: Record<number, string> = {
+  3: 'ember-advent-wednesday',
+  5: 'ember-advent-friday',
+  6: 'ember-advent-saturday',
+};
+
+function emberIdFor(isoDate: string): string | undefined {
+  const septemberOffset = septemberEmberDayOffset(isoDate);
+  if (septemberOffset !== undefined) {
+    return SEPTEMBER_EMBER_IDS[septemberOffset];
+  }
+  const adventOffset = adventEmberDayOffset(isoDate);
+  if (adventOffset !== undefined) {
+    return ADVENT_EMBER_IDS[adventOffset];
+  }
+  return undefined;
+}
+
+/**
+ * Run after applyOctaves, same gate that function's own doc comment and
+ * applyMarianSaturday both rely on: an active octave (the Nativity of the
+ * BVM's, Sep 8-15, can genuinely overlap a late-anchored September Ember
+ * week in some years) already has real standing of its own and shouldn't
+ * be silently relabeled out from under it.
+ *
+ * Two cases, mirroring how a "Commemoratio ad Laudes tantum" reads
+ * live against the reference engine: if the feria itself is what's
+ * winning (`winner.kind === 'temporal'`, i.e. resolveTemporalCategory's
+ * `privileged-feria-minor` threshold already beat whatever saint was
+ * there, or nothing was there at all), its id is swapped for the Ember
+ * day's own — real content gets found where it wouldn't otherwise be. If
+ * a saint won outright instead (strong enough to clear that threshold),
+ * the winner is left alone but the Ember day is still commemorated
+ * alongside it, so its own collect/readings still surface (this app
+ * doesn't model the "Laudes only" hour-scoping nuance — same simplification
+ * level as every other commemoration here, not a new gap).
+ */
+export function applyEmberDay(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  if (activeOctavesFor(isoDate).length > 0) {
+    return winner;
+  }
+  const emberId = emberIdFor(isoDate);
+  if (!emberId) {
+    return winner;
+  }
+  if (winner.kind === 'temporal') {
+    return { kind: 'temporal', id: emberId };
+  }
+  commemorations.push({ kind: 'temporal', id: emberId });
+  return winner;
+}

src/calendar/feasts.ts

@@ -1,6 +1,166 @@
 // Sanctoral occurrence resolution: given a date, which saint(s) are
 // assigned via data/calendar/sanctoral-calendar.yml's day -> saint-id
-// mapping, and their rank/propers/common from data/calendar/saints/<id>.yml.
-// See calendar/temporal.ts for the separate Easter/fixed-date resolution.
-// Unused until milestone 4.
-export {};
+// mapping, and their rank from data/calendar/saints/<id>.yml. See
+// calendar/temporal.ts for the separate temporal-cycle resolution, and
+// calendar/commemorations.ts for how a candidate returned here actually
+// gets weighed against the day's temporal standing.
+//
+// Doesn't resolve clashes *among* multiple saints sharing a date — real
+// practice has its own precedence/commemoration rules for that too, not
+// modeled here. If a day has more than one candidate, calendar/index.ts
+// just picks the highest-ranked as the day's sole sanctoral contender.
+import type { FeastClass, OctaveConfig } from './types';
+import sanctoralCalendarData from '../data/calendar/sanctoral-calendar.yml';
+
+export interface SaintRecord {
+  id: string;
+  name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
+  rank: FeastClass;
+  common: string;
+  propers: string | null;
+  /** Fallback id for Prime/Terce/Sext/None's antiphon/chapter when this
+   * saint has no proper file of their own for a given hour (see
+   * hours/resolve-common.ts's resolveMinorHourAntiphon/Chapter) — a
+   * *different* id than `common` above, deliberately: live-verified that
+   * the minor hours don't always draw from the same Common category as
+   * the saint's overall classification. E.g. both Chair of St. Peter
+   * feasts are `common: common-of-an-apostle` (Peter's own rank/collect
+   * classification), but their Prime/Terce/Sext/None content is drawn
+   * from the Common of a Confessor Bishop instead (Peter considered as
+   * bishop, for that specific commemoration) — `minorHoursCommon:
+   * common-of-a-confessor-bishop` captures that without corrupting the
+   * saint's real `common` field. Absent for saints with no shared-Common
+   * minor-hour content (either fully proper, or not yet authored).
+   */
+  minorHoursCommon?: string;
+  /**
+   * Fallback id for the day collect (`getDayCollect`) when this saint has
+   * no proper collect of their own (`propers` may still be non-null —
+   * e.g. St. Agatha and St. Lucy both have a proper antiphon but a
+   * Common-sourced collect) — the *full* id of a `data/propers/common/
+   * collect-c*.yml` file (e.g. `collect-c2-1`, not `c2-1` — no suffix
+   * gets appended), a *template* with a literal `{N}` standing in for
+   * the saint's own name, substituted via `collectName` below.
+   * Deliberately more granular than `common` above: the reference
+   * source's own Commune files split e.g. "Common of a Martyr Bishop"
+   * into several differently-worded collect templates (its own `C2`,
+   * `C2-1`, `C2a-1`, `C2b`, `C2b-1` — no clean semantic label recovered
+   * for *why* each saint gets a particular one, so these ids trace
+   * straight back to the source's own naming, e.g. `collect-c2-1`,
+   * rather than inventing a name that might be wrong.
+   */
+  collectCommon?: string;
+  /** The `{N}` substitution values for `collectCommon`'s template, in
+   * whatever grammatical case that specific template's own placeholder
+   * position needs — taken directly from the reference source's own
+   * per-saint `[Name]` section (Latin/English/Sancti or SanctiM
+   * `MM-DD.txt`), not re-declined by hand. Arrays, filled in
+   * left-to-right against the template's own `{N}` occurrences in
+   * document order — most saints need exactly one name, but several
+   * Common templates (e.g. `collect-c3`, two co-named Martyr-Bishops)
+   * have two or more `{N}` placeholders for a group commemorated
+   * together, one array entry per saint in the group. */
+  collectName?: { la: string[]; en: string[] };
+  /**
+   * Fallback id for Lauds' Benedictus antiphon (`getBenedictusAntiphon`)
+   * when this saint has no proper `${propers}-antiphon` of their own —
+   * `data/propers/common/benedictus-antiphon-${id}.yml`. Unlike
+   * `collectCommon`, no name-substitution template: live-verified every
+   * Common category's Benedictus antiphon in current use is name-free
+   * text (the source's own `Commune/C4a.txt`, Doctor, is the one
+   * exception — has a `{N}`-shaped "beáte N." — but no saint on this
+   * calendar draws from it yet, so no substitution mechanism was built
+   * for this field; revisit if that changes). Often, but not always, the
+   * same category as `minorHoursCommon` below (both were live-verified
+   * independently per saint, not assumed identical).
+   */
+  benedictusCommon?: string;
+  /**
+   * The `{N}` substitution value(s) for the Matins invitatory antiphon's
+   * own Common template (`hours/matins.ts`'s `resolveMatinsInvitatoryText`,
+   * via `hours/resolve-common.ts`'s `substituteName` — the same helper
+   * `getDayCollect` already uses for `collectCommon`/`collectName`, just a
+   * separate field here since the invitatory's own `{N}` position needs
+   * its own grammatical case, not necessarily the same one `collectName`
+   * was declined for). Currently only needed for Common-of-a-Holy-Woman
+   * (`Commune/C7.txt`'s own `[Invit]`, "Laudémus Deum nostrum * In
+   * confessióne beátæ N.." — genitive singular, e.g. "Marthæ") — every
+   * other Common category in use has name-free invitatory text. Absent
+   * for saints whose Common invitatory antiphon needs no substitution. */
+  invitatoryName?: { la: string[]; en: string[] };
+  /** See calendar/types.ts's OctaveConfig doc comment. Absent for the vast
+   * majority of saints — only ones with a real octave declare it. */
+  octave?: OctaveConfig;
+  /** For a `rank: vigil` record only — the real id of the feast this is
+   * the eve of (e.g. `st-andrew`, not derivable from this record's own id
+   * by stripping a `vigil-of-` prefix: several vigils' ids don't match
+   * their feast's id exactly — `vigil-of-the-assumption` vs `assumption`,
+   * `vigil-of-st-james` vs `st-james-the-greater`). Lets
+   * calendar/vespers.ts's evening-anticipation merge recognize "today's
+   * Vigil is being displaced by the very feast it's the eve of" precisely
+   * (rather than guessing from date adjacency alone) and skip
+   * commemorating the Vigil redundantly alongside its own feast. */
+  vigilOf?: string;
+  /** This feast, when it keeps its own Second Vespers (see
+   * calendar/vespers.ts's keepsOwnSecondVespers), refuses to commemorate
+   * whatever wins the following day there — the feast-side mirror of a
+   * privileged Sunday/major-feria refusing a weak commemoration *back*
+   * (calendar/commemorations.ts), which vu had no equivalent of at all
+   * until this field. Modeled as an explicit per-feast flag rather than
+   * porting the reference engine's fractional-rank privilege matrix
+   * (crank/rank thresholds, a "Festum Domini" distinction, an outright
+   * hardcoded pair exception for Most Precious Blood vs. the Sacred
+   * Heart on the rare late-Easter date they collide) — that matches this
+   * repo's own "explicit per-feast fact, verified against the live
+   * engine one date at a time" convention (same as `vigilOf` above)
+   * rather than a general formula applied blanket and hoped correct.
+   * Absent (the default) preserves today's status quo: any sanctoral
+   * successor gets commemorated regardless of rank. Not yet set on any
+   * saint — add only after checking a specific date against the live
+   * reference engine, not speculatively for every `duplex-1-classis`
+   * feast. NOT a fit for the Precious Blood/Sacred Heart case itself
+   * (that exclusion is specific to one neighbor, not "never commemorate
+   * anyone" — see this field's own doc comment above) — see TODO.md. */
+  forbidsSuccessorCommemoration?: true;
+}
+
+const sanctoralCalendar = sanctoralCalendarData as { days: Record<string, string[]> };
+
+const saintModules = import.meta.glob<{ default: SaintRecord }>('../data/calendar/saints/*.yml', {
+  eager: true,
+});
+
+const saintsById = new Map<string, SaintRecord>();
+for (const mod of Object.values(saintModules)) {
+  saintsById.set(mod.default.id, mod.default);
+}
+
+export interface SanctoralCandidate {
+  id: string;
+  name: string;
+  nameLa?: string;
+  rank: FeastClass;
+}
+
+/** Which saint(s) (if any) are assigned to this date. `isoDate`'s year is ignored — the sanctoral cycle repeats every civil year. */
+/** The saint's full record — used when something more than id/name/rank is
+ * needed, e.g. hours/resolve-common.ts's getDayCollect looking up whether
+ * a real collect has been authored for a winning saint. */
+export function getSaintRecord(id: string): SaintRecord | undefined {
+  return saintsById.get(id);
+}
+
+export function getSanctoralCandidatesFor(isoDate: string): SanctoralCandidate[] {
+  const monthDay = isoDate.slice(5);
+  const ids = sanctoralCalendar.days[monthDay] ?? [];
+  return ids.map((id) => {
+    const saint = saintsById.get(id);
+    if (!saint) {
+      throw new Error(`sanctoral-calendar.yml references unknown saint id '${id}'`);
+    }
+    return { id: saint.id, name: saint.name, nameLa: saint.nameLa, rank: saint.rank };
+  });
+}

src/calendar/index.ts

@@ -1,35 +1,512 @@
-import type { LiturgicalDay } from './types';
+import type { Commemoration, DayWinner, FeastClass, LiturgicalDay, SanctoralIdentity, TemporalCategory } from './types';
 import { weekdayOf } from './weekday';
+import { resolveSeason, resolveTemporalCategory, easterOffsetOf } from './temporal';
+import { resolveTemporalId } from './temporal-id';
+import { getSanctoralCandidatesFor } from './feasts';
+import { decideOccurrence, compareFeastClass, isAtLeast, type OccurrenceResult } from './commemorations';
+import { resolveCollision } from './collision';
+import { addDays, toIsoDate } from './date-math';
+import { easterSunday } from './easter';
+import { activeOctavesFor, strictestThreshold } from './octaves';
+import { applyMovableFeasts } from './movable-feasts';
+import { applyEmberDay } from './ember-days';
+
+/**
+ * A day's occurrence considered on its own — no awareness of what an
+ * adjacent day might be trying to transfer in. `resolveDay` calls this
+ * for the date itself and for yesterday/tomorrow (to check for an
+ * inbound transfer) without ever recursing into their own adjacent-day
+ * checks — that's what keeps this from being mutually recursive. The one
+ * exception, `easterOctaveBacklogFor`, deliberately calls this for up to
+ * 15 fixed days (Palm Sunday through Low Sunday) regardless of `isoDate`
+ * — see its own doc comment.
+ */
+function resolveNativeOccurrence(isoDate: string): { temporalCategory: TemporalCategory; result: OccurrenceResult } {
+  const weekday = weekdayOf(isoDate);
+  const season = resolveSeason(isoDate);
+  const temporalCategory = resolveTemporalCategory(isoDate, season, weekday);
+  const temporalId = resolveTemporalId(isoDate);
+
+  // Multiple saints sharing a date is its own small occurrence contest,
+  // resolved the same way a transfer landing is — see calendar/collision.ts.
+  const candidates = getSanctoralCandidatesFor(isoDate);
+  let topCandidate: SanctoralIdentity | null = null;
+  const clashCommemorations: Commemoration[] = [];
+  for (const candidate of candidates) {
+    if (!topCandidate) {
+      topCandidate = candidate;
+      continue;
+    }
+    const collision = resolveCollision(candidate, topCandidate);
+    clashCommemorations.push(...collision.commemorations);
+    if (collision.winner.kind === 'sanctoral') {
+      topCandidate = {
+        id: collision.winner.id,
+        name: collision.winner.name,
+        nameLa: collision.winner.nameLa,
+        rank: collision.winner.rank,
+      };
+    }
+  }
+
+  const result = decideOccurrence(temporalCategory, temporalId, topCandidate);
+  result.commemorations.push(...clashCommemorations);
+  return { temporalCategory, result };
+}
+
+function applyIncomingTransfer(
+  candidate: SanctoralIdentity,
+  temporalCategory: TemporalCategory,
+  winner: DayWinner,
+  commemorations: Commemoration[],
+  fromDate: string,
+): DayWinner {
+  if (temporalCategory === 'privileged-feria-major') {
+    // Never a landing spot for any rank, and never even a bare
+    // commemoration (commemorations.ts's own case already guarantees
+    // this — a `winner.kind === 'sanctoral'` day never actually happens
+    // in this category, so `decideOccurrence` alone would already
+    // produce this same no-op; kept explicit as a documented short-
+    // circuit). A candidate impeded here — Holy Week, the Easter Octave,
+    // Low Sunday — doesn't chain forward day-by-day the way an ordinary
+    // transfer does; see `applyEasterOctaveBacklog` in `resolveDay` for
+    // its own dedicated mechanism instead. The lesser privileged-feria
+    // tier doesn't need any of this — ordinary collision/transfer logic
+    // is fine there, same as any ordinary-sunday landing.
+    return winner;
+  }
+  // Tags the returned winner with where it transferred from, but only when
+  // the candidate actually ended up winning here — a collision loss (the
+  // candidate merely commemorated, incumbent keeps the day) isn't a landing.
+  const tagIfLanded = (result: DayWinner): DayWinner =>
+    result.kind === 'sanctoral' && result.id === candidate.id ? { ...result, transferredFrom: fromDate } : result;
+  // Same tagging, but for the candidate's own *commemoration* — it still
+  // needs marking as arrived-via-transfer even when it lost the landing
+  // day outright (a collision loss, or falling below the landing day's own
+  // threshold in decideOccurrence) rather than merely being naturally due
+  // for commemoration here.
+  const tagCommemorations = (result: Commemoration[]): Commemoration[] =>
+    result.map((c) => (c.kind === 'sanctoral' && c.id === candidate.id ? { ...c, transferredFrom: fromDate } : c));
+  if (winner.kind === 'temporal') {
+    // Found via real data: a transferred-in Simplex saint was blindly
+    // winning outright even when it landed on a privileged Sunday (Trinity
+    // Sunday, specifically) — the arriving candidate needs to go through
+    // the *same* precedence rules a native occurrence would have used,
+    // not just take over because nothing else was assigned here.
+    const decided = decideOccurrence(temporalCategory, winner.id, candidate);
+    commemorations.push(...tagCommemorations(decided.commemorations));
+    // If the candidate fails here too (decided.transfer set), it's simply
+    // not delivered — every category reaching this branch only ever
+    // needs a single hop (see `applyEasterOctaveBacklog` for the one
+    // multi-day case, handled separately, not through here).
+    return tagIfLanded(decided.winner);
+  }
+  const collision = resolveCollision(candidate, winner);
+  commemorations.push(...tagCommemorations(collision.commemorations));
+  return tagIfLanded(collision.winner);
+}
+
+// The minimum rank worth carrying out of the Palm-Sunday-through-Low-
+// Sunday span at all (see `applyEasterOctaveBacklog` below) — anything
+// weaker than this just lapses for the year, same as it already gets no
+// trace *within* the span itself (commemorations.ts's `privileged-feria-
+// major`/`privileged-sunday` cases). Per direct instruction (2026-09-01):
+// this is the same threshold the sibling in-place-commemoration rule
+// used before it was found wrong — that number wasn't the mistake, only
+// which question it was answering.
+const EASTER_OCTAVE_BACKLOG_FLOOR: FeastClass = 'duplex-majus';
+
+/**
+ * Every candidate impeded anywhere from Palm Sunday through Low Sunday
+ * inclusive (`easterOffsetOf` -7 through +7) that clears
+ * `EASTER_OCTAVE_BACKLOG_FLOOR`, in native-date order — the backlog
+ * `applyEasterOctaveBacklog` draws from. Judged only by each day's own
+ * `resolveNativeOccurrence`, never a fully `resolveDay`-resolved one
+ * (same convention `applyIncomingTransfer` already uses).
+ */
+function easterOctaveBacklogFor(year: number): { candidate: SanctoralIdentity; fromDate: string }[] {
+  const easterIso = toIsoDate(easterSunday(year));
+  const backlog: { candidate: SanctoralIdentity; fromDate: string }[] = [];
+  for (let offset = -7; offset <= 7; offset++) {
+    const date = addDays(easterIso, offset);
+    const candidate = resolveNativeOccurrence(date).result.transfer?.candidate;
+    if (candidate && isAtLeast(candidate.rank, EASTER_OCTAVE_BACKLOG_FLOOR)) {
+      backlog.push({ candidate, fromDate: date });
+    }
+  }
+  return backlog;
+}
+
+// Generous headroom over any realistic backlog length (the whole span is
+// 15 days; vu's own calendar has never produced more than a handful of
+// duplex-majus+ candidates in it) — exists purely so a date far removed
+// from any Easter doesn't pay for an `easterOctaveBacklogFor` computation
+// it could never need.
+const MAX_EASTER_OCTAVE_BACKLOG_DAYS = 60;
+
+/**
+ * The Nth day after Low Sunday celebrates the Nth candidate in that
+ * year's backlog (native-date order) — winning outright, no rank fight
+ * against whatever would have natively been there, which is demoted to a
+ * commemoration instead — one candidate per day until the backlog is
+ * exhausted. Per direct instruction (2026-09-01): not a generic multi-day
+ * cascade/queue (this app already has real precedent for stacking
+ * commemorations, so a spread-out cascade wasn't the right shape), and
+ * not a same-day batch either (only one candidate surfaces per day, same
+ * as any other transfer landing in this app) — a fixed, deterministic
+ * position for each backlog candidate rather than a "first day not
+ * already spoken for" search.
+ */
+function applyEasterOctaveBacklog(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  const offset = easterOffsetOf(isoDate);
+  if (offset <= 7 || offset > 7 + MAX_EASTER_OCTAVE_BACKLOG_DAYS) {
+    return winner;
+  }
+  const n = offset - 7;
+  const backlog = easterOctaveBacklogFor(Number(isoDate.slice(0, 4)));
+  const entry = backlog[n - 1];
+  if (!entry) {
+    return winner;
+  }
+  if (winner.kind === 'sanctoral') {
+    commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
+  }
+  return { kind: 'sanctoral', ...entry.candidate, transferredFrom: entry.fromDate };
+}
 
 /**
  * Resolves everything about a given day *except* hour content — weekday,
- * season, and any occurring feasts. Season and occurring feasts are stubs
- * until calendar/easter.ts and calendar/feasts.ts land at milestone 4;
- * hours that only need weekday (Prime, Compline, Terce, Sext, None) can
- * already rely on this fully.
+ * season, temporal precedence category, and the day's real winner plus
+ * whatever's commemorated alongside it (calendar/commemorations.ts,
+ * calendar/collision.ts, calendar/transfer signaling all feed into this).
  */
 export function resolveDay(isoDate: string): LiturgicalDay {
-  return {
-    date: isoDate,
-    weekday: weekdayOf(isoDate),
-    // Placeholder string, not a real resolution — real season/temporal-id
-    // lookup (data/calendar/easter-offsets.yml + fixed-date-calendar.yml)
-    // lands at milestone 4.
-    season: 'trinitytide',
-    occurring: [],
-  };
+  const weekday = weekdayOf(isoDate);
+  const season = resolveSeason(isoDate);
+  const { temporalCategory, result } = resolveNativeOccurrence(isoDate);
+
+  let winner = result.winner;
+  const commemorations = [...result.commemorations];
+
+  const yesterdayIso = addDays(isoDate, -1);
+  const yesterday = resolveNativeOccurrence(yesterdayIso);
+  // A candidate impeded anywhere from Palm Sunday through Low Sunday
+  // (`easterOffsetOf` -7 through +7) is exclusively
+  // `applyEasterOctaveBacklog`'s to place — skipped here so it isn't
+  // *also* picked up by this ordinary single-hop check (real bug found
+  // 2026-09-01: Low Sunday's own transfer was leaking into the very next
+  // day's ordinary yesterday-check, landing/commemorating a candidate
+  // below the backlog's own rank floor). Scoped to that specific span,
+  // not `privileged-sunday` generally — an ordinary privileged Sunday
+  // elsewhere (Advent, Septuagesima–Passiontide) still uses this normal
+  // single-hop path same as before.
+  const yesterdayOffset = easterOffsetOf(yesterdayIso);
+  const yesterdayInEasterSpan = yesterdayOffset >= -7 && yesterdayOffset <= 7;
+  if (yesterday.result.transfer?.direction === 'forward' && !yesterdayInEasterSpan) {
+    winner = applyIncomingTransfer(yesterday.result.transfer.candidate, temporalCategory, winner, commemorations, yesterdayIso);
+  }
+  const tomorrowIso = addDays(isoDate, 1);
+  const tomorrow = resolveNativeOccurrence(tomorrowIso);
+  if (tomorrow.result.transfer?.direction === 'backward') {
+    winner = applyIncomingTransfer(tomorrow.result.transfer.candidate, temporalCategory, winner, commemorations, tomorrowIso);
+  }
+  // The one case that single yesterday-check can't reach: anything
+  // impeded within Holy Week/Easter Day/the Octave/Low Sunday itself
+  // (all `privileged-feria-major`/`privileged-sunday`, which never
+  // accept a landing at all) needs its own dedicated mechanism — see
+  // `applyEasterOctaveBacklog`'s own doc comment.
+  winner = applyEasterOctaveBacklog(isoDate, winner, commemorations);
+
+  winner = applyOctaves(isoDate, winner, commemorations);
+  winner = applyEmberDay(isoDate, winner, commemorations);
+  winner = applyMarianSaturday(isoDate, weekday, temporalCategory, winner, commemorations);
+  winner = applyChristmasOctaveSunday(isoDate, weekday, winner, commemorations);
+  winner = applyMovableFeasts(isoDate, winner, commemorations);
+  applyEpiphany6Commemoration(isoDate, commemorations);
+  applyAdventFourVigilCommemoration(isoDate, weekday, commemorations);
+
+  // This date's own native candidate (if any) couldn't be kept here and
+  // moved on instead — see calendar/types.ts's `transferredAway` doc
+  // comment for why this is tracked separately from `Commemoration`, and
+  // why no landing date is recorded.
+  const transferredAway = result.transfer ? { candidate: result.transfer.candidate } : undefined;
+
+  return { date: isoDate, weekday, season, temporalCategory, winner, commemorations, transferredAway };
+}
+
+/**
+ * Real rubric, confirmed 2026-08: when the 6th Sunday after Epiphany is
+ * bumped by Septuagesima — i.e. only in years where the 5th Sunday after
+ * Epiphany was the last one to actually occur — it's commemorated on the
+ * Saturday immediately before Septuagesima, on top of whatever else that
+ * Saturday already resolved to. Distinct from (and doesn't imply) the
+ * later "resumed post-Epiphany Sunday" transfer handled in
+ * temporal-id.ts's post-Pentecost overflow branch — that one applies to
+ * *every* skipped post-Epiphany Sunday, not just VI; this Saturday
+ * commemoration is VI's alone. Purely additive: no `Commemoration` variant
+ * needed beyond the existing `{ kind: 'temporal' }` one, since
+ * hours/resolve-common.ts's getDayCollects already resolves any temporal
+ * commemoration's own `${id}-collect` for free.
+ */
+function applyEpiphany6Commemoration(isoDate: string, commemorations: Commemoration[]): void {
+  const year = Number(isoDate.slice(0, 4));
+  const septuagesimaStart = addDays(toIsoDate(easterSunday(year)), -63);
+  const saturdayBeforeSeptuagesima = addDays(septuagesimaStart, -1);
+  if (isoDate !== saturdayBeforeSeptuagesima) {
+    return;
+  }
+  const lastEpiphanySunday = addDays(septuagesimaStart, -7);
+  if (resolveTemporalId(lastEpiphanySunday) !== 'post-epiphany-5') {
+    return;
+  }
+  commemorations.push({ kind: 'temporal', id: 'post-epiphany-6' });
+}
+
+/**
+ * When Advent 4's own Sunday lands on Dec 24 (its latest possible date),
+ * `resolveTemporalId` already gives that day the Vigil of Christmas's own
+ * identity (`vigil-of-christmas` — collect, Lauds antiphons, Matins Gospel
+ * nocturn), matching the reference engine's own rule that the Vigil's rank
+ * governs. Per direct instruction (2026-08), unlike the reference engine's
+ * own `no commemoratio` for this exact day, Advent 4 itself is still
+ * commemorated here — the Sundays of Advent have real standing of their
+ * own, distinct from an ordinary saint quietly ceding to a Vigil. Purely
+ * additive, same shape as applyEpiphany6Commemoration just above: no new
+ * `Commemoration` variant needed, `getDayCollects` already resolves any
+ * `{ kind: 'temporal' }` commemoration's own `${id}-collect` for free.
+ * `advent-4` is hardcoded rather than recomputed because Dec 24 always
+ * falls at or after Advent's own 4th Sunday by construction (it's the
+ * latest date Advent's 4th Sunday can ever land on).
+ */
+function applyAdventFourVigilCommemoration(
+  isoDate: string,
+  weekday: ReturnType<typeof weekdayOf>,
+  commemorations: Commemoration[],
+): void {
+  if (isoDate.slice(5) === '12-24' && weekday === 'sunday') {
+    commemorations.push({ kind: 'temporal', id: 'advent-4' });
+  }
+}
+
+/**
+ * Per direct instruction, scoped to exactly Dec 26-30 — every year
+ * contains exactly one real Sunday somewhere in that 5-day window.
+ *
+ * On whichever of Dec 26-29 it actually falls, Nat1-0 (the Sunday within
+ * the Octave of the Nativity) always wins outright, full stop — no rank
+ * check at all, a deliberate departure from what Monastic 1617 itself
+ * does there (a Duplex-II-classis saint — Stephen/John/Innocents — beats
+ * the Sunday there in the real engine; see TODO.md). The displaced
+ * saint isn't even commemorated in place; he reappears in full on Dec
+ * 30 instead — the block's one date with no fixed saint of its own —
+ * rather than the general privileged-sunday transfer/commemorate split
+ * used everywhere else. Dec 30 itself, on a year it's the *actual*
+ * Sunday (nothing displaced), resolves normally: Nat1-0 wins clean since
+ * nothing was ever assigned there to begin with.
+ */
+function applyChristmasOctaveSunday(
+  isoDate: string,
+  weekday: ReturnType<typeof weekdayOf>,
+  winner: DayWinner,
+  commemorations: Commemoration[],
+): DayWinner {
+  const [year, monthStr, dayStr] = isoDate.split('-');
+  if (monthStr !== '12') {
+    return winner;
+  }
+  const day = Number(dayStr);
+
+  if (day >= 26 && day <= 29 && weekday === 'sunday') {
+    // The displaced saint isn't commemorated in place (per this
+    // function's own doc comment, "he reappears in full on Dec 30
+    // instead") — strip the sanctoral commemoration `decideOccurrence`
+    // already pushed for him before this override ran, the same
+    // candidate the Dec 30 branch below will look up again to revive.
+    // Only became reachable once `commemorations.ts`'s `ordinary-sunday`
+    // case started commemorating Semiduplex/Simplex in place instead of
+    // transferring them (see its own doc comment) — before that fix, a
+    // `transfer` signal carried the candidate forward instead of a
+    // commemoration, so there was nothing here to strip.
+    const displaced = getSanctoralCandidatesFor(isoDate)[0];
+    if (displaced) {
+      const idx = commemorations.findIndex((c) => c.kind === 'sanctoral' && c.id === displaced.id);
+      if (idx !== -1) {
+        commemorations.splice(idx, 1);
+      }
+    }
+    return { kind: 'temporal', id: 'christmas-octave-sunday' };
+  }
+
+  if (day === 30) {
+    for (let d = 26; d <= 29; d++) {
+      const candidateDate = `${year}-12-${String(d).padStart(2, '0')}`;
+      if (weekdayOf(candidateDate) !== 'sunday') {
+        continue;
+      }
+      const displaced = getSanctoralCandidatesFor(candidateDate)[0];
+      if (!displaced) {
+        break;
+      }
+      // Drop the now-redundant "Octave of <displaced>" commemoration —
+      // applyOctaves already pushed one above, using Dec 30's *original*
+      // temporal winner; now that the displaced saint is winning the day
+      // outright instead, commemorating his own octave alongside himself
+      // would be the same redundancy applyOctaves' own `isSelf` check
+      // already avoids on a saint's actual day.
+      const idx = commemorations.findIndex((c) => c.kind === 'octave' && c.id === displaced.id);
+      if (idx !== -1) {
+        commemorations.splice(idx, 1);
+      }
+      return { kind: 'sanctoral', id: displaced.id, name: displaced.name, nameLa: displaced.nameLa, rank: displaced.rank };
+    }
+  }
+
+  return winner;
+}
+
+/**
+ * Layered on top of everything above, same spirit as applyOctaves: never
+ * changes decideOccurrence's own rules, just relabels the result on a free
+ * Saturday. Real standing of its own, but only really a Simplex-strength
+ * one (per direct instruction, refined from an earlier "mirrors
+ * privileged-feria-minor exactly" pass that also swept in Vigils, which
+ * turned out wrong: a Vigil keeps forcing its own primacy on a Saturday
+ * the same way it already does any other day, same as Simplex always has
+ * — see calendar/commemorations.ts's own transferDirectionOf for Vigil's
+ * usual special standing elsewhere) — a Simplex saint alone loses to it
+ * and is commemorated instead; anything Semiduplex-or-higher, or a Vigil,
+ * still wins outright and this never applies. `ordinary-feria` is the
+ * only category this touches — every privileged season/day (Ember
+ * Saturdays, Advent, Lent, ...) already has its own real standing and
+ * keeps it untouched.
+ *
+ * The relabel (not just leaving `winner` as the plain temporal id) is
+ * what lets getDayLabel/getBenedictusAntiphon/getDayCollects/getLaudsPsalmodyOverride
+ * all recognize this day as "Our Lady's Saturday" rather than an
+ * anonymous feria — see data/calendar/temporal-feasts/marian-saturday.yml.
+ *
+ * Also gated on no octave being active: `ordinary-feria` isn't only "a
+ * genuinely free Saturday" — Pentecost's own Ember Saturday is
+ * deliberately classified this way too (see data/calendar/temporal-
+ * categories.yml), specifically so the octave layer above can reach it.
+ * Found via a real regression: without this gate, Pentecost's Ember
+ * Saturday got relabeled "Our Lady's Saturday" right out from under the
+ * octave commemoration that's supposed to govern it.
+ */
+function applyMarianSaturday(
+  isoDate: string,
+  weekday: ReturnType<typeof weekdayOf>,
+  temporalCategory: TemporalCategory,
+  winner: DayWinner,
+  commemorations: Commemoration[],
+): DayWinner {
+  if (weekday !== 'saturday' || temporalCategory !== 'ordinary-feria' || activeOctavesFor(isoDate).length > 0) {
+    return winner;
+  }
+  const MARIAN_SATURDAY: DayWinner = { kind: 'temporal', id: 'marian-saturday' };
+  if (winner.kind === 'temporal') {
+    return MARIAN_SATURDAY;
+  }
+  if (winner.rank !== 'simplex') {
+    return winner;
+  }
+  commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
+  return MARIAN_SATURDAY;
+}
+
+/**
+ * Layered on top of everything above, not part of it: an octave doesn't
+ * change how a single day's own precedence contest is decided, it just
+ * (a) adds a commemoration for every octave still active on this date, and
+ * (b) occasionally overrides the winner when the occurring saint doesn't
+ * outrank the strictest active octave's threshold, in which case the day
+ * reverts to its own temporal identity and the saint is commemorated
+ * instead — same "demoted, not dropped" shape as every other
+ * commemoration rule in this file.
+ *
+ * A *tie against an octave's own elevated closing day* goes to the
+ * octave, not the occurring saint — live-verified counterexample: St.
+ * Hyacinth (plain Duplex, Aug 17) against St. Lawrence's own octave
+ * closing day that same date (also Duplex, via `closingDayRank`'s
+ * default) — the reference engine's own alternate block for that date is
+ * titled "Commemoratio S. Hyacinthi Confessoris", i.e. Hyacinth is the
+ * one merely commemorated there, Lawrence's own elevated closing day
+ * keeps the office. Matches this file's own `collision.ts` precedent for
+ * the analogous sanctoral-vs-sanctoral tie ("Ties favor `native` — the
+ * incoming feast is the guest here"): the closing day is the
+ * already-running incumbent's own elevated day, an occurring saint is
+ * the guest, and a guest needs to actually outrank it to displace it,
+ * not just match it.
+ *
+ * A tie against an *ordinary* (non-closing) octave day's threshold still
+ * favors the occurring saint, unchanged from the original behavior —
+ * confirmed by two already-verified, live-sourced counterexamples this
+ * file's own tests carry: St. Thomas of Canterbury (plain Semiduplex,
+ * Dec 29) wins outright against the Christmas Octave's own ordinary
+ * `wins: semiduplex` default that day (not its closing day, Jan 1), and
+ * St. Nicholas of Tolentino (plain Semiduplex, Sep 10) likewise against
+ * the Nativity of the BVM's octave (day 3 of 8, not closing). Only a
+ * closing day's own elevated rank carries the "already the incumbent"
+ * weight that breaks a tie in the octave's favor.
+ */
+function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  const octaves = activeOctavesFor(isoDate);
+  if (octaves.length === 0) {
+    return winner;
+  }
+
+  let resolvedWinner = winner;
+  if (winner.kind === 'sanctoral') {
+    const threshold = strictestThreshold(octaves);
+    const cmp = compareFeastClass(winner.rank, threshold);
+    const tiedAgainstClosingDay = cmp === 0 && octaves.some((o) => o.isClosingDay && compareFeastClass(o.wins, threshold) === 0);
+    if (cmp < 0 || tiedAgainstClosingDay) {
+      const isOneOfTheseOctaves = octaves.some((o) => o.id === winner.id);
+      if (!isOneOfTheseOctaves) {
+        commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
+        resolvedWinner = { kind: 'temporal', id: resolveTemporalId(isoDate) };
+      }
+    }
+  }
+
+  for (const octave of octaves) {
+    const isSelf = resolvedWinner.kind === 'sanctoral' && resolvedWinner.id === octave.id;
+    // An octave's own day-1, when nothing displaced it, already *is* that
+    // feast (via the day's own temporal identity) — commemorating it
+    // again alongside itself would be redundant.
+    const isOwnStartDay = octave.dayNumber === 1 && resolvedWinner.kind === 'temporal';
+    if (!isSelf && !isOwnStartDay) {
+      commemorations.push({ kind: 'octave', id: octave.id, name: octave.name, nameLa: octave.nameLa });
+    }
+  }
+
+  return resolvedWinner;
 }
 
 /**
  * The Sunday/feast-vs-ferial split that several hours' propers key off of
  * (Prime's capitulum and Preces, so far): a plain weekday with nothing else
- * going on gets the "ferial" form, Sunday or an occurring feast gets the
- * fuller "Sunday/feast" form. `occurring` is always [] until milestone 4, so
- * today this reduces to "is it Sunday" — but the feast-override branch is
- * real, not a stub, and will start firing the moment feasts do.
+ * going on gets the "ferial" form, Sunday or a winning feast gets the
+ * fuller "Sunday/feast" form.
  */
 export function isSundayOrFeast(day: LiturgicalDay): boolean {
-  return day.weekday === 'sunday' || day.occurring.length > 0;
+  return day.weekday === 'sunday' || day.winner.kind === 'sanctoral';
 }
 
-export type { LiturgicalDay, OccurringFeast, Season, Weekday, FeastRank } from './types';
+export { compareFeastClass, isAtLeast, decideOccurrence, minimumOutrightWinningRank } from './commemorations';
+export { resolveCollision } from './collision';
+export { resolveTemporalId } from './temporal-id';
+export { monthWeekId } from './month-week-id';
+export { activeOctavesFor, strictestThreshold, resolveActiveOctave, octaveGoverningPrivilegedDay } from './octaves';
+export type { ActiveOctave } from './octaves';
+export type {
+  LiturgicalDay,
+  DayWinner,
+  Commemoration,
+  SanctoralIdentity,
+  Season,
+  Weekday,
+  FeastClass,
+  TemporalCategory,
+  OctaveConfig,
+} from './types';

src/calendar/month-week-id.ts

@@ -0,0 +1,74 @@
+// The reference engine's own "calendar-month/week" Matins-reading identity
+// (e.g. "081" = 1st Sunday of August) — genuinely anchored to the civil
+// calendar, NOT Easter-offset like every other id in temporal-id.ts. Real
+// Nocturn 2 patristic content for the later post-Pentecost Sundays lives
+// in the reference engine's Tempora/<MMN>-0.txt files (August-November),
+// keyed this way, not by post-pentecost-NN — which month/week id governs a
+// given date shifts every year with Easter's date, so there is no fixed
+// post-pentecost-NN <-> month-week correspondence to hard-code. See
+// hours/matins.ts's buildReadingPool, which pools this id's own authored
+// content (data/propers/nocturn-readings/month-week-<id>.yml) alongside
+// the ordinary temporalId-keyed pool, same dual-key precedent as
+// propers/bible-plan.ts's Dec25-Jan13 calendar-date stretch.
+//
+// Ported from DivinumOfficium's own Date.pm::monthday() sub, Tridentine/
+// pre-1955 rubrics (this app's baseline throughout — see
+// calendar/temporal.ts's resolveTemporalCategory and its neighbors for the
+// same choice made elsewhere). Concretely, "pre-1955" here means
+// Date.pm's own $modernstyle flag is false: no 1960-rubric October
+// week-III vanishing (that adjustment is entirely modernstyle-gated, so
+// simply never applies here), and November's backward-from-Advent
+// recount still applies for week > 0 (that part is NOT modernstyle-gated
+// in the source) but its extra "collapse week 1 into week 0" step is
+// skipped (that step *is* modernstyle-only).
+import { addDays, dayOfWeek, daysBetween } from './date-math';
+import { adventStart, sundayOnOrBefore } from './temporal';
+
+/** The Sunday that "counts as" the 1st Sunday of `month` for this
+ * reckoning: the Sunday on-or-before the 1st, unless the 1st falls
+ * Thu-Sat (in which case that partial first week has fewer than 4 days in
+ * `month`, so it's skipped in favor of the following Sunday). */
+function firstSundayOfLiturgicalMonth(year: number, month: number): string {
+  const firstOfMonth = `${year}-${String(month).padStart(2, '0')}-01`;
+  const sunday = sundayOnOrBefore(firstOfMonth);
+  return dayOfWeek(firstOfMonth) >= 4 ? addDays(sunday, 7) : sunday;
+}
+
+/**
+ * `"MMN"` (month, 2 digits; week, 1 digit — e.g. `"081"`), or `undefined`
+ * if `isoDate` falls outside the reckoning's range (before the 1st Sunday
+ * of August, or on/after Advent's start). Only ever non-undefined for
+ * August through the eve of Advent.
+ */
+export function monthWeekId(isoDate: string): string | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const month = Number(isoDate.slice(5, 7));
+  if (month < 7) return undefined;
+
+  let litMonth = 0;
+  const firstSundays: Partial<Record<number, string>> = {};
+  for (let m = 8; m <= 12; m++) {
+    const firstSunday = firstSundayOfLiturgicalMonth(year, m);
+    firstSundays[m] = firstSunday;
+    if (isoDate >= firstSunday) {
+      litMonth = m;
+    } else {
+      break;
+    }
+  }
+  if (litMonth === 0) return undefined;
+
+  const advent = adventStart(year);
+  if (litMonth > 10 && isoDate >= advent) return undefined;
+
+  let week = Math.floor(daysBetween(firstSundays[litMonth]!, isoDate) / 7);
+
+  // November: renumbered by counting backward from Advent rather than
+  // forward from November's own 1st Sunday, for every week after the
+  // first — real rubric, not modernstyle-gated (see header comment).
+  if (litMonth === 11 && week > 0) {
+    week = 4 - Math.floor((daysBetween(isoDate, advent) - 1) / 7);
+  }
+
+  return `${String(litMonth).padStart(2, '0')}${week + 1}`;
+}

src/calendar/movable-feasts.ts

@@ -0,0 +1,103 @@
+// A generic resolver for feasts whose own date isn't reachable through
+// calendar/temporal-id.ts's ordinary governing-Sunday lookup -- either
+// because the feast itself isn't a Sunday (Immaculate Heart of Mary,
+// Easter+69, always a Saturday), or because its occurrence rule (last
+// Sunday of a month, unconditional) doesn't fit the plain rank-contest
+// every other day goes through (Christ the King).
+//
+// Every entry is just a `data/calendar/temporal-feasts/<id>.yml` file with
+// `rank` and `anchor` set (temporal-feasts.ts's own `movableTemporalFeasts`
+// scans for these) -- adding the next one (an Ember/Rogation day, a
+// Sacred-Heart-family Marian feast, a Lenten Friday devotion, St. Joseph's
+// own Eastertide feast, ...) needs no new function here or in
+// calendar/index.ts, just a new anchor value on that new file.
+//
+// Deliberately doesn't try to cover every movable-date pattern in this
+// codebase: `marian-saturday` (a generic "nothing else assigned" fallback,
+// not date-anchored at all) and `christmas-octave-sunday` (whichever of
+// Dec 26-29 is a Sunday, a fixed-date-*range* search rather than a
+// Nth-Sunday-from-an-anchor one) are structurally different rules and stay
+// as their own small functions in calendar/index.ts.
+import type { Commemoration, DayWinner } from './types';
+import type { MovableAnchor } from './temporal-feasts';
+import { compareFeastClass } from './commemorations';
+import { easterSunday } from './easter';
+import { addDays, toIsoDate } from './date-math';
+import { adventStart, sundayOnOrAfter, sundayOnOrBefore } from './temporal';
+import { movableTemporalFeasts } from './temporal-feasts';
+
+function lastDayOfMonth(year: number, month: number): string {
+  const nextMonthFirst = month === 12 ? toIsoDate({ year: year + 1, month: 1, day: 1 }) : toIsoDate({ year, month: month + 1, day: 1 });
+  return addDays(nextMonthFirst, -1);
+}
+
+/** The Nth Sunday of `month` (`nth: -1` for "last"), or the Nth Sunday
+ * counting from Advent's own start (always a Sunday itself, so "1st
+ * Sunday of Advent" is exactly `adventStart`) -- the two calendar-
+ * anchored kinds share one "count Sundays from an anchor date" shape,
+ * just with a different anchor. `{ kind: 'easter' }` needs no such
+ * counting at all: Easter Sunday is already a known, fixed anchor, so any
+ * day pegged to it (Sunday or weekday alike) is just a direct offset. */
+function dateForAnchor(year: number, anchor: MovableAnchor): string {
+  switch (anchor.kind) {
+    case 'easter':
+      return addDays(toIsoDate(easterSunday(year)), anchor.offset);
+    case 'nth-sunday-of-month': {
+      if (anchor.nth === -1) {
+        return sundayOnOrBefore(lastDayOfMonth(year, anchor.month));
+      }
+      const firstSunday = sundayOnOrAfter(toIsoDate({ year, month: anchor.month, day: 1 }));
+      return addDays(firstSunday, 7 * (anchor.nth - 1));
+    }
+    case 'nth-sunday-of-advent':
+      return addDays(adventStart(year), 7 * (anchor.nth - 1));
+    case 'fixed-date':
+      return toIsoDate({ year, month: anchor.month, day: anchor.day });
+  }
+}
+
+/**
+ * Run last in resolveDay's override chain (see calendar/index.ts) so a
+ * specific named movable feast always supersedes whatever generic default
+ * (marian-saturday, a plain Sunday-of-week id) ran before it.
+ *
+ * Two occurrence rules, per feast: the ordinary one is rank-compared,
+ * commemorate-the-loser (a temporal winner, with no real standing of its
+ * own, is always superseded; a sanctoral winner keeps the day if its own
+ * rank is at least as strong, commemorating the movable feast instead;
+ * otherwise the movable feast wins and the displaced saint is
+ * commemorated) -- same shape applyMarianSaturday already uses. The
+ * `unconditional` rule (Christ the King) skips the rank contest entirely
+ * and always wins, commemorating whatever it displaces regardless of
+ * strength.
+ */
+export function applyMovableFeasts(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  const year = Number(isoDate.slice(0, 4));
+  let resolvedWinner = winner;
+  for (const feast of movableTemporalFeasts()) {
+    if (isoDate !== dateForAnchor(year, feast.anchor!)) {
+      continue;
+    }
+    const FEAST_WINNER: DayWinner = { kind: 'temporal', id: feast.id };
+    if (feast.unconditional) {
+      if (resolvedWinner.kind === 'temporal') {
+        commemorations.push({ kind: 'temporal', id: resolvedWinner.id });
+      } else {
+        commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
+      }
+      resolvedWinner = FEAST_WINNER;
+      continue;
+    }
+    const rank = feast.rank ?? 'simplex';
+    if (resolvedWinner.kind === 'temporal') {
+      commemorations.push({ kind: 'temporal', id: resolvedWinner.id });
+      resolvedWinner = FEAST_WINNER;
+    } else if (compareFeastClass(resolvedWinner.rank, rank) >= 0) {
+      commemorations.push({ kind: 'temporal', id: feast.id });
+    } else {
+      commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
+      resolvedWinner = FEAST_WINNER;
+    }
+  }
+  return resolvedWinner;
+}

src/calendar/octaves.ts

@@ -0,0 +1,207 @@
+// The "generic way to commemorate an octave" — a lookback over the past
+// week (a feast's own day plus up to 7 more) collecting every octave
+// still active on a given date, from *both* sanctoral saints
+// (calendar/feasts.ts) and temporal feasts (calendar/temporal-feasts.ts).
+// Deliberately a post-processing layer over calendar/index.ts's existing
+// occurrence/transfer pipeline, not a change to calendar/commemorations.ts
+// itself — an octave doesn't change *how* a single day's precedence
+// contest is decided, it just adds commemorations on top of whatever that
+// contest already produced, and occasionally overrides the winner when a
+// too-minor saint would otherwise have taken the day from it.
+import type { FeastClass, LiturgicalDay, OctaveConfig } from './types';
+import { getSanctoralCandidatesFor, getSaintRecord } from './feasts';
+import { getTemporalFeastRecord, temporalFeastIdsStartingOn } from './temporal-feasts';
+import { addDays, daysBetween } from './date-math';
+import { compareFeastClass, minimumOutrightWinningRank } from './commemorations';
+
+export interface ActiveOctave {
+  id: string;
+  name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
+  /** This octave's own effective rank *today* — the ordinary `wins`
+   * threshold on every day except its own closing day, where it's
+   * `closingDayRank` instead (see calendar/types.ts's OctaveConfig).
+   * Doubles as both "how strong a rival saint must be to displace this
+   * octave" and "this octave's own strength when compared against
+   * another simultaneously-active octave" (resolveActiveOctave) — same
+   * underlying question, two different comparison partners. */
+  wins: FeastClass;
+  /** 1 on the feast's own day, counting up from there. */
+  dayNumber: number;
+  /** Whether `dayNumber` is this octave's own final ("in Octava") day —
+   * i.e. whether `wins` above came from `closingDayRank` rather than the
+   * ordinary `wins` config. Used by calendar/index.ts's applyOctaves to
+   * decide which side a *tied* rank favors — see its own doc comment. */
+  isClosingDay: boolean;
+}
+
+const DEFAULT_DAYS = 8;
+const DEFAULT_WINS: FeastClass = 'semiduplex';
+const DEFAULT_CLOSING_DAY_RANK: FeastClass = 'duplex';
+/** How far back to look for an octave's own start date — must cover the
+ * longest configured `days` a caller might use; 7 covers the standard
+ * 8-day octave (day 1 = the start itself, day 8 = 7 days later). */
+const LOOKBACK_DAYS = 7;
+
+function considerCandidate(
+  active: ActiveOctave[],
+  seen: Set<string>,
+  isoDate: string,
+  startDate: string,
+  id: string,
+  name: string,
+  nameLa: string | undefined,
+  octave: OctaveConfig | undefined,
+): void {
+  if (!octave?.enabled || seen.has(id)) {
+    return;
+  }
+  const days = octave.days ?? DEFAULT_DAYS;
+  const offset = daysBetween(startDate, isoDate);
+  if (offset < 0 || offset >= days) {
+    return;
+  }
+  seen.add(id);
+  const dayNumber = offset + 1;
+  const isClosingDay = dayNumber === days;
+  const wins = isClosingDay ? (octave.closingDayRank ?? DEFAULT_CLOSING_DAY_RANK) : (octave.wins ?? DEFAULT_WINS);
+  active.push({ id, name, nameLa, wins, dayNumber, isClosingDay });
+}
+
+/** Every octave (sanctoral or temporal) whose window covers `isoDate`,
+ * oldest-started first (so a stack like Christmas/Stephen/John/Innocents
+ * reads in the order each one actually began, matching how they'd be
+ * listed at Matins/Lauds/Vespers). */
+export function activeOctavesFor(isoDate: string): ActiveOctave[] {
+  const active: ActiveOctave[] = [];
+  const seen = new Set<string>();
+
+  for (let back = LOOKBACK_DAYS; back >= 0; back--) {
+    const candidateDate = addDays(isoDate, -back);
+
+    for (const candidate of getSanctoralCandidatesFor(candidateDate)) {
+      const record = getSaintRecord(candidate.id);
+      if (record) {
+        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.nameLa, record.octave);
+      }
+    }
+
+    for (const feastId of temporalFeastIdsStartingOn(candidateDate)) {
+      const record = getTemporalFeastRecord(feastId);
+      if (record) {
+        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.nameLa, record.octave);
+      }
+    }
+  }
+
+  return active;
+}
+
+/** The strictest (highest) `wins` threshold among a set of active octaves —
+ * what an occurring saint needs to clear to keep the day against all of
+ * them at once. */
+export function strictestThreshold(octaves: ActiveOctave[]): FeastClass {
+  return octaves.reduce<FeastClass>(
+    (max, o) => (compareFeastClass(o.wins, max) > 0 ? o.wins : max),
+    octaves[0]?.wins ?? DEFAULT_WINS,
+  );
+}
+
+/**
+ * Which single active octave actually governs a day's own content/label
+ * when more than one is active at once (this app's first real case: St.
+ * Lawrence's, Aug 10-17, and the Assumption's, Aug 15-22, genuinely
+ * overlap every year) and no rival saint has already displaced all of
+ * them outright (that's calendar/index.ts's applyOctaves — this only
+ * runs octave-vs-octave). Per direct instruction:
+ *
+ * - Highest effective rank (`wins`, already elevated on either octave's
+ *   own closing day) wins outright.
+ * - Tied rank, one of them on its own closing day: the closing day wins
+ *   — its "in Octava" day is the octave's own culminating day, so it
+ *   takes precedence over an ordinary day of an equally-ranked octave
+ *   even if that other octave started more recently (2026-08 user
+ *   instruction, concrete case: Aug 17, St. Lawrence's own closing day,
+ *   vs. the Assumption's ordinary day 3, both `duplex` once Assumption's
+ *   octave was strengthened — Lawrence's closing day wins).
+ * - Tied rank, neither (or both) on their own closing day: the more
+ *   recently *started* octave wins (smaller `dayNumber` today) — the
+ *   reasoning given was that day 1 of a newly started octave needs to be
+ *   fully present, which is the whole point of it starting; the older
+ *   octave that's already been running is commemorated instead, same as
+ *   any octave that loses this comparison.
+ *
+ * Undefined when no octave is active at all. Every other active octave
+ * still gets commemorated regardless of which one wins here — this
+ * function only decides whose *content* (and day-label name) governs,
+ * not who gets left out of the commemoration list entirely (see
+ * calendar/index.ts's applyOctaves, unchanged by this).
+ */
+export function resolveActiveOctave(isoDate: string): ActiveOctave | undefined {
+  return pickWinningOctave(activeOctavesFor(isoDate));
+}
+
+/**
+ * Whether an active octave's own effective rank clears the bar a real
+ * sanctoral candidate would need to win `day`'s temporal category outright
+ * — i.e. whether the octave governs the day's content/label even though
+ * no *saint* occurring there was strong enough to (a "foreign" octave
+ * superimposed on a season it doesn't belong to, e.g. the Immaculate
+ * Conception's own octave running Dec 8-15, squarely inside Advent).
+ * Live-verified against Divino Afflatu 1954: Dec 9/10/12/14 (ordinary
+ * octave days, Semiduplex) and Dec 15 (the octave's own elevated closing
+ * day, Duplex majus) all win outright over Advent's own privileged-feria-
+ * minor ferias, exactly the same threshold `decideOccurrence` already
+ * uses for a real Semiduplex+ saint there (St. Nicholas, Dec 6).
+ *
+ * Deliberately excludes `ordinary-feria` (unconditional there already —
+ * any active octave governs regardless of rank, handled separately by
+ * each caller via `resolveActiveOctave` directly) and `christmastide`
+ * (Christmas's own stacked octaves — Christmas, St. Stephen, St. John,
+ * Holy Innocents — are structurally already that season's own temporal
+ * content, not a foreign add-on contesting it the way the Immaculate
+ * Conception's octave contests Advent: live-verified, Dec 30 keeps
+ * "Dominica Infra Octavam Nativitatis" as the real DO title regardless of
+ * actual weekday or which of the four octaves is active, never an octave
+ * name — see calendar/day-label.ts's and hours/resolve-common.ts's own
+ * Dec-30 doc comments for the fuller reasoning already established
+ * there). */
+export function octaveGoverningPrivilegedDay(day: LiturgicalDay): ActiveOctave | undefined {
+  if (day.temporalCategory === 'ordinary-feria' || day.season === 'christmastide') {
+    return undefined;
+  }
+  const minRank = minimumOutrightWinningRank(day.temporalCategory);
+  if (!minRank) {
+    return undefined;
+  }
+  const octave = resolveActiveOctave(day.date);
+  if (octave && compareFeastClass(octave.wins, minRank) >= 0) {
+    return octave;
+  }
+  return undefined;
+}
+
+/** The comparison itself, factored out from resolveActiveOctave so the
+ * precedence rule (rank, then recency) is directly unit-testable against
+ * synthetic ActiveOctave data — no real equal-rank overlap exists yet in
+ * this app's own calendar to exercise the tie-break against. */
+export function pickWinningOctave(active: ActiveOctave[]): ActiveOctave | undefined {
+  return active.reduce<ActiveOctave | undefined>((best, candidate) => {
+    if (!best) {
+      return candidate;
+    }
+    const rankCmp = compareFeastClass(candidate.wins, best.wins);
+    if (rankCmp > 0) {
+      return candidate;
+    }
+    if (rankCmp < 0) {
+      return best;
+    }
+    if (candidate.isClosingDay !== best.isClosingDay) {
+      return candidate.isClosingDay ? candidate : best;
+    }
+    return candidate.dayNumber < best.dayNumber ? candidate : best;
+  }, undefined);
+}

src/calendar/temporal-feasts.ts

@@ -0,0 +1,112 @@
+// The temporal-cycle sibling of calendar/feasts.ts's SaintRecord: a small
+// metadata record for a *temporal* id (Christmas, Pentecost, ...) that
+// needs to carry something beyond its collect text — so far, just whether
+// it has an octave (calendar/types.ts's OctaveConfig). Most temporal ids
+// don't need a record at all (they're just collect-text lookups via
+// propers/index.ts's getTemporalProper); this only exists for the ones
+// that do.
+import type { FeastClass, OctaveConfig } from './types';
+import { easterOffsetOf } from './temporal';
+
+/** How to compute a movable feast's own date each year, for a feast that
+ * ISN'T itself a Sunday (or, for `unconditional` feasts like Christ the
+ * King, one whose occurrence rule is simpler to express as "always wins
+ * outright" than as an ordinary rank contest) -- see
+ * calendar/movable-feasts.ts, which is the only consumer of this.
+ * `resolveTemporalId`'s own Easter-offset resolution only ever finds one
+ * of the 52 canonical *Sunday* ids (it works by finding the governing
+ * Sunday on-or-before a date, then looking that Sunday's own offset up);
+ * none of these three anchor kinds are reachable through that lookup no
+ * matter what, so they need this separate mechanism instead. A feast
+ * that *is* a Sunday itself (Pentecost) doesn't need this at all -- it's
+ * already covered by the ordinary Sunday lookup, and by
+ * EASTER_OFFSET_STARTS below if it also has an octave to start. */
+export type MovableAnchor =
+  | { kind: 'easter'; offset: number }
+  | { kind: 'nth-sunday-of-month'; month: number; nth: number } // nth: 1-4, or -1 for "last"
+  | { kind: 'nth-sunday-of-advent'; nth: number } // nth: 1-4 (Advent always has exactly 4 Sundays)
+  | { kind: 'fixed-date'; month: number; day: number }; // a plain civil-calendar date, not itself Easter- or Advent-anchored (e.g. the Circumcision, Jan 1)
+
+export interface TemporalFeastRecord {
+  id: string;
+  name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
+  octave?: OctaveConfig;
+  rank?: FeastClass;
+  anchor?: MovableAnchor;
+  /** Christ the King's own rule: always wins the day outright, no rank
+   * contest at all (see calendar/movable-feasts.ts's applyMovableFeasts) --
+   * every other movable feast instead loses to an equal-or-higher-ranked
+   * sanctoral winner and is commemorated alongside it instead. */
+  unconditional?: boolean;
+  /** The temporal-feast sibling of calendar/feasts.ts's SaintRecord field
+   * of the same name -- see that field's own doc comment for the full
+   * rationale (a feast-side mirror of the day-side privilege
+   * calendar/commemorations.ts already models, deliberately a flag
+   * rather than a ported rank-threshold formula). Set on sacred-heart.yml
+   * specifically -- live source (horascommon.pl, github #4586): on the
+   * rare late-Easter date the movable Feast of the Sacred Heart falls the
+   * day immediately before the fixed Most Precious Blood (July 1), Sacred
+   * Heart's own kept Second Vespers explicitly does *not* commemorate
+   * Precious Blood the next evening ("Vespera de præcedenti; nihil de
+   * sequenti") -- the reverse direction (Precious Blood's own Vespers
+   * commemorating a Sacred Heart that falls *after* it, the other rare
+   * late-Easter arrangement) has no such carve-out in the reference
+   * engine, so this flag is intentionally one-directional, not mirrored
+   * onto most-precious-blood.yml. */
+  forbidsSuccessorCommemoration?: true;
+}
+
+const temporalFeastModules = import.meta.glob<{ default: TemporalFeastRecord }>(
+  '../data/calendar/temporal-feasts/*.yml',
+  { eager: true },
+);
+
+const temporalFeastsById = new Map<string, TemporalFeastRecord>();
+for (const mod of Object.values(temporalFeastModules)) {
+  temporalFeastsById.set(mod.default.id, mod.default);
+}
+
+export function getTemporalFeastRecord(id: string): TemporalFeastRecord | undefined {
+  return temporalFeastsById.get(id);
+}
+
+/** Every temporal feast record carrying its own `anchor` -- the table
+ * calendar/movable-feasts.ts's applyMovableFeasts scans. Adding a new
+ * movable feast (an Ember/Rogation day, a Sacred-Heart-family Marian
+ * feast, a Lenten Friday devotion, ...) is just a new
+ * `data/calendar/temporal-feasts/<id>.yml` file with `rank` and `anchor`
+ * set -- no new code. */
+export function movableTemporalFeasts(): TemporalFeastRecord[] {
+  return [...temporalFeastsById.values()].filter((f) => f.anchor !== undefined);
+}
+
+/** Fixed-calendar-date starts (MM-DD -> temporal feast id). Only Christmas
+ * so far; Epiphany/Candlemas would join here if they ever needed an
+ * octave modeled too. */
+const FIXED_DATE_STARTS: [string, string][] = [['12-25', 'christmas-day']];
+
+/** Easter-offset starts (offset -> temporal feast id). */
+const EASTER_OFFSET_STARTS: [number, string][] = [
+  [17, 'patronage-of-st-joseph'],
+  [39, 'ascension'],
+  [49, 'pentecost-sunday'],
+  [60, 'corpus-christi'],
+  [68, 'sacred-heart'],
+];
+
+/** Which temporal feast(s), if any, have their own (day-1) octave start on this date. */
+export function temporalFeastIdsStartingOn(isoDate: string): string[] {
+  const monthDay = isoDate.slice(5);
+  const ids: string[] = [];
+  for (const [md, id] of FIXED_DATE_STARTS) {
+    if (md === monthDay) ids.push(id);
+  }
+  const offset = easterOffsetOf(isoDate);
+  for (const [off, id] of EASTER_OFFSET_STARTS) {
+    if (off === offset) ids.push(id);
+  }
+  return ids;
+}

src/calendar/temporal-id.ts

@@ -0,0 +1,130 @@
+// Maps any date to one of the 52 canonical temporal-propers ids already
+// authored in data/propers/temporal/*.yml — the "which Sunday's collect
+// governs this date" question. A feria always inherits the collect of the
+// Sunday on or before it (real rubric: the ferias of a week use that
+// week's own Sunday collect), so this is really "find the governing
+// Sunday, then name it."
+//
+// Deliberately Pentecost/offset-based, not Trinity-counted — this is
+// content-storage identity, kept independent of whatever counting
+// convention calendar/day-label.ts displays on screen. See that file's
+// header and propers/index.ts's getTemporalProper for the fuller version
+// of this reasoning.
+//
+// One known, deliberately unfixed gap: the ferias between Christmas Day
+// and the Sunday within its octave, and between Epiphany and its own
+// first Sunday, fall back to that season's first named Sunday a few days
+// early — Christmas Day's and Epiphany's own collects aren't authored as
+// separate temporal-propers entries (only Sunday collects were pulled), so
+// this is a deliberate approximation, not an oversight.
+//
+// Overflow years (Easter early enough that fewer than 6 Sundays after
+// Epiphany occur before Septuagesima cuts in) are handled below: the
+// skipped post-Epiphany Sundays "resume" after Sunday XXIII after
+// Pentecost, in their own numeric order, right before the fixed final
+// Sunday of the year (always Sunday XXIV's own formulary, regardless of
+// how many Sundays actually elapsed since Pentecost). Ported directly
+// from the reference engine's own `getweek()`
+// (DivinumOfficium/Date.pm) — same rubric, same arithmetic (weeks-until-
+// Advent, not a separately-tracked count of skipped Epiphany Sundays);
+// confirmed against that source rather than re-derived by hand.
+import { resolveSeason, sundayOnOrBefore, firstSundayStrictlyAfter, adventStart, easterOffsetOf } from './temporal';
+import { daysBetween } from './date-math';
+
+const EASTER_OFFSET_IDS: [number, string][] = [
+  [-63, 'septuagesima'],
+  [-56, 'sexagesima'],
+  [-49, 'quinquagesima'],
+  [-42, 'lent-1'],
+  [-35, 'lent-2'],
+  [-28, 'lent-3'],
+  [-21, 'lent-4'],
+  [-14, 'passion-sunday'],
+  [-7, 'palm-sunday'],
+  [0, 'easter-sunday'],
+  [7, 'easter-octave'],
+  [14, 'easter-3'],
+  [21, 'easter-4'],
+  [28, 'easter-5'],
+  [35, 'easter-6'],
+  [42, 'sunday-after-ascension'],
+  [49, 'pentecost-sunday'],
+];
+// Sundays I-XXII after Pentecost only — XXIII and XXIV are handled by
+// resolvePostPentecost23Plus below, since (unlike I-XXII) which id a given
+// week gets can depend on distance-to-Advent, not just its own offset.
+for (let n = 1; n <= 22; n++) {
+  EASTER_OFFSET_IDS.push([56 + 7 * (n - 1), `post-pentecost-${String(n).padStart(2, '0')}`]);
+}
+const EASTER_OFFSET_ID_MAP = new Map(EASTER_OFFSET_IDS);
+
+/**
+ * A governing Sunday at or beyond Pentecost week XXIII. `pentecostWeek` is
+ * the reference engine's own `$n` (1 = Trinity Sunday, verified against
+ * DivinumOfficium/Date.pm and its Tempora/PentNN file naming).
+ */
+function resolvePostPentecost23Plus(governingSunday: string, year: number, pentecostWeek: number): string {
+  const wdist = Math.floor((daysBetween(governingSunday, adventStart(year)) + 6) / 7);
+  if (wdist < 2) {
+    return 'post-pentecost-24';
+  }
+  if (pentecostWeek === 23) {
+    return 'post-pentecost-23';
+  }
+  return `post-epiphany-${8 - wdist}`;
+}
+
+export function resolveTemporalId(isoDate: string): string {
+  const season = resolveSeason(isoDate);
+  const year = Number(isoDate.slice(0, 4));
+
+  // The Vigil of Christmas (Dec 24) has its own real proper content
+  // (collect, Lauds antiphons, Matins Gospel+homily nocturn) distinct from
+  // Advent 4's own — see data/propers/temporal/vigil-of-christmas-collect.yml
+  // and data/propers/nocturn-readings/vigil-of-christmas.yml, both
+  // transcribed directly from the reference engine's Sancti/12-24.txt.
+  // Applies even when Dec 24 itself is Advent 4's own Sunday — per direct
+  // instruction (2026-08), the Vigil's own identity (rank/collect/Lauds
+  // antiphons) governs that day too, with Advent 4 folded in as a
+  // commemoration instead (calendar/index.ts's
+  // applyAdventFourVigilCommemoration) rather than the reference engine's
+  // own `no commemoratio` rule. Matins' three-nocturn Sunday psalmody is
+  // unaffected either way — it's driven by `day.weekday`, not by this id
+  // (hours/matins.ts's own `threeNocturns` check), so Advent 4's "Psalmi
+  // Dominica" standing survives this id swap for free.
+  if (isoDate.slice(5) === '12-24') {
+    return 'vigil-of-christmas';
+  }
+
+  if (season === 'advent') {
+    const start = adventStart(year);
+    const n = Math.round(daysBetween(start, sundayOnOrBefore(isoDate)) / 7) + 1;
+    return `advent-${Math.min(n, 4)}`;
+  }
+
+  if (season === 'christmastide') {
+    return 'christmas-octave-sunday';
+  }
+
+  if (season === 'epiphanytide') {
+    const firstSunday = firstSundayStrictlyAfter(`${year}-01-06`);
+    if (isoDate < firstSunday) {
+      return 'post-epiphany-1';
+    }
+    const n = Math.round(daysBetween(firstSunday, sundayOnOrBefore(isoDate)) / 7) + 1;
+    return `post-epiphany-${Math.min(n, 6)}`;
+  }
+
+  // Everything else (Septuagesima-tide through Trinitytide) is Easter-
+  // anchored — find the governing Sunday and map its own offset directly,
+  // regardless of which `season` bucket the feria itself falls in (the
+  // ferias right after Ash Wednesday genuinely reuse Quinquagesima's
+  // collect, crossing what resolveSeason calls two different seasons).
+  const governingSunday = sundayOnOrBefore(isoDate);
+  const offset = easterOffsetOf(governingSunday);
+  const pentecostWeek = Math.round((offset - 49) / 7);
+  if (pentecostWeek >= 23) {
+    return resolvePostPentecost23Plus(governingSunday, year, pentecostWeek);
+  }
+  return EASTER_OFFSET_ID_MAP.get(offset) ?? 'septuagesima';
+}

src/calendar/temporal.ts

@@ -1,8 +1,263 @@
-// Temporal-cycle occurrence resolution: given a date, which temporal-id
-// applies (season, proper Sunday/feria), by combining two offset systems —
-// data/calendar/easter-offsets.yml (Septuagesima through Trinitytide) and
-// data/calendar/fixed-date-calendar.yml (Christmas, Epiphany). Also where
-// the Advent-start and Epiphanytide-length wrinkles noted in
-// fixed-date-calendar.yml get arbitrated. Depends on calendar/easter.ts for
-// the Easter date itself. Unused until milestone 4.
-export {};
+// Temporal-cycle occurrence resolution: given a date, which season applies.
+// Combines two independent anchor systems that hand off to each other once
+// a year, right around Epiphanytide -> Septuagesima:
+//   - Christmas-relative (data/calendar/fixed-date-calendar.yml): Advent,
+//     Christmastide, Epiphanytide. Advent's start is "the Sunday nearest
+//     Nov 30", not a plain fixed date, so that rule lives in code here.
+//   - Easter-relative (data/calendar/easter-offsets.yml, via
+//     calendar/easter.ts): Septuagesima through the end of Trinitytide.
+//
+// Does NOT resolve occurring feasts (calendar/feasts.ts, still a stub) —
+// a season is the temporal-cycle backdrop a day sits on; which saint (if
+// any) is being kept that day, and whether it outranks the season, is a
+// separate, larger project.
+import type { Season, TemporalCategory, Weekday } from './types';
+import { easterSunday } from './easter';
+import { addDays, daysBetween, dayOfWeek, toIsoDate } from './date-math';
+import fixedDateData from '../data/calendar/fixed-date-calendar.yml';
+import easterOffsetsData from '../data/calendar/easter-offsets.yml';
+import temporalCategoriesData from '../data/calendar/temporal-categories.yml';
+
+const fixedDates = fixedDateData as { dates: Record<string, string> };
+const easterOffsets = easterOffsetsData as {
+  ranges: { season: string; fromOffset: number }[];
+  days?: Record<string, string>;
+};
+const temporalCategories = temporalCategoriesData as {
+  bySeason: Record<string, { sunday: TemporalCategory; feria: TemporalCategory }>;
+  offsets?: Record<string, TemporalCategory>;
+  offsetRanges?: { fromOffset: number; toOffset: number; category: TemporalCategory }[];
+  fixedDates?: Record<string, TemporalCategory>;
+};
+
+function fixedDateFor(id: string): { month: number; day: number } {
+  const entry = Object.entries(fixedDates.dates).find(([, value]) => value === id);
+  if (!entry) {
+    throw new Error(`fixed-date-calendar.yml has no entry for '${id}'`);
+  }
+  const [monthStr, dayStr] = entry[0].split('-');
+  return { month: Number(monthStr), day: Number(dayStr) };
+}
+
+const CHRISTMAS = fixedDateFor('christmas-day');
+const EPIPHANY = fixedDateFor('epiphany');
+
+/** The Sunday nearest `isoDate` — ties (exactly 3-4 days either way can't
+ * happen; a week has one middle point, Wednesday, which is always closer
+ * to one side or the other) resolved the usual "nearest" way: on or
+ * before if `isoDate` is Sun-Wed, the next one if Thu-Sat. Shared by
+ * `adventStart` (nearest Nov 30) and calendar/ember-days.ts's own
+ * September Ember anchor (nearest Sept 14). */
+export function nearestSunday(isoDate: string): string {
+  const dow = dayOfWeek(isoDate);
+  const delta = dow <= 3 ? -dow : 7 - dow;
+  return addDays(isoDate, delta);
+}
+
+/** The Sunday nearest Nov 30 (St. Andrew's Day) — Advent's real start rule. */
+export function adventStart(year: number): string {
+  return nearestSunday(`${year}-11-30`);
+}
+
+/**
+ * The Sunday on or before `isoDate` — "which week does this feria belong
+ * to." Shared by calendar/day-label.ts (display) and, eventually, whatever
+ * resolves temporal-propers content ids (calendar/types.ts's `PropersRef`
+ * `source: 'temporal'` branch) — both need the same "which Sunday governs
+ * this feria" answer, just for different purposes, so it lives here rather
+ * than in either consumer.
+ */
+export function sundayOnOrBefore(isoDate: string): string {
+  return addDays(isoDate, -dayOfWeek(isoDate));
+}
+
+/** The first Sunday strictly after `isoDate`, even if `isoDate` is itself a Sunday. */
+export function firstSundayStrictlyAfter(isoDate: string): string {
+  const dow = dayOfWeek(isoDate);
+  return addDays(isoDate, dow === 0 ? 7 : 7 - dow);
+}
+
+/** The Sunday on or after `isoDate` — `isoDate` itself, if it's already a
+ * Sunday. Used by calendar/movable-feasts.ts's "Nth Sunday of month"
+ * anchor (the 1st Sunday of a month counts the month's own 1st day if
+ * that's a Sunday, unlike firstSundayStrictlyAfter above). */
+export function sundayOnOrAfter(isoDate: string): string {
+  const dow = dayOfWeek(isoDate);
+  return dow === 0 ? isoDate : addDays(isoDate, 7 - dow);
+}
+
+function seasonFromEasterOffset(offset: number): Season {
+  const dayOverride = easterOffsets.days?.[String(offset)];
+  if (dayOverride) {
+    return dayOverride;
+  }
+  const sorted = [...easterOffsets.ranges].sort((a, b) => a.fromOffset - b.fromOffset);
+  const first = sorted[0];
+  if (!first) {
+    throw new Error('easter-offsets.yml has no ranges');
+  }
+  let season: Season = first.season;
+  for (const range of sorted) {
+    if (offset >= range.fromOffset) {
+      season = range.season;
+    }
+  }
+  return season;
+}
+
+export function resolveSeason(isoDate: string): Season {
+  const [, monthStr, dayStr] = isoDate.split('-');
+  const month = Number(monthStr);
+  const day = Number(dayStr);
+  const year = Number(isoDate.slice(0, 4));
+
+  // Advent: the Sunday nearest Nov 30 through Dec 24.
+  const advent = adventStart(year);
+  const isChristmasDayOrLater = month === CHRISTMAS.month && day >= CHRISTMAS.day;
+  if (isoDate >= advent && !isChristmasDayOrLater) {
+    return 'advent';
+  }
+
+  // Christmastide: Christmas Day through Jan 5, wrapping across the civil
+  // year boundary (so checked as two separate month/day windows, not one
+  // date range).
+  if (isChristmasDayOrLater || (month === 1 && day < EPIPHANY.day)) {
+    return 'christmastide';
+  }
+
+  // Epiphanytide: Epiphany until Septuagesima cuts in. Septuagesima's
+  // earliest possible date (Jan 18, when Easter falls on its earliest
+  // possible date, Mar 22) is always after Epiphany, so no year-rollover
+  // Easter lookup is ever needed to make this comparison.
+  const easterIso = toIsoDate(easterSunday(year));
+  const septuagesimaStart = addDays(easterIso, -63);
+  if (isoDate < septuagesimaStart) {
+    return 'epiphanytide';
+  }
+
+  return seasonFromEasterOffset(daysBetween(easterIso, isoDate));
+}
+
+/** Days from Easter Sunday (negative = before, 0 = Easter, positive = after) for the given date's own year. */
+export function easterOffsetOf(isoDate: string): number {
+  const year = Number(isoDate.slice(0, 4));
+  return daysBetween(toIsoDate(easterSunday(year)), isoDate);
+}
+
+/** The Sacred Triduum: Maundy/Holy Thursday through Holy Saturday
+ * (inclusive). Doesn't line up with `season` (which resolves this window
+ * to 'passiontide', same as the two weeks before it) — see
+ * hours/marian-antiphon.ts's isCandlemasToHolyWednesday for the same
+ * direct-date-check pattern used for another window `season` can't
+ * represent. Gloria Patri is omitted after psalms only in this narrower
+ * window, not throughout Passiontide/Holy Week generally. */
+export function isInTriduum(isoDate: string): boolean {
+  const offset = easterOffsetOf(isoDate);
+  return offset >= -3 && offset <= -1;
+}
+
+const SEPTEMBER_EMBER_OFFSETS = [3, 5, 6]; // Wed, Fri, Sat after the anchor Sunday
+const ADVENT_EMBER_OFFSETS = [3, 5, 6]; // Wed, Fri, Sat after the 3rd Sunday of Advent
+
+/** The Sunday nearest Sept 14 (Exaltation of the Holy Cross) — anchors
+ * September's Ember days, same "nearest" rule as Advent's own start.
+ * Live-verified (2026, 2019) against the reference engine: genuinely
+ * "nearest," not "3rd Sunday of the calendar month" — those two
+ * computations disagree in some years (e.g. 2025). */
+export function septemberEmberAnchor(year: number): string {
+  return nearestSunday(`${year}-09-14`);
+}
+
+/** Which of September's 3 Ember-day offsets (3/5/6 = Wed/Fri/Sat)
+ * `isoDate` is, if any — shared by resolveTemporalCategory below (the
+ * precedence side: these get `privileged-feria-minor`) and
+ * calendar/ember-days.ts (the content-id side: each gets its own proper
+ * collect/readings instead of inheriting the governing Sunday's). */
+export function septemberEmberDayOffset(isoDate: string): number | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const anchor = septemberEmberAnchor(year);
+  return SEPTEMBER_EMBER_OFFSETS.find((offset) => addDays(anchor, offset) === isoDate);
+}
+
+/** Which of Advent's 3 Ember-day offsets `isoDate` is, if any. Unlike
+ * September's, this doesn't need its own resolveTemporalCategory entry —
+ * Advent's ordinary `privileged-feria-minor` season default already
+ * covers it (no live evidence found that Advent Ember days need a
+ * stronger tier) — but it still needs its own content id, same as
+ * September's, hence still exported for calendar/ember-days.ts. */
+export function adventEmberDayOffset(isoDate: string): number | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const thirdAdventSunday = addDays(adventStart(year), 14);
+  return ADVENT_EMBER_OFFSETS.find((offset) => addDays(thirdAdventSunday, offset) === isoDate);
+}
+
+/**
+ * A day's precedence category under the temporal cycle alone — see
+ * calendar/types.ts's TemporalCategory doc comment and
+ * data/calendar/temporal-categories.yml for the reconstruction caveat.
+ *
+ * Sundays never fall on any of the offset/fixed-date overrides below (Ash
+ * Wednesday, Holy Week, the Easter/Pentecost octaves' weekdays, and the
+ * Christmas vigil are all, by construction, not Sundays) except possibly
+ * the Christmas vigil (Dec 24 can land on a Sunday) — and a Sunday's own
+ * privileged/ordinary status should win in that case regardless, so
+ * Sundays are resolved straight from `bySeason` without consulting the
+ * overrides at all. The deliberate exceptions are Easter Sunday itself
+ * (offset 0) and Low Sunday (offset 7, the Octave's own closing day):
+ * `eastertide`'s own `bySeason` default is `ordinary-sunday` (live-
+ * verified for the *ordinary* Sundays from the 2nd Sunday after Easter
+ * on — see that entry's own comment), but both bookend Sundays of the
+ * Easter Octave need the stronger `privileged-sunday` tier instead.
+ * Easter Day: live-verified 2026-09-01, the Annunciation (Duplex I.
+ * classis) transfers off it in years they coincide, the same "transfers,
+ * no exception" behavior as every other privileged-sunday case. Low
+ * Sunday: not independently collision-verified (no Monastic-track saint
+ * — `SanctiM/MM-DD.txt` — ever falls there across the real range of
+ * Easter dates, so no live test case exists), but its own formal rank in
+ * the reference source ("Dominica in Albis in Octava Paschæ ~ Duplex I.
+ * classis") matches Easter Day's own exactly, and no `Transfer:` note
+ * ever shows there even for a same-named non-Monastic-track saint
+ * (St. Isidore of Seville, 2027; St. Vincent Ferrer, 2043) that a real
+ * Monastic-track day would display — treated the same as Easter Day on
+ * that basis. Both checked directly here rather than via `offsets`,
+ * since offsets are never consulted for a Sunday.
+ */
+export function resolveTemporalCategory(isoDate: string, season: Season, weekday: Weekday): TemporalCategory {
+  const bySeasonEntry = temporalCategories.bySeason[season];
+  const base = bySeasonEntry ? (weekday === 'sunday' ? bySeasonEntry.sunday : bySeasonEntry.feria) : 'ordinary-feria';
+  if (weekday === 'sunday') {
+    if (season === 'eastertide' && [0, 7].includes(easterOffsetOf(isoDate))) {
+      return 'privileged-sunday';
+    }
+    return base;
+  }
+
+  const fixedOverride = temporalCategories.fixedDates?.[isoDate.slice(5)];
+  if (fixedOverride) {
+    return fixedOverride;
+  }
+
+  // September Ember days: live-verified privileged-feria-minor (Ss.
+  // Cornelius & Cyprian, Semiduplex, won outright there with the feria
+  // demoted to a commemoration) — see septemberEmberDayOffset's own doc
+  // comment for why this can't be expressed as a plain Easter offset or
+  // fixed MM-DD the way every other override in this function is.
+  if (septemberEmberDayOffset(isoDate) !== undefined) {
+    return 'privileged-feria-minor';
+  }
+
+  const offset = easterOffsetOf(isoDate);
+
+  const singleOverride = temporalCategories.offsets?.[String(offset)];
+  if (singleOverride) {
+    return singleOverride;
+  }
+
+  for (const range of temporalCategories.offsetRanges ?? []) {
+    if (offset >= range.fromOffset && offset <= range.toOffset) {
+      return range.category;
+    }
+  }
+
+  return base;
+}

src/calendar/types.ts

@@ -14,33 +14,223 @@ export type Weekday =
 // actually resolves the "opinionated but configurable" tension: the opinion
 // (trinitytide) lives in editable data, not in a TS enum you'd recompile to
 // change.
+//
+// A real limitation this doesn't fully solve: a single `season` string can
+// only hold one mutually-exclusive value per day, but several independent
+// liturgical windows overlap without sharing boundaries. For example, on a
+// real day between Candlemas (Feb 2) and Ash Wednesday, Compline's Marian
+// antiphon should already be Ave Regina Caelorum, but Lent's Alleluia
+// suppression and hymn swap shouldn't have started yet — two things that
+// are both true at once, which one `season` value can't represent.
+//
+// Real season resolution now exists (calendar/temporal.ts, calendar/easter.ts),
+// and the Marian-antiphon case above is handled — but not by adding a
+// `season` value for it. hours/marian-antiphon.ts checks the real date
+// directly instead of going through `season` at all for that one window.
+// That's a fine, scoped fix for one known overlap; it isn't a general
+// solution. If another mechanism turns up with the same shape (a window
+// that doesn't nest inside one `season` bucket), reach for the same
+// pattern — a direct date check bypassing `season` — rather than trying to
+// force `season` to hold two truths at once. Only worth generalizing into
+// several independent named windows/flags on `LiturgicalDay` itself if a
+// third case shows up and the duplication starts to hurt.
 export type Season = string;
 
-// Open-ended on purpose — the actual ranking scheme (double/semidouble/simple,
-// or whatever the finalized rank system turns out to be) is a rule decision for
-// milestone 4, not a type decision for milestone 0.
-export type FeastRank = string;
+// The old (pre-1955) rank scale, low to high. Deliberately a closed union
+// rather than an open string like Season — the whole point of
+// calendar/commemorations.ts's decideOccurrence is to compare two of these
+// with explicit, readable rules, which only works if the set of values is
+// fixed and known. See calendar/types.ts's TemporalCategory doc comment for
+// the other half of that comparison.
+//
+// `vigil` sits between `simplex` and `semiduplex` on purpose — it's the
+// same strength as `simplex` for the "does this win against a Sunday"
+// question (both lose and get transferred rather than fighting the day
+// directly), but ranks strictly above `simplex` for the *separate*
+// "two saints collide on the same landing day" comparison
+// (calendar/collision.ts). One ordering serves both; see the design
+// discussion in project history for why that isn't a coincidence.
+export type FeastClass =
+  | 'simplex'
+  | 'vigil'
+  | 'semiduplex'
+  | 'duplex'
+  | 'duplex-majus'
+  | 'duplex-2-classis'
+  | 'duplex-1-classis';
 
-export interface OccurringFeast {
+// A day's own precedence class *before* any sanctoral feast is considered —
+// i.e. what the temporal cycle alone says this day is entitled to. This is
+// coarser than `season` on purpose: several different seasons share the
+// same precedence behavior (Advent/Septuagesima/Lent/Passiontide Sundays
+// are all "privileged" in the same way; Epiphanytide/Trinitytide Sundays
+// are all "ordinary" in the same way), and decideOccurrence only cares
+// about that behavior, not which season produced it. See
+// data/calendar/temporal-categories.yml for which season maps to which
+// category — reconstructed from general knowledge of the pre-1955
+// tradition, not yet verified against a primary source, so expect
+// corrections.
+// `privileged-feria` and `privileged-feria-major` are two real, distinct
+// tiers (confirmed by finding a plain Duplex saint, St. Gregory the Great,
+// outright winning against a Lenten Ember Saturday in the real Monastic
+// 1617 engine, which the original single-tier model wrongly forbade) —
+// see calendar/commemorations.ts's rules for `privileged-feria` (behaves
+// like `ordinary-sunday`: Duplex+ wins outright) vs `privileged-feria-major`
+// (behaves like `privileged-sunday`: never displaced, and — corrected
+// 2026-09-01 — never gets even a bare commemoration at any rank either;
+// an earlier claim that a duplex-majus+ candidate is "merely commemorated"
+// there, citing St. Mark within the Easter Octave, turned out to be a
+// misreading — direct instruction confirmed nothing is ever commemorated
+// anywhere from Palm Sunday through Low Sunday, and live-checking Ash
+// Wednesday found the same). See data/calendar/temporal-categories.yml
+// for exactly which days fall in which tier — some of that split (e.g.
+// whether Pentecost's own Ember days share Lent's lesser tier or
+// Easter's major one) is still a reconstructed guess, not verified.
+// `privileged-feria-minor` is a third, weaker tier, added during the
+// December sanctoral pull after finding Advent's own ordinary (non-Ember)
+// ferias have real standing of their own in the live engine — a Simplex
+// saint (e.g. St. Bibiana, Dec 2) is merely commemorated there, while a
+// Semiduplex+ saint (e.g. St. Nicholas, Dec 6) wins outright with the
+// feria itself commemorated in return — neither of which the original
+// `ordinary-feria` fallback (any saint wins, nothing ever commemorated)
+// could represent. Lent's own ordinary ferias are documented as sharing
+// this same real-world property but are NOT switched to this tier yet —
+// unverified this session, left as `ordinary-feria` pending a future check.
+export type TemporalCategory =
+  | 'ordinary-feria'
+  | 'privileged-feria-minor'
+  | 'privileged-feria'
+  | 'privileged-feria-major'
+  | 'ordinary-sunday'
+  | 'privileged-sunday';
+
+export interface SanctoralIdentity {
   id: string;
   name: string;
-  rank: FeastRank;
-  commemorated: boolean;
-  // Placeholder for the first/second-Vespers overlap wrinkle — unresolved until
-  // milestone 4 actually needs it.
-  vespersFrom?: 'today' | 'firstVespersOfTomorrow';
+  /** Latin form of `name`, when authored (see `data/calendar/saints/*.yml`'s
+   * own `nameLa` field). Absent for the majority of saints still — display
+   * code falls back to `name` itself when this is missing, same "surface
+   * real text rather than block on missing" convention used elsewhere. */
+  nameLa?: string;
+  rank: FeastClass;
 }
 
+/**
+ * Attached to a saint's own record (calendar/feasts.ts's SaintRecord) or a
+ * temporal feast's (calendar/temporal-feasts.ts's TemporalFeastRecord) to
+ * declare that it carries an octave — commemorated daily for `days` days
+ * after its own feast, layered on top of whatever normally wins each of
+ * those days. `enabled: false` (or the field simply absent) means no
+ * octave; `{ enabled: true }` alone is valid and uses every default below,
+ * satisfying the "turned on but no octave data authored yet" case —
+ * calendar/octaves.ts is the "generic way to commemorate an octave" that
+ * makes that minimal declaration meaningful on its own.
+ *
+ * Matins readings, where sourced, are looked up separately by convention
+ * (propers/octave-readings.ts's `getOctaveReading(octaveId, dayNumber)`,
+ * id `${octaveId}-octave-day-${dayNumber}`) rather than declared here —
+ * they vary day to day within a single octave (confirmed: the Assumption's
+ * own octave gives different patristic sermon excerpts on day 2 vs. day
+ * 5), so there's no single id to put on this config, and it's normal for
+ * some days to have none authored at all.
+ */
+export interface OctaveConfig {
+  enabled: boolean;
+  /** Length of the octave in days, inclusive of the feast's own day. Default 8. */
+  days?: number;
+  /** Rank threshold: an occurring saint at this rank or higher keeps the
+   * day for itself (the octave is merely commemorated back); below it, the
+   * octave wins the day instead and the saint is commemorated. Default
+   * 'semiduplex' — i.e. only a Simplex loses to the octave — matching
+   * every octave checked so far except Pentecost's (see
+   * data/calendar/temporal-feasts/pentecost-sunday.yml), which is
+   * stricter (`duplex`). */
+  wins?: FeastClass;
+  /** The octave's own effective rank on its *last* day specifically (the
+   * "in Octava" closing day) instead of `wins` — live-verified as a real,
+   * general pattern rather than a per-saint quirk: both St. Lawrence's
+   * own Aug 17 and the Assumption's own Aug 22 show as Duplex, elevated
+   * above their otherwise-Semiduplex ordinary in-between days. Default
+   * 'duplex'. Feeds both the rival-saint threshold (calendar/octaves.ts's
+   * `strictestThreshold`) and octave-vs-octave precedence
+   * (`resolveActiveOctave`) on that one day. */
+  closingDayRank?: FeastClass;
+}
+
+export type DayWinner =
+  | { kind: 'temporal'; id: string }
+  | ({
+      kind: 'sanctoral';
+      // Set by calendar/vespers.ts's resolveEveningDay when this feast's
+      // First Vespers is being anticipated this evening (i.e. this feast
+      // belongs to *tomorrow*, but is winning tonight's Vespers/Compline).
+      vespersFrom?: 'firstVespersOfTomorrow';
+      // Set by calendar/index.ts's resolveDay/applyIncomingTransfer when
+      // this winner is only here because its own native date (an adjacent
+      // ISO date) couldn't hold it (calendar/commemorations.ts's
+      // `decideOccurrence` `transfer` signal) — the ISO date it transferred
+      // *from*. Absent for a feast winning on its own native date.
+      transferredFrom?: string;
+    } & SanctoralIdentity);
+
+/**
+ * A day can have more than one of these at once (a transferred feast can
+ * displace a native saint who then also gets commemorated, alongside the
+ * Sunday whose own occurrence pushed the transfer in the first place, or —
+ * since octaves were modeled — several overlapping octaves stacking on one
+ * date, e.g. Christmas + St. Stephen + St. John all commemorated together
+ * within the Christmas Octave) — hence a list, not a single flag.
+ */
+export type Commemoration =
+  | { kind: 'temporal'; id: string }
+  | ({
+      kind: 'sanctoral';
+      // Set by calendar/vespers.ts's resolveEveningDay when this
+      // commemoration exists only because Vespers/Compline crossed a day
+      // boundary (First Vespers anticipation, or a kept Second Vespers
+      // still noting the displaced neighbor) — 'today' for the real
+      // Divino Afflatu "commemoratio de præcedenti" case, 'tomorrow' for
+      // "commemoratio de sequenti". Left unset for an ordinary same-day
+      // commemoration (a real collision, an octave day, etc.), which
+      // carries no such qualifier.
+      vespersNote?: 'today' | 'tomorrow';
+      // Set by calendar/index.ts's applyIncomingTransfer, same meaning as
+      // `DayWinner`'s own `transferredFrom` — this saint is only
+      // commemorated here (rather than absent) because a transfer landed
+      // on this date and lost a collision, or fell below the landing
+      // day's own outright-winning threshold, not because it's natively
+      // due for commemoration here. Absent for an ordinary same-day
+      // commemoration.
+      transferredFrom?: string;
+    } & SanctoralIdentity)
+  | { kind: 'octave'; id: string; name: string; nameLa?: string };
+
 export interface LiturgicalDay {
   /** ISO date, e.g. "2026-08-09" */
   date: string;
   weekday: Weekday;
-  /**
-   * Real season resolution depends on Easter's date (see calendar/easter.ts,
-   * not implemented until milestone 4). Until then this is a placeholder and
-   * must not be trusted by any hour's logic.
-   */
+  /** Real temporal-cycle season, computed via calendar/temporal.ts. */
   season: Season;
-  /** Always [] until milestone 4 wires up calendar/feasts.ts. */
-  occurring: OccurringFeast[];
+  /** This day's own precedence class, before any sanctoral feast wins or loses against it. */
+  temporalCategory: TemporalCategory;
+  /** Whichever office actually governs the day. */
+  winner: DayWinner;
+  /** Everything else commemorated alongside the winner — see the doc comment on Commemoration. */
+  commemorations: Commemoration[];
+  /** Set when this date's own native sanctoral candidate couldn't be kept
+   * here at all (calendar/commemorations.ts's `decideOccurrence` `transfer`
+   * signal) and moved to a later/earlier date instead. No landing date is
+   * recorded here — this exists purely so the display can say "not an
+   * omission, this office moved elsewhere" without needing the caller to
+   * separately go find where; the actual landing date is discoverable
+   * from the landing day's own winner/commemoration, tagged with
+   * `transferredFrom`. An ordinary transfer (calendar/index.ts's
+   * `applyIncomingTransfer`, called from `resolveDay`) only ever needs
+   * the immediately adjacent day; anything impeded within Holy Week/the
+   * Easter Octave/Low Sunday goes through the separate, dedicated
+   * `applyEasterOctaveBacklog` mechanism instead, which can place a
+   * candidate many days later. Distinct from — and not implied by —
+   * `Commemoration`, since a transferred-away
+   * candidate gets no commemoration on its own native date at all. */
+  transferredAway?: { candidate: SanctoralIdentity };
 }

src/calendar/vespers.ts

@@ -0,0 +1,258 @@
+// First vs. Second Vespers: whether an evening hour (Vespers, Compline)
+// belongs to *today* (Second Vespers, closing today's own office) or
+// anticipates *tomorrow* (First Vespers of a higher-ranking day) — e.g.
+// Alma Redemptoris Mater starting at Compline the Saturday evening before
+// Advent I, not on Advent Sunday itself. See calendar/commemorations.ts for
+// the sibling temporal-vs-sanctoral decision this mirrors.
+//
+// Same reconstruction caveat as commemorations.ts/temporal-categories.yml:
+// best-effort, not sourced from a primary text for this era, expect
+// corrections.
+import type { Commemoration, DayWinner, LiturgicalDay } from './types';
+import { resolveDay } from './index';
+import { addDays } from './date-math';
+import { easterOffsetOf } from './temporal';
+import { compareFeastClass, isAtLeast } from './commemorations';
+import { getSaintRecord } from './feasts';
+import { getTemporalFeastRecord } from './temporal-feasts';
+
+/**
+ * Fixed/movable "feasts of the Lord" load-bearing elsewhere in this app
+ * (season boundaries, hours/marian-antiphon.ts's Candlemas window) but not
+ * yet modeled as real sanctoral/occurring entries — listed explicitly here
+ * so they still participate in First Vespers eligibility, rather than
+ * silently having none. Not a general mechanism, just this short, known
+ * list; a real sanctoral entry for any of these would make this
+ * redundant for that one date once added.
+ */
+function isMajorFixedFeastOfTheLord(isoDate: string): boolean {
+  const monthDay = isoDate.slice(5);
+  if (monthDay === '12-25' || monthDay === '01-06' || monthDay === '02-02') {
+    return true; // Christmas, Epiphany, Candlemas
+  }
+  const offset = easterOffsetOf(isoDate);
+  return offset === 0 || offset === 39 || offset === 60 || offset === 68; // Easter, Ascension, Corpus Christi, Sacred Heart
+}
+
+/** Does this day's evening claim First Vespers at all (for the day *after* it)? */
+function hasFirstVespers(day: LiturgicalDay): boolean {
+  if (day.weekday === 'sunday' || isMajorFixedFeastOfTheLord(day.date)) {
+    return true;
+  }
+  // Live-verified (2026-08): Ss. Cyriacus/Largus/Smaragdus (Aug 8, plain
+  // Semiduplex) claims First Vespers over St. Donatus's Aug 7 — "Vespera
+  // de sequenti" in the real Monastic 1617 engine. Originally thought
+  // Semiduplex was the actual cutoff, but re-verified 2026-08-25: St.
+  // Zephyrinus (Aug 26, plain Simplex) likewise claims First Vespers over
+  // St. Louis's Aug 25 (also Simplex) — "Vespera de sequenti; nihil de
+  // præcedenti" — so *any* real sanctoral winner, however low-ranked,
+  // clears this bar; there's no rank floor at all, only the separate
+  // keepsOwnSecondVespers question of whether the day *before* it
+  // outranks the claim. Every FeastClass (including `vigil`, untested
+  // directly but the same "lowest tier" logic) now qualifies.
+  return day.winner.kind === 'sanctoral';
+}
+
+/** Does this day keep its own Second Vespers regardless of what tomorrow is,
+ * independent of any comparison against tomorrow's rank? Covers only the
+ * *absolute* cases — Sunday, a privileged feria, or a major fixed feast of
+ * the Lord. The ordinary sanctoral-vs-sanctoral case is decided separately,
+ * by direct rank comparison (see `resolveEveningDay`) rather than a fixed
+ * floor here: this function used to also require the winner be at least
+ * `duplex-2-classis`, but that's the wrong rule — the real "De Concurrentia
+ * Officii" rubric (divinum-officium-reference's rubrics.txt, Titulus XI)
+ * compares today's rank against tomorrow's directly, with ties going to
+ * tomorrow, not a fixed threshold on today alone. That floor produced a
+ * wrong result for 2026-08-31 -> 09-01: St. Raymond Nonnatus (Semiduplex,
+ * below the floor) lost his own Second Vespers to St. Giles (Simplex) even
+ * though Raymond outranks Giles. */
+function keepsOwnSecondVespers(day: LiturgicalDay): boolean {
+  return (
+    day.weekday === 'sunday' ||
+    day.temporalCategory === 'privileged-feria-minor' ||
+    day.temporalCategory === 'privileged-feria' ||
+    day.temporalCategory === 'privileged-feria-major' ||
+    isMajorFixedFeastOfTheLord(day.date)
+  );
+}
+
+/**
+ * Today lost the evening to tomorrow's First Vespers — is today still
+ * commemorated there? Not if it's Simplex (or a bare temporal winner,
+ * with no standing of its own — same "no standing to defend" idea
+ * commemorations.ts's `ordinary-feria` case already uses during the
+ * day). Live-verified:
+ *   - Aug 8 -> 9 (Ss. Cyriaci/Largi/Smaragdi, Semiduplex, before an
+ *     ordinary Sunday): today loses the evening, today is still
+ *     commemorated ("commemoratio de præcedenti").
+ *   - Aug 7 -> 8 (St. Donatus, Simplex, before Ss. Cyriaci/etc.): today
+ *     loses the evening and is *not* commemorated ("nihil de
+ *     præcedenti") — pins down the Simplex exclusion specifically for
+ *     this direction.
+ */
+function commemorationOfDisplacedPredecessor(loser: DayWinner): Commemoration | undefined {
+  if (loser.kind !== 'sanctoral' || loser.rank === 'simplex') {
+    return undefined;
+  }
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'today' };
+}
+
+/**
+ * Today keeps its own Second Vespers regardless — is tomorrow still
+ * commemorated there? Unlike the reverse direction above, Simplex is
+ * NOT excluded here: live-verified Aug 24 -> 25 (St. Bartholomew,
+ * Duplex II. classis, keeps his own evening; St. Louis, Simplex, on
+ * Aug 25) still reads "commemoratio de sequenti" — the same asymmetry
+ * this file's earlier version only guessed at by symmetry with the
+ * other direction and flagged as unverified. Also verified with a
+ * non-Simplex loser: Jul 25 -> 26 (St. James, Duplex II. classis, kept
+ * second Vespers regardless; St. Anne, Duplex, loses the evening but is
+ * still commemorated).
+ *
+ * `winner` (today's own, the one actually keeping this evening) can
+ * refuse the commemoration outright via its own record's
+ * `forbidsSuccessorCommemoration` — the feast-side mirror of the
+ * day-side privilege calendar/commemorations.ts already models (see that
+ * field's own doc comment, on both SaintRecord and TemporalFeastRecord,
+ * for why this is a flag rather than a rank threshold). Checked on
+ * whichever kind of record `winner` actually is — set today only on
+ * `sacred-heart` (a `temporal` winner), the live-verified case that
+ * motivated this field; every sanctoral saint is still unset, a no-op
+ * until a specific date is verified and flagged.
+ */
+function commemorationOfDisplacedSuccessor(winner: DayWinner, loser: DayWinner): Commemoration | undefined {
+  if (loser.kind !== 'sanctoral') {
+    return undefined;
+  }
+  const forbids =
+    winner.kind === 'sanctoral' ? getSaintRecord(winner.id)?.forbidsSuccessorCommemoration : getTemporalFeastRecord(winner.id)?.forbidsSuccessorCommemoration;
+  if (forbids) {
+    return undefined;
+  }
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'tomorrow' };
+}
+
+function tagVespersFrom(tomorrow: LiturgicalDay): LiturgicalDay {
+  if (tomorrow.winner.kind !== 'sanctoral') {
+    return tomorrow;
+  }
+  return { ...tomorrow, winner: { ...tomorrow.winner, vespersFrom: 'firstVespersOfTomorrow' } };
+}
+
+/** Today's own Vigil isn't commemorated alongside the very feast it's the
+ * eve of — e.g. Nov 29's Vigil of St. Andrew shouldn't also show up next
+ * to St. Andrew himself once this evening has already adopted his First
+ * Vespers, whether St. Andrew governs it outright or is merely
+ * commemorated there himself (2025-11-30: he's only commemorated under
+ * Advent I, a `privileged-sunday`, per commemorations.ts's own threshold
+ * — the Vigil would otherwise show up redundantly alongside him even
+ * though neither one is tomorrow's actual winner). Matched via each
+ * Vigil's own explicit `vigilOf` field (calendar/feasts.ts's
+ * `SaintRecord`) against tomorrow's winner *and* its commemorations, not
+ * date adjacency or name-guessing — several vigils' own ids don't map
+ * cleanly to their feast's id (`vigil-of-the-assumption` vs `assumption`,
+ * `vigil-of-st-james` vs `st-james-the-greater`), so this needs the
+ * explicit link. Scoped to this evening-anticipation merge specifically,
+ * not `commemorationOfDisplacedPredecessor` itself — the reverse direction
+ * (`keepsOwnSecondVespers`, commemorating *tomorrow's* Vigil while today
+ * keeps its own Vespers) can't hit this collision: a Vigil dated tomorrow
+ * belongs to a feast the day after tomorrow, never today. */
+function isVigilOfTomorrow(today: LiturgicalDay, tomorrow: LiturgicalDay): boolean {
+  if (today.winner.kind !== 'sanctoral' || today.winner.rank !== 'vigil') {
+    return false;
+  }
+  const feastId = getSaintRecord(today.winner.id)?.vigilOf;
+  if (!feastId) {
+    return false;
+  }
+  return (
+    (tomorrow.winner.kind === 'sanctoral' && tomorrow.winner.id === feastId) ||
+    tomorrow.commemorations.some((c) => c.kind === 'sanctoral' && c.id === feastId)
+  );
+}
+
+/** The ordinary anticipation path: tag tomorrow's identity, then layer in
+ * today's commemoration if it's eligible (see
+ * commemorationOfDisplacedPredecessor). Not used by the
+ * isMajorFixedFeastOfTheLord override below — whether Christmas/
+ * Easter/etc. commemorate the day they're displacing is a separate,
+ * unverified question (these may well suppress it the way
+ * privileged-sunday/privileged-feria-major do during the day — see
+ * commemorations.ts), so it deliberately doesn't inherit this behavior. */
+function anticipated(today: LiturgicalDay, tomorrow: LiturgicalDay): LiturgicalDay {
+  const tagged = tagVespersFrom(tomorrow);
+  const commemoration = isVigilOfTomorrow(today, tomorrow) ? undefined : commemorationOfDisplacedPredecessor(today.winner);
+  if (!commemoration) {
+    return tagged;
+  }
+  return { ...tagged, commemorations: [...tagged.commemorations, commemoration] };
+}
+
+/**
+ * Resolves which day's identity actually governs this evening's office.
+ * Returns `resolveDay(isoDate)` unchanged unless tomorrow has First
+ * Vespers *and* today doesn't keep its own Second Vespers regardless — in
+ * which case returns tomorrow's `LiturgicalDay`, with `vespersFrom:
+ * 'firstVespersOfTomorrow'` set on its winner (if sanctoral) so callers
+ * can tell the difference from an ordinary day. Either way, whichever side
+ * doesn't govern the evening is folded into the returned day's own
+ * `commemorations` when it's eligible (see
+ * commemorationOfDisplacedPredecessor/-Successor) — except under the
+ * isMajorFixedFeastOfTheLord override just below, which doesn't apply
+ * that at all yet.
+ *
+ * One deliberate absolute exception, caught by a failing test: a day on
+ * `isMajorFixedFeastOfTheLord`'s list always wins tomorrow's Vespers,
+ * *before* checking whether today would otherwise keep its own — Easter
+ * displaces even Holy Saturday's privileged-feria status (the classic
+ * case: the Vigil already belongs to Easter, not to Holy Saturday), and
+ * would likewise displace an actual Sunday if one ever landed on Dec 24 or
+ * an Ember Saturday. This is why it's a short, explicit list rather than a
+ * threshold: these particular days are understood to be *absolute*.
+ *
+ * When neither side is covered by an absolute case and both today and
+ * tomorrow have a real sanctoral winner, the rubric's actual rule applies:
+ * direct rank comparison, with today keeping its own Second Vespers only if
+ * it *strictly* outranks tomorrow — an exact tie goes to tomorrow ("a
+ * Capitulo fit de sequenti cum commemoratione praecedentis"). Note this
+ * checks tomorrow's actual *winner*, not merely whether tomorrow's calendar
+ * weekday is Sunday — a plain Duplex can itself outright win an ordinary
+ * Sunday's daytime office (see commemorations.ts's header comment, e.g. St.
+ * Anne beating an ordinary Sunday on 2026-07-26), in which case it's that
+ * Duplex's own rank being compared, not some notion of "Sunday's rank".
+ * When tomorrow's winner is genuinely the Sunday itself (`kind !==
+ * 'sanctoral'`), today's sufficiently high sanctoral rank
+ * (`duplex-2-classis`+) still claims the evening outright per the rubric's
+ * "Duplex always keeps both Vespers" rule — handled by the
+ * `isAtLeast`-style fallback below, same floor as before, just no longer
+ * applied when tomorrow also has a real (comparable) sanctoral winner.
+ */
+export function resolveEveningDay(isoDate: string): LiturgicalDay {
+  const today = resolveDay(isoDate);
+  const tomorrow = resolveDay(addDays(isoDate, 1));
+
+  if (isMajorFixedFeastOfTheLord(tomorrow.date)) {
+    return tagVespersFrom(tomorrow);
+  }
+
+  let todayWins: boolean;
+  if (keepsOwnSecondVespers(today)) {
+    todayWins = true;
+  } else if (today.winner.kind === 'sanctoral' && tomorrow.winner.kind === 'sanctoral') {
+    todayWins = compareFeastClass(today.winner.rank, tomorrow.winner.rank) > 0;
+  } else if (today.winner.kind === 'sanctoral' && isAtLeast(today.winner.rank, 'duplex-2-classis')) {
+    todayWins = true;
+  } else {
+    todayWins = !hasFirstVespers(tomorrow);
+  }
+
+  if (todayWins) {
+    // Today wins outright, but tomorrow is still commemorated here as
+    // long as it's a real sanctoral winner — see
+    // commemorationOfDisplacedSuccessor's own doc comment for why this
+    // direction doesn't exclude Simplex the way the reverse one does.
+    const commemoration = commemorationOfDisplacedSuccessor(today.winner, tomorrow.winner);
+    return commemoration ? { ...today, commemorations: [...today.commemorations, commemoration] } : today;
+  }
+  return anticipated(today, tomorrow);
+}

src/data/calendar/easter-offsets.yml

@@ -1,18 +1,30 @@
 # Offsets in days from Easter Sunday (0). Negative = before Easter, positive
 # = after. Covers the whole Easter-anchored span: Septuagesima through the
-# last Sunday of Trinitytide. A temporal-id's *name* (and hence whether it
-# reads "trinitytide" or "time after pentecost") lives here as data, not as
-# a compiled TS enum — see calendar/types.ts's Season type.
+# last Sunday of Trinitytide. A season's *name* (and hence whether it reads
+# "trinitytide" or "time after pentecost") lives here as data, not as a
+# compiled TS enum — see calendar/types.ts's Season type.
 #
-# PLACEHOLDER: only a handful of anchor points, to prove the shape. The full
-# set of Sundays/ferias between anchors is content-authoring work for
-# milestone 4.
-offsets:
-  -63: septuagesima-sunday
-  -56: sexagesima-sunday
-  -49: quinquagesima-sunday
-  -46: ash-wednesday
-  0: easter-sunday
-  39: ascension-thursday
-  49: pentecost-sunday
-  56: trinity-sunday
+# `ranges` gives the season that starts at each offset and runs until the
+# next range's offset (or, for the last entry, until Advent cuts it off —
+# see calendar/temporal.ts). `days` overrides a single specific offset with
+# its own one-day season, for movable feasts that aren't a whole season
+# but that other by-season tables (prime-chapter-responsory-by-season.yml,
+# hymn-doxology-by-season.yml) already reference by name.
+ranges:
+  - season: septuagesima
+    fromOffset: -63
+  - season: lent
+    fromOffset: -46
+  - season: passiontide
+    fromOffset: -14
+  - season: eastertide
+    fromOffset: 0
+  - season: ascensiontide
+    fromOffset: 39
+  - season: pentecost
+    fromOffset: 49
+  - season: trinitytide
+    fromOffset: 56
+days:
+  60: corpus-christi # Thursday after Trinity Sunday
+  68: sacred-heart # Friday after the octave of Corpus Christi

src/data/calendar/saints/all-saints-of-the-benedictine-order.yml

@@ -0,0 +1,17 @@
+# A monastic-calendar-specific addition, absent from the base Tridentine
+# table (1570.txt) entirely -- unsurprisingly, since this feast (all the
+# saints of St. Benedict's own Order) exists only in Benedictine-family
+# calendars. Verified live (Monastic Tridentinum 1617, 2025-11-13) --
+# winner outright, Duplex II. classis, alone; one of the highest-ranked
+# monastic-only additions found in this pull, alongside Ss. Placid and
+# Companions (October). No unique collect: the raw file at this MM-DD
+# slot (Sancti/11-13.txt) is actually St. Didacus's (a later, 1588+
+# addition to this filename slot) -- a live prayTertia query for the
+# Monastic 1617 track returns no Oratio at all, confirming propers: null
+# is correct.
+id: all-saints-of-the-benedictine-order
+name: "All Saints of the Order of St. Benedict"
+nameLa: "Omnes Sancti Ordinis Sancti Benedicti"
+rank: duplex-2-classis
+common: proper-to-all-saints
+propers: "all-saints-of-the-benedictine-order"

src/data/calendar/saints/all-saints.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (web/www/horas/Latin/Sancti/11-01.txt,
+# untagged/default [Rank] block). Propers backfilled during the November
+# pull now that the collect-pulling methodology exists -- own proper
+# collect (see all-saints-collect.yml for a note on how its English side
+# was sourced).
+id: all-saints
+name: "All Saints"
+nameLa: "Omnes Sancti"
+rank: duplex-1-classis
+common: proper-to-all-saints
+propers: "all-saints"
+# Has a real octave (Nov 1-8) -- see calendar/types.ts's OctaveConfig.
+octave:
+  enabled: true

src/data/calendar/saints/annunciation.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/03-25.txt` -- "In Annuntiatione
+# Beatæ Mariæ Virginis;;Duplex I classis;;6.92;;ex C11". Own proper
+# [Oratio]/[Ant 1]/Nocturn 2-3 content of her own (real, unique text
+# throughout), not a bare Common fallback -- same pattern as
+# our-lady-of-the-snows.yml's siblings (assumption, immaculate-
+# conception, nativity-bvm). One of the four "fixed BVM feast, excluded
+# per the usual convention" items literally named alongside Purification
+# in this app's original stale exclusion note.
+id: annunciation
+name: "The Annunciation of the Blessed Virgin Mary"
+nameLa: "Annuntiatio Beatæ Mariæ Virginis"
+rank: duplex-1-classis
+common: common-of-the-bvm
+propers: "annunciation"

src/data/calendar/saints/apparition-of-st-michael.yml

@@ -0,0 +1,12 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-05-08, no Sunday collision) -- winner outright, Duplex majus.
+# A second, distinct feast of St. Michael (his apparition at Monte Gargano)
+# from st-michael.yml's Sept 29 dedication feast -- kept as a separate
+# record, same precedent as the two Chair-of-Peter feasts. Own proper
+# collect and antiphon.
+id: apparition-of-st-michael
+name: "The Apparition of St. Michael the Archangel"
+nameLa: "Apparitio Sancti Michaelis Archangeli"
+rank: duplex-majus
+common: common-of-an-angel
+propers: "apparition-of-st-michael"

src/data/calendar/saints/apparition-of-the-immaculate-bvm.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/02-11.txt` -- "In Apparitione
+# Beatæ Mariæ Virginis Immaculatæ;;Duplex majus;;4;;ex C11" (Our Lady of
+# Lourdes). Own proper [Oratio]/[Ant 1]/Nocturn 2 vita (the Bernadette
+# apparition narrative); her Nocturn 3 is a direct `@Sancti/12-10bmv`
+# cross-reference -- shares content with the 3rd day within the Octave
+# of the Immaculate Conception (a different reading than
+# immaculate-conception.yml's own Dec 8 Nocturn 2 content).
+id: apparition-of-the-immaculate-bvm
+name: "The Apparition of the Immaculate Blessed Virgin Mary (Our Lady of Lourdes)"
+nameLa: "Apparitio Immaculatæ Beatæ Mariæ Virginis"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "apparition-of-the-immaculate-bvm"

src/data/calendar/saints/assumption.yml

@@ -0,0 +1,26 @@
+# Verified against Divinum Officium (web/www/horas/Latin/Sancti/08-15.txt,
+# untagged/default [Rank] block). Propers backfilled during the August
+# pull (live kalendar/prayTertia check, 2025-08-15) now that the
+# collect-pulling methodology exists -- own proper collect. Its own
+# [Ant 1] is itself a cross-reference (@Sancti/08-15t, a Tridentine-
+# specific block) rather than plain text, so left unpulled this pass.
+id: assumption
+name: "The Assumption of the Blessed Virgin Mary"
+nameLa: "Assumptio Beatæ Mariæ Virginis"
+rank: duplex-1-classis
+common: common-of-the-bvm
+propers: "assumption"
+# Has a real octave (Aug 15-22) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's own override -- a Semiduplex saint no
+# longer just ties (and, by the ordinary-day tie rule, wins) an
+# ordinary octave day here; it loses outright to the octave instead.
+# Concrete motivation: st-john-eudes.yml's demotion to Semiduplex only
+# actually cedes Aug 19 to the octave because of this. Side effect
+# accepted by the user: st-damasus.yml (Dec 11, Immaculate Conception's
+# octave) and st-nicholas-of-tolentino.yml (Sep 10, Nativity of the
+# BVM's octave) are unrelated octaves not touched by this change, so
+# they're unaffected -- this only strengthens Assumption's own octave.
+octave:
+  enabled: true
+  wins: duplex

src/data/calendar/saints/chair-of-st-peter-at-antioch.yml

@@ -0,0 +1,12 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-02-22, no Sunday collision) -- winner outright, Duplex majus.
+# The second of the two Chair-of-Peter feasts (see chair-of-st-peter-at-
+# rome.yml, Jan 18) -- this is the antiphon's true home, and the collect is
+# identical text to Rome's, both intentionally duplicated rather than shared.
+id: chair-of-st-peter-at-antioch
+name: "The Chair of St. Peter at Antioch"
+nameLa: "Cathedra Sancti Petri Antiochiæ"
+rank: duplex-majus
+common: common-of-an-apostle
+propers: "chair-of-st-peter-at-antioch"
+minorHoursCommon: common-of-a-confessor-bishop

src/data/calendar/saints/chair-of-st-peter-at-rome.yml

@@ -0,0 +1,15 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-01-18, no Sunday collision) -- winner outright, Duplex majus.
+# About St. Peter the apostle's office, not a feast of the Lord -- kept in the
+# sanctoral store like the rest, distinct from the second Chair-of-Peter feast
+# at Antioch (Feb 22, not yet pulled). Own proper collect and antiphon --
+# the antiphon is a cross-reference in the source
+# (web/www/horas/Latin/Sancti/01-18.txt's [Ant 1] points at Sancti/02-22.txt,
+# since both Chair feasts share it).
+id: chair-of-st-peter-at-rome
+name: "The Chair of St. Peter at Rome"
+nameLa: "Cathedra Sancti Petri Romæ"
+rank: duplex-majus
+common: common-of-an-apostle
+propers: "chair-of-st-peter-at-rome"
+minorHoursCommon: common-of-a-confessor-bishop

src/data/calendar/saints/commemoration-of-st-paul.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-30, no Sunday collision) -- winner outright, Duplex. A
+# third distinct Pauline feast this pull has found (alongside the
+# Conversion of St. Paul, Jan 25, and Ss. Peter and Paul, June 29) -- kept
+# as its own record. Own proper collect and antiphon.
+id: commemoration-of-st-paul
+name: "Commemoration of St. Paul, Apostle"
+nameLa: "Commemoratio Sancti Pauli Apostoli"
+rank: duplex
+common: common-of-an-apostle
+propers: "commemoration-of-st-paul"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-30.txt) --
+# [Rule]/[Rank] point to Commune/C1 instead, the same C-number family already
+# live-query-verified for common-of-apostles.yml (see TODO.md's 'minor hour
+# content gaps' section).
+minorHoursCommon: common-of-apostles

src/data/calendar/saints/conversion-of-st-paul.yml

@@ -0,0 +1,9 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-01-25, no Sunday collision) -- winner outright, Duplex majus. Own
+# proper collect and antiphon.
+id: conversion-of-st-paul
+name: "The Conversion of St. Paul, Apostle"
+nameLa: "Conversio Sancti Pauli Apostoli"
+rank: duplex-majus
+common: common-of-an-apostle
+propers: "conversion-of-st-paul"

src/data/calendar/saints/decollation-of-st-john-baptist.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-08-29) -- winner outright, Duplex, over the stub
+# St. Sabina (see st-sabina.yml). About St. John the Baptist's beheading,
+# not a feast of the Lord/BVM, so kept in scope like his Nativity in June.
+# Own proper collect and antiphon.
+id: decollation-of-st-john-baptist
+name: "The Beheading of St. John the Baptist"
+nameLa: "Decollatio Sancti Joannis Baptistæ"
+rank: duplex
+common: common-of-a-martyr
+propers: "decollation-of-st-john-baptist"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-29.txt) --
+# [Rule]/[Rank] point to Commune/C2a instead, the same C-number family
+# already live-query-verified for common-of-a-martyr.yml (see TODO.md's
+# 'minor hour content gaps' section).
+minorHoursCommon: common-of-a-martyr

src/data/calendar/saints/dedication-of-the-basilica-of-the-most-holy-savior.yml

@@ -0,0 +1,30 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/11-09.txt` -- "In
+# Dedicatione Archibasilicæ Ss. Salvatoris;;Duplex II. classis;;5;;ex C8".
+# Previously excluded entirely under a stale "fixed feast of the Lord,
+# not modeled" note in sanctoral-calendar.yml's own November comment --
+# wrong, same class of error as our-lady-of-the-snows.yml: she has real,
+# unique Lectio1-6(+6a) content of her own (the history of the Lateran
+# basilica's dedication under Pope St. Sylvester, through its later
+# restorations), and her `ex C8` Rule just means her collect/antiphon/
+# Nocturn-3-Gospel-and-homily come from the existing Common of a
+# Dedication (`collect-c8.yml`, `benedictus-antiphon-common-of-a-
+# dedication.yml` -- already authored, reused directly here, not
+# duplicated) -- the same Common already used by
+# dedication-of-the-basilicas-of-ss-peter-and-paul.yml.
+id: dedication-of-the-basilica-of-the-most-holy-savior
+name: "Dedication of the Basilica of the Most Holy Savior (the Lateran)"
+nameLa: "Dedicatio Basilicæ Sanctissimi Salvatoris"
+rank: duplex-2-classis
+common: common-of-a-dedication
+propers: null
+collectCommon: collect-c8
+# collect-c8's own text has no {N} placeholder to substitute (it's about
+# the building, not a saint) -- collectName is still required by
+# getDayCollect's own lookup, but its value is never actually used.
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-a-dedication
+benedictusCommon: common-of-a-dedication

src/data/calendar/saints/dedication-of-the-basilicas-of-ss-peter-and-paul.yml

@@ -0,0 +1,20 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-11-18) -- winner outright, Duplex, alone. About the
+# basilicas honoring Ss. Peter and Paul specifically (not a feast of the
+# Lord the way the Nov 9 Dedication of the Basilica of the Most Holy
+# Savior is -- see this month's sanctoral-calendar.yml comment on that
+# exclusion), so kept in scope like the Commemoration of St. Paul (June)
+# and the two Chair-of-Peter feasts (January). No unique collect: the raw
+# file at this MM-DD slot (Sancti/11-18.txt) is empty.
+id: dedication-of-the-basilicas-of-ss-peter-and-paul
+name: "Dedication of the Basilicas of Ss. Peter and Paul"
+nameLa: "Dedicatio Basilicarum Sanctorum Petri et Pauli Apostolorum"
+rank: duplex
+common: common-of-an-apostle
+propers: null
+collectCommon: collect-c8
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-a-dedication
+benedictusCommon: common-of-a-dedication

src/data/calendar/saints/exaltation-of-the-holy-cross.yml

@@ -0,0 +1,21 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/09-14.txt` -- "In
+# Exaltatione Sanctæ Crucis;;Duplex majus;;4;;ex Sancti/05-03". Previously
+# excluded entirely under a stale "fixed feast of the Lord, same
+# convention as the Finding of the Holy Cross" note in
+# sanctoral-calendar.yml's own September comment -- wrong, same class of
+# error, now fixed alongside it (see finding-of-the-holy-cross.yml). Her
+# own [Rule] is `ex Sancti/05-03` -- she reuses the Finding of the Holy
+# Cross's content wholesale, so `propers` points at that saint's own
+# collect/antiphon files directly rather than duplicating them (same
+# cross-id-reuse pattern as st-michael.yml's `apparition-of-st-michael`).
+# The Matins nocturn-readings mechanism has no equivalent cross-id
+# lookup, so exaltation-of-the-holy-cross.yml duplicates
+# finding-of-the-holy-cross.yml's own reading content instead.
+id: exaltation-of-the-holy-cross
+name: "The Exaltation of the Holy Cross"
+nameLa: "Exaltatio Sanctæ Crucis"
+rank: duplex-majus
+common: proper-to-the-finding-of-the-holy-cross
+propers: "finding-of-the-holy-cross"

src/data/calendar/saints/example-confessor.yml

@@ -1,9 +1,8 @@
-# PLACEHOLDER — demonstrates the saint-record shape only. Not a real saint,
-# not a real rank, not a real day assignment (see sanctoral-calendar.yml for
-# where this id gets pointed at a day). Which day(s) point here can change
-# freely without ever touching this file.
+# PLACEHOLDER — demonstrates the saint-record shape only, deliberately not
+# mapped to any day in sanctoral-calendar.yml (which now holds real,
+# verified entries — see that file). Not a real saint, not a real rank.
 id: example-confessor
 name: "Example Confessor (placeholder)"
-rank: placeholder # real rank scheme is a milestone 4 decision, not made yet
+rank: simplex # placeholder value
 common: common-of-a-confessor-not-bishop
-propers: null # set to a propers id once/if this saint has a full proper
+propers: null

src/data/calendar/saints/finding-of-st-stephen.yml

@@ -0,0 +1,23 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2026-08-03, a clean weekday). In the real engine, Aug 3
+# falling on a Sunday transfers this forward to Aug 7 (see st-donatus.yml)
+# -- this app's transfer machinery doesn't chase that multi-day skip
+# search, so in this app that Sunday simply displaces this feast entirely
+# for that year (same "not delivered rather than guessed at" stance as
+# other unmodeled transfer chains) rather than landing it on Aug 7. About
+# St. Stephen the Protomartyr's relics, not a feast of the Lord/BVM, so
+# kept in scope like the Conversion of St. Paul. Own collect: a deliberate
+# cross-reference to St. Stephen's own Dec 26 feast (@Sancti/12-26) with
+# one word substituted ("natalícia" -> "Inventiónem") -- the reference
+# engine expands this to full text automatically. Its [Ant 1] is the same
+# Dec 26 antiphon reused verbatim, no substitution this time.
+id: finding-of-st-stephen
+name: "The Finding of St. Stephen, Protomartyr"
+nameLa: "Inventio Sancti Stephani Protomartyris"
+rank: semiduplex
+common: common-of-a-martyr
+propers: "finding-of-st-stephen"
+# P/T/S/N: [Rule] points directly at st-stephen-protomartyr's own file
+# (Sancti/12-26), not a Commune category -- reuses his own already-authored
+# proper P/T/S/N wholesale (see TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: st-stephen-protomartyr

src/data/calendar/saints/finding-of-the-holy-cross.yml

@@ -0,0 +1,19 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/05-03.txt` --
+# "Inventione Sanctæ Crucis;;Duplex II classis;;5.2;;". Previously
+# excluded entirely under a stale "fixed feast of the Lord, not modeled"
+# note in sanctoral-calendar.yml's own May comment -- wrong, same class
+# of error as our-lady-of-the-snows.yml: her [Rule] says `proprium` -- a
+# fully proper feast with real, complete unique text throughout
+# (collect, antiphon, 8 Matins lessons -- the file itself has no
+# Lectio9 at all, an unusual but genuine structural feature, not an
+# omission on this app's part). `Sancti/09-14.txt`'s Exaltation of the
+# Holy Cross reuses this same content wholesale (`ex Sancti/05-03`) --
+# see exaltation-of-the-holy-cross.yml.
+id: finding-of-the-holy-cross
+name: "The Finding of the Holy Cross"
+nameLa: "Inventio Sanctæ Crucis"
+rank: duplex-2-classis
+common: proper-to-the-finding-of-the-holy-cross
+propers: "finding-of-the-holy-cross"

src/data/calendar/saints/forty-holy-martyrs.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2033-03-10, no Sunday collision) -- winner outright, Semiduplex.
+# Own proper collect, no unique antiphon of their own.
+id: forty-holy-martyrs
+name: "The Forty Holy Martyrs"
+nameLa: "Quadraginta Sancti Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "forty-holy-martyrs"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (03-10.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/guardian-angels.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/10-02.txt` -- "Duplex majus;;4;;
+# vide C4" (Common of a Confessor Bishop -- structural category only;
+# the feast's own content is fully proper throughout). Own real
+# [Oratio] and own [Ant 1]. Own Nocturn 2-3 content (Nocturn 2: St.
+# Bernard's own homily on Psalm 90 "Qui habitat"; Nocturn 3: St.
+# Hilary's own homily, Gospel bare incipit). Nocturn 1 (Lectio1-3,
+# scripture) not modeled per this app's established convention.
+id: guardian-angels
+name: "The Guardian Angels"
+nameLa: "Sancti Angeli Custodes"
+rank: duplex-majus
+common: common-of-an-angel
+propers: "guardian-angels"

src/data/calendar/saints/holy-innocents.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2026-12-28) -- wins outright, Duplex II. classis, within
+# Christmas's Octave (privileged-feria-minor), Octave day commemorated in
+# return. About the Innocents slain at Christ's birth, not a feast of the
+# Lord/BVM directly, so kept in scope like every other real saint's day
+# this pull has found. Own proper collect and antiphon.
+id: holy-innocents
+name: "The Holy Innocents, Martyrs"
+nameLa: "Sancti Innocentes, Martyres"
+rank: duplex-2-classis
+common: common-of-several-martyrs
+propers: "holy-innocents"
+# Has its own real octave, one of the three "Comites Christi" (with St.
+# Stephen and St. John) -- see st-stephen-protomartyr.yml.
+octave:
+  enabled: true

src/data/calendar/saints/holy-name-of-mary.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-12.txt` -- "S. Nominis
+# Beatæ Mariæ Virginis;;Duplex majus;;4;;ex C11". Own real [Oratio]
+# and own untagged [Ant 1] (shared verbatim with our-lady-of-mount-
+# carmel-antiphon.yml -- a coincidental reuse of the same formulaic
+# BVM-commemoration text already present in the reference source
+# itself, not a copy-paste error introduced here). Own Nocturn 2-3
+# content (Nocturn 3 is St. Peter Chrysologus's own homily on the
+# Annunciation, not a cross-reference). Instituted 1683 by Innocent XI
+# after the relief of Vienna.
+id: holy-name-of-mary
+name: "The Holy Name of the Blessed Virgin Mary"
+nameLa: "Sanctissimum Nomen Mariæ"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "holy-name-of-mary"

src/data/calendar/saints/immaculate-conception.yml

@@ -0,0 +1,20 @@
+# Verified against Divinum Officium (web/www/horas/Latin/Sancti/12-08.txt,
+# untagged/default [Rank] block). Propers backfilled during the December
+# pull now that the collect-pulling methodology exists -- own proper
+# collect and antiphon.
+id: immaculate-conception
+name: "The Immaculate Conception of the Blessed Virgin Mary"
+nameLa: "Immaculata Conceptio Beatæ Mariæ Virginis"
+rank: duplex-1-classis
+common: common-of-the-bvm
+propers: "immaculate-conception"
+minorHoursCommon: common-of-the-bvm
+# Has a real octave (Dec 8-15) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's and assumption.yml's own overrides. Side
+# effect accepted by the user: St. Damasus (Dec 11, semiduplex) no
+# longer ties and wins an ordinary octave day here -- he now loses
+# outright to the octave instead (see st-damasus.yml).
+octave:
+  enabled: true
+  wins: duplex

src/data/calendar/saints/maternity-of-the-bvm.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/10-11.txt` -- "Maternitatis
+# Beatæ Mariæ Virginis;;Duplex 2 classis;;5.1;;ex C11". Own real
+# [Oratio] and own [Ant 1]. Own Nocturn 2-3 content (Nocturn 2: two
+# excerpts from Pope St. Leo the Great's own Nativity sermons; Nocturn
+# 3: St. Bernard's own homily, Gospel bare incipit). Instituted 1931 by
+# Pius XI for the 1500th anniversary of the Council of Ephesus (see the
+# feast's own Lectio6, quoted in nocturn-readings).
+id: maternity-of-the-bvm
+name: "The Maternity of the Blessed Virgin Mary"
+nameLa: "Maternitas Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "maternity-of-the-bvm"

src/data/calendar/saints/most-precious-blood.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-01.txt` -- "Duplex I
+# classis;;6;;" (`[Rule]` says `proprium` -- "Festum Domini"). A fully
+# proper feast of the Lord with real, complete unique text throughout
+# (own Oratio, own Ant 1, full 9-lesson Matins), same pattern as
+# transfiguration.yml/finding-of-the-holy-cross.yml. Instituted by Pius
+# IX in 1849, raised to Duplex I Classis by Pius XI for the 1933
+# nineteen-century jubilee of the Redemption (see the feast's own
+# Lectio6, quoted in nocturn-readings).
+id: most-precious-blood
+name: "The Most Precious Blood of Our Lord Jesus Christ"
+nameLa: "Pretiosissimus Sanguis Domini Nostri Jesu Christi"
+rank: duplex-1-classis
+common: proper-to-the-most-precious-blood
+propers: "most-precious-blood"

src/data/calendar/saints/nativity-bvm.yml

@@ -0,0 +1,22 @@
+# Verified against Divinum Officium (web/www/horas/Latin/Sancti/09-08.txt,
+# untagged/default [Rank] block). Propers backfilled during the September
+# pull (live kalendar/prayTertia check, 2025-09-08) now that the
+# collect-pulling methodology exists -- own proper collect and antiphon;
+# wins outright over the stub St. Hadrian (see st-hadrian.yml).
+id: nativity-bvm
+name: "The Nativity of the Blessed Virgin Mary"
+nameLa: "Nativitas Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "nativity-bvm"
+minorHoursCommon: common-of-the-bvm
+# Has a real octave (Sep 8-15) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's and assumption.yml's own overrides. Side
+# effect accepted by the user: St. Nicholas of Tolentino (Sep 10,
+# semiduplex) no longer ties and wins an ordinary octave day here -- he
+# now loses outright to the octave instead (see
+# st-nicholas-of-tolentino.yml).
+octave:
+  enabled: true
+  wins: duplex

src/data/calendar/saints/nativity-of-st-john-the-baptist.yml

@@ -0,0 +1,24 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-24, no Sunday collision) -- winner outright, Duplex I.
+# classis, the highest rank pulled in this set. About St. John the
+# Baptist's own nativity, not a feast of the Lord/BVM, so kept in the
+# sanctoral store like the Conversion of St. Paul/Chair-of-Peter feasts
+# despite the very high rank. Own proper collect and antiphon.
+#
+# `common: common-of-an-apostle` is a placeholder, not a liturgical
+# claim -- the reference engine assigns this feast no Commune at all
+# (every [Rule] line in Sancti/06-24.txt and SanctiM/06-24.txt points to
+# proper text, never a Commune category), so no better-fitting id exists
+# either. Now verified-inert: every part this field could ever be
+# consulted for (Matins invitatory/hymn/Nocturn psalmody, Vespers
+# psalmody, the Lauds/Vespers bundle, Benedictus antiphon, collect, all
+# four minor hours) has its own real proper text authored, so this field
+# is never actually reached by any resolver (see
+# data/hours/matins-psalmody-overrides/saints/nativity-of-st-john-the-baptist.yml's
+# own comment).
+id: nativity-of-st-john-the-baptist
+name: "The Nativity of St. John the Baptist"
+nameLa: "Nativitas Sancti Joannis Baptistæ"
+rank: duplex-1-classis
+common: common-of-an-apostle
+propers: "nativity-of-st-john-the-baptist"

src/data/calendar/saints/octave-of-all-saints.yml

@@ -0,0 +1,19 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/11-08.txt` -- "In Octava Omnium
+# Sanctorum;;Duplex majus;;4.1;;vide Sancti/11-01" (cross-references
+# All Saints' own file for Rank/Rule). No [Oratio] at all in this
+# file, unlike octave-of-ss-peter-and-paul.yml -- collect reuses All
+# Saints' own real proper collect via the cross-id `propers` pointer
+# (same reasoning as the Finding/Exaltation of the Holy Cross and
+# Gabriel/Raphael Archangel pattern). But this day does have genuine
+# own Nocturn 2-3 content (St. Cyprian's "De mortalitate", St.
+# Augustine's homily on the Beatitudes) -- see
+# nocturn-readings/octave-of-all-saints.yml, since the Matins
+# nocturn-readings mechanism has no cross-id lookup the way
+# collect/antiphon do.
+id: octave-of-all-saints
+name: "The Octave Day of All Saints"
+nameLa: "Octava Omnium Sanctorum"
+rank: duplex-majus
+common: proper-to-all-saints
+propers: "all-saints"

src/data/calendar/saints/octave-of-ss-peter-and-paul.yml

@@ -0,0 +1,24 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-06.txt` -- "In Octava Ss.
+# Apostolorum Petri et Pauli;;Duplex majus;;4.1;;vide C1" (Common of
+# Apostles). The Octave Day itself of Ss. Peter and Paul (June 29 + 7),
+# with its own real proper [Oratio] and own Nocturn 2-3 content
+# (Chrysostom's sermon on both Apostles; Jerome's homily on Christ
+# walking on the water). Its [Ant 1]/[Ant 2]/[Ant 3] are all a
+# cross-reference (`@Sancti/07-03oct`) to the file for the Octave's
+# 5th day, which has its own real proper antiphon text -- authored
+# here directly since it is the actual text this day uses, not a
+# private duplicate (the Matins nocturn-readings mechanism has no
+# cross-id lookup the way collect/antiphon do via `propers`, so this
+# mirrors the same reasoning as exaltation-of-the-holy-cross.yml's
+# collect/antiphon pointer, just inlined since there's no saint id to
+# point at here). Rest of the Octave's own continuation days (July 4,
+# 7-8 minus named saints) aren't modeled -- pure octave-continuation
+# content remains a separate, not-yet-built mechanism (see
+# vu-sanctoral-sweep-progress memory).
+id: octave-of-ss-peter-and-paul
+name: "The Octave Day of Ss. Peter and Paul, Apostles"
+nameLa: "Octava Sanctorum Petri et Pauli, Apostolorum"
+rank: duplex-majus
+common: common-of-apostles
+propers: "octave-of-ss-peter-and-paul"

src/data/calendar/saints/our-lady-of-guadalupe.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: Sancti/12-12n.txt --
+# "Beatæ Mariæ Virginis de Guadalupe;;Duplex;;3;;vide C11" (Common of
+# the BVM), the same rank family and `n` (national-calendar) sourcing as
+# apparition-of-the-immaculate-bvm.yml (Our Lady of Lourdes, Feb 11) --
+# not a canonization so the late-canonization deflation rule doesn't
+# apply; the cultus itself is old enough for the project's period
+# (Benedict XIV confirmed it 1754, Pius X named her Patroness of Latin
+# America). Own proper Oratio and [Ant 1], same scope as the Lourdes
+# feast -- no separate Vespers/Lauds antiphon set transcribed, Common of
+# the BVM (C11) carries the rest when she wins outright.
+id: our-lady-of-guadalupe
+name: "Our Lady of Guadalupe"
+nameLa: "Beata Maria Virgo de Guadalupe"
+rank: duplex
+common: common-of-the-bvm
+propers: "our-lady-of-guadalupe"

src/data/calendar/saints/our-lady-of-mount-carmel.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-16.txt` -- "In
+# Commemoratione Beatæ Mariæ Virgine de Monte Carmelo;;Duplex majus;;
+# 4;;ex C11". Own real [Oratio] and own untagged [Ant 1] ("Sancta
+# María, succúrre míseris..." -- a separate `(rubrica cisterciensis)`
+# variant cross-references `@CommuneCist/C11` instead, ignored per the
+# untagged-block convention). Own Nocturn 2 vita content. No Lectio7-9
+# in her own file (only a `Responsory7` cross-ref) -- defers to the
+# Common of the BVM's own Nocturn 3, not transcribed here, same pattern
+# as our-lady-of-the-snows.yml/presentation-of-the-bvm.yml.
+id: our-lady-of-mount-carmel
+name: "Our Lady of Mount Carmel"
+nameLa: "Beata Maria Virgo de Monte Carmelo"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "our-lady-of-mount-carmel"

src/data/calendar/saints/our-lady-of-ransom.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-24.txt` -- "Beatæ Mariæ
+# Virginis de Mercede;;Duplex majus;;4;;ex C11". Own real [Oratio].
+# No [Ant 1] of her own in this file -- benedictusCommon falls back to
+# the plain Common of the BVM. No Lectio7-9 -- defers to the Common's
+# own Nocturn 3, not transcribed here.
+id: our-lady-of-ransom
+name: "Our Lady of Ransom"
+nameLa: "Beata Maria Virgo de Mercede"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "our-lady-of-ransom"
+benedictusCommon: common-of-the-bvm

src/data/calendar/saints/our-lady-of-the-snows.yml

@@ -0,0 +1,32 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/08-05.txt` --
+# "Sanctæ Mariæ Virginis ad Nives;;Duplex majus;;4;;ex C11". Previously
+# excluded from this app's calendar entirely under a stale "fixed BVM
+# feasts aren't modeled" note in sanctoral-calendar.yml's own August
+# comment -- wrong: this app already models three other fixed BVM feasts
+# the same way (assumption, immaculate-conception, nativity-bvm), and
+# this one has real, complete content too (Matins readings, sourced
+# directly; collect/antiphon via the Common-of-the-BVM fallback her own
+# `[Rule]` already points to, `ex C11` -- see collect-c11.yml and
+# benedictus-antiphon-common-of-the-bvm.yml). No `propers` of her own:
+# unlike the other three BVM feasts (each of which has real unique
+# collect/antiphon text), her file has none, so `collectCommon`/
+# `benedictusCommon` is the correct mechanism here, same as any other
+# `propers: null` saint falling back to a shared Common.
+id: our-lady-of-the-snows
+name: "Our Lady of the Snows (Dedication of St. Mary Major)"
+nameLa: "Dedicatio Sanctæ Mariæ ad Nives"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: null
+collectCommon: collect-c11
+# collect-c11's own text has no {N} placeholder to substitute (it
+# addresses "fámulis tuis" generically, not the saint by name) --
+# collectName is still required by getDayCollect's own lookup, but its
+# value is never actually used for this particular Common.
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-the-bvm
+benedictusCommon: common-of-the-bvm

src/data/calendar/saints/presentation-of-the-bvm.yml

@@ -0,0 +1,25 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/11-21.txt` -- "In
+# Præsentatione Beatæ Mariæ Virginis;;Duplex majus;;4;;ex C11". Previously
+# excluded entirely under a stale "fixed BVM feast, excluded per the
+# usual convention" note in sanctoral-calendar.yml's own November comment
+# -- wrong, same class of error as our-lady-of-the-snows.yml. Unlike her,
+# this feast DOES have a real, unique [Oratio] of its own (see
+# presentation-of-the-bvm-collect.yml) and Nocturn 2 vita content
+# (Lectio4-6, St. John Damascene + St. Ambrose on the Blessed Virgin).
+# Her [Ant 1] is a substituted Common text (`@Commune/C10:Ant 2_`, with a
+# truncate-and-add-alleluia edit specific to this feast -- see
+# presentation-of-the-bvm-antiphon.yml), effectively proper by the same
+# "own [Name]/edit makes shared-formula text proper" reasoning as
+# st-lucy-collect.yml, so authored via `propers` rather than a Common
+# fallback. No Lectio7-9 override in her own file (defers to Commune/
+# C11's own Nocturn 3, same as our-lady-of-the-snows.yml's — see that
+# file's own Nocturn 3 comment for why it's duplicated rather than
+# cross-referenced).
+id: presentation-of-the-bvm
+name: "The Presentation of the Blessed Virgin Mary"
+nameLa: "Præsentatio Beatæ Mariæ Virginis"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "presentation-of-the-bvm"

src/data/calendar/saints/purification.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/02-02.txt` -- "In
+# Purificatione Beatæ Mariæ Virginis;;Duplex 2 class;;5.1;;ex C11". Real
+# unique [Oratio]/[Ant 1]/Nocturn 2-3 content of her own (not a bare
+# Common fallback the way our-lady-of-the-snows.yml was) -- same
+# fixed-BVM-feast pattern as that pass, previously excluded under the
+# same stale "not modeled" convention this app has now dropped
+# per direct instruction (2026-08): import available content regardless
+# of rubric-era markers.
+id: purification
+name: "The Purification of the Blessed Virgin Mary (Candlemas)"
+nameLa: "Purificatio Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "purification"

src/data/calendar/saints/queenship-of-the-bvm.yml

@@ -0,0 +1,24 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/05-31.txt` -- "Beatæ Mariæ
+# Virginis Reginæ;;Duplex II classis;;5.1;;ex C11" (Common of Feasts
+# of the BVM). Instituted 1954 by Pius XII's encyclical "Ad cæli
+# Reginam" -- her own file has full, real, proper content throughout:
+# own [Oratio], own [Ant 1] (not a Common substitution, unlike
+# presentation-of-the-bvm.yml), and a full nine-lesson Matins office of
+# her own. Nocturn 1 (Sir 24, plain scripture) isn't modeled, per this
+# app's established convention (getNocturnReadings only ever carries
+# Nocturn 2/3 across the whole calendar). Nocturn 2 (Lectio4-6): a
+# three-part patristic/magisterial anthology (Peter Canisius,
+# Athanasius via Canisius, Pius XII's "Ad cæli Reginam" itself) rather
+# than one continuous narrative -- still combined into a single
+# reading, matching how this app already treats other multi-source
+# Nocturn 2 content. Nocturn 3: her own Gospel citation ends "Et
+# réliqua"/"And so on" with no full pericope given -- per the
+# bare-incipit convention, only the homily (Lectio7-9, St. Bonaventure)
+# is authored, isGospel: false, no citation field.
+id: queenship-of-the-bvm
+name: "The Queenship of the Blessed Virgin Mary"
+nameLa: "Beata Maria Virgo Regina"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "queenship-of-the-bvm"

src/data/calendar/saints/seven-sorrows-of-the-bvm.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-15.txt` -- "Septem Dolorum
+# Beatæ Mariæ Virginis;;Duplex 2nd class;;5.1;;ex C11". Own real
+# [Oratio] and own [Ant 1]. Nocturn 2 (Lectio4-6) is a direct
+# `@Tempora/Quad5-5` cross-reference (Friday of Passion Week's own
+# temporal content, reused wholesale here) -- not this feast's own
+# content, not transcribed, per the bare-cross-reference convention.
+# Nocturn 3 (Lectio7-9) is her own real content (St. Ambrose's homily
+# on John 19:25-27 and his own Epistle 25).
+id: seven-sorrows-of-the-bvm
+name: "The Seven Sorrows of the Blessed Virgin Mary"
+nameLa: "Septem Dolores Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "seven-sorrows-of-the-bvm"

src/data/calendar/saints/ss-abdon-and-sennen.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2026-07-30, a year this date isn't a Sunday) -- winner outright,
+# Simplex. Own proper collect, no unique antiphon of their own.
+id: ss-abdon-and-sennen
+name: "Ss. Abdon and Sennen, Martyrs"
+nameLa: "Sancti Abdon et Sennes, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-abdon-and-sennen"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-30.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-alexander-eventius-theodulus-and-juvenal.yml

@@ -0,0 +1,20 @@
+# Secondary commemoration on 05-03, pulled from Divinum Officium's kalendar
+# headline (Monastic Tridentinum 1617) -- loses the day to the Finding of
+# the Holy Cross (a fixed-date feast of the Lord, out of scope, see
+# sanctoral-calendar.yml), so unlike most other stubs in this set, this
+# isn't just an artifact of the specific year checked: their competing
+# observance is likewise fixed-date, meaning no year exists where they'd
+# win independently. That query doesn't expose a secondary entry's own
+# rank, only its name -- simplex here is an unverified placeholder, same
+# caveat as every other stub. No text pulled at all yet.
+id: ss-alexander-eventius-theodulus-and-juvenal
+name: "Ss. Alexander I, Eventius, and Theodulus, Martyrs, and Juvenal, Bishop and Confessor"
+nameLa: "Sancti Alexander, Eventius et Theodulus, Martyres, et Sanctus Juvenalis, Episcopus et Confessor"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-alexander-eventius-theodulus-and-juvenal"
+# No [Ant 1] of its own in the source (05-03r.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-basilides-cyrinus-nabor-and-nazarius.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-12, no Sunday collision) -- winner outright, Simplex. Own
+# proper collect and antiphon.
+id: ss-basilides-cyrinus-nabor-and-nazarius
+name: "Ss. Basilides, Cyrinus, Nabor, and Nazarius, Martyrs"
+nameLa: "Sancti Basilides, Cyrinus, Nabor et Nazarius, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-basilides-cyrinus-nabor-and-nazarius"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-12o.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-chrysanthus-and-daria.yml

@@ -0,0 +1,18 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check on a clean weekday (2027-10-25, a Monday) -- wins
+# outright at Simplex. On a Saturday this date is instead outranked by
+# the generic "Sanctae Mariae Sabbato" votive (confirmed re-checking
+# 2025-10-25, a Saturday, where the votive won instead) -- an artifact of
+# the tested weekday, same pattern as several saints in August. Own
+# proper collect, no unique antiphon of their own.
+id: ss-chrysanthus-and-daria
+name: "Ss. Chrysanthus and Daria, Martyrs"
+nameLa: "Sancti Chrysanthus et Daria, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-chrysanthus-and-daria"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (10-25.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cletus-and-marcellinus.yml

@@ -0,0 +1,15 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2042-04-26, no Sunday collision) -- winner outright, Semiduplex.
+# No unique Oratio/Antiphon -- Common of Several Martyrs only.
+id: ss-cletus-and-marcellinus
+name: "Ss. Cletus and Marcellinus, Popes and Martyrs"
+nameLa: "Sancti Cletus et Marcellinus, Papæ et Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: null
+collectCommon: collect-c3b
+collectName:
+  la: ["Cletum", "Marcellínum"]
+  en: ["Cletus", "Marcellinus"]
+minorHoursCommon: common-of-pope-martyrs
+benedictusCommon: common-of-pope-martyrs

src/data/calendar/saints/ss-cornelius-and-cyprian.yml

@@ -0,0 +1,20 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-09-16, 2026-09-16) -- winner outright, Semiduplex,
+# over the stub Ss. Euphemia, Lucy, and Geminianus (see
+# ss-euphemia-lucia-and-geminianus.yml). In years where Sep 16 itself
+# falls on the movable September Ember Wednesday, that Ember day is
+# commemorated instead of Euphemia et al. (confirmed 2026) -- doesn't
+# change this saint's own outright win either way. No unique collect: the
+# raw file at this MM-DD slot (Sancti/09-16.txt) is empty.
+id: ss-cornelius-and-cyprian
+name: "Ss. Cornelius, Pope, and Cyprian, Bishop, Martyrs"
+nameLa: "Sanctus Cornelius, Papa, et Sanctus Cyprianus, Episcopus, Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: null
+collectCommon: collect-c3
+collectName:
+  la: ["Cornélii", "Cypriáni"]
+  en: ["Cornelius", "Cyprian"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cosmas-and-damian.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-09-27) -- winner outright, Semiduplex, alone. Own
+# proper collect, no unique antiphon of their own.
+id: ss-cosmas-and-damian
+name: "Ss. Cosmas and Damian, Martyrs"
+nameLa: "Sancti Cosmas et Damianus, Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-cosmas-and-damian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-27.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyprian-and-justina.yml

@@ -0,0 +1,17 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-09-26) -- winner outright, Simplex, alone. Own
+# proper collect, no unique antiphon of their own. A different St.
+# Cyprian than the Sep 16 St. Cornelius's companion (see
+# ss-cornelius-and-cyprian.yml) -- this Cyprian is paired with St.
+# Justina instead, a distinct legend.
+id: ss-cyprian-and-justina
+name: "Ss. Cyprian and Justina, Martyrs"
+nameLa: "Sanctus Cyprianus et Sancta Justina, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-cyprian-and-justina"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-26.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyriacus-largus-and-smaragdus.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-08-08) -- winner outright, Semiduplex, alone. Own
+# proper collect, no unique antiphon of their own.
+id: ss-cyriacus-largus-and-smaragdus
+name: "Ss. Cyriacus, Largus, and Smaragdus, Martyrs"
+nameLa: "Sancti Cyriacus, Largus et Smaragdus, Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-cyriacus-largus-and-smaragdus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-08.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyril-and-methodius.yml

@@ -0,0 +1,18 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-07.txt` -- "Duplex;;3;;vide
+# C4-1" (a variant Oratio of the Common of a Confessor Bishop, C4 --
+# same non-distinct-category reasoning as st-augustine-of-canterbury.yml).
+# Own real proper [Oratio] and own Nocturn 2 content (Leo XIII's own
+# encyclical letter). No [Ant 1] of its own -- benedictusCommon/
+# minorHoursCommon fall back to the plain Common of a Confessor
+# Bishop. Nocturn 3 is a direct `@Commune/C1a:LectioN` cross-reference
+# (Common of Apostles variant), not this saint's own content -- not
+# transcribed, per the bare-cross-reference convention.
+id: ss-cyril-and-methodius
+name: "Ss. Cyril and Methodius, Bishops and Confessors"
+nameLa: "Sancti Cyrillus et Methodius, Episcopi et Confessores"
+rank: duplex
+common: common-of-a-confessor-bishop
+propers: "ss-cyril-and-methodius"
+benedictusCommon: common-of-a-confessor-bishop
+minorHoursCommon: common-of-a-confessor-bishop

src/data/calendar/saints/ss-dionysius-and-companions.yml

@@ -0,0 +1,25 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-10-09) -- winner outright, Semiduplex, alone. No
+# unique collect: the raw file at this MM-DD slot (Sancti/10-09.txt) is
+# actually St. John Leonardi's (a later, 17th-century addition to this
+# filename slot, canonized 1938) -- a live prayTertia query for the
+# Monastic 1617 track returns no Oratio at all, confirming propers: null
+# is correct.
+id: ss-dionysius-and-companions
+name: "St. Dionysius, Bishop, and Companions, Martyrs"
+nameLa: "Sanctus Dionysius, Episcopus, et Socii, Martyres"
+rank: semiduplex
+common: common-of-a-martyr-bishop
+propers: "ss-dionysius-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-10-09,
+# winner outright) as byte-identical to common-of-several-martyrs's own
+# ("Vestri capílli cápitis...") -- despite `common` above saying
+# martyr-*bishop*, not several-martyrs; the two fields aren't always the
+# same category (see calendar/feasts.ts's SaintRecord.benedictusCommon
+# doc comment).
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (10-09t.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-euphemia-lucia-and-geminianus.yml

@@ -0,0 +1,21 @@
+# Genuinely unwinnable stub (verified 2025-09-16, a non-Ember year) --
+# always commemorated under Ss. Cornelius and Cyprian (see
+# ss-cornelius-and-cyprian.yml), never wins outright; both are fixed,
+# non-movable dates, so this isn't an artifact of the tested year. In
+# years where Sep 16 lands on the movable September Ember Wednesday
+# instead (confirmed 2026), this saint doesn't even surface as a
+# commemoration at all -- the Ember day takes that slot -- but that's a
+# separate, already-modeled temporal interaction (privileged-feria),
+# not a change to this saint's own standing. rank/propers unverified
+# placeholders.
+id: ss-euphemia-lucia-and-geminianus
+name: "Ss. Euphemia, Lucy, and Geminianus, Martyrs"
+nameLa: "Sanctæ Euphemia et Lucia, et Sanctus Geminianus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-euphemia-lucia-and-geminianus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-16.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-fabian-and-sebastian.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-01-20, no Sunday collision) -- winner outright, Duplex. One feast
+# shared by two martyrs. Own proper collect, no unique antiphon of their own.
+id: ss-fabian-and-sebastian
+name: "Ss. Fabian and Sebastian, Martyrs"
+nameLa: "Sancti Fabianus et Sebastianus, Martyres"
+rank: duplex
+common: common-of-several-martyrs
+propers: "ss-fabian-and-sebastian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (01-20.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-faustinus-and-jovita.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2038-02-15, a year clear of the movable post-Ash-Wednesday ferias
+# near this date, and not a Sunday) -- winner outright, Simplex. No unique
+# Oratio/Antiphon in the source -- Common of Several Martyrs only.
+id: ss-faustinus-and-jovita
+name: "Ss. Faustinus and Jovita, Martyrs"
+nameLa: "Sancti Faustinus et Jovita, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: null
+collectCommon: collect-c3a-1
+collectName:
+  la: ["Faustíni", "Jovítæ"]
+  en: ["Faustinus", "Jovita"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-felix-and-adauctus.yml

@@ -0,0 +1,30 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check on a clean weekday (2027-08-30, a Monday) -- wins outright
+# at Simplex against a bare weekday. On a Saturday this date is instead
+# outranked by the generic "Sanctae Mariae Sabbato" votive (confirmed
+# re-checking 2025-08-30, a Saturday, where the votive won instead) -- an
+# artifact of the tested weekday, same pattern as St. Stephen I (Aug 2)
+# this month and Ss. Marcellinus/Peter/Erasmus in June. No unique collect
+# of its own here on the Monastic 1617 track (a live prayTertia query for
+# that track returns no Oratio at all): the raw file at this MM-DD slot
+# (Sancti/08-30.txt) actually belongs to St. Rose of Lima, a much later
+# (17th-century) addition to this filename slot on the general
+# Tridentine/Divino Afflatu calendar -- see st-rose-of-lima.yml, now
+# authored and the day's outright winner (semiduplex > simplex) per
+# sanctoral-calendar.yml. Felix and Adauctus's own real content survives
+# at the suffixed sibling file (Sancti/08-30o.txt) and is kept here as a
+# full commemoration, not suppressed, per collision.ts.
+id: ss-felix-and-adauctus
+name: "Ss. Felix and Adauctus, Martyrs"
+nameLa: "Sancti Felix et Adauctus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-felix-and-adauctus"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-08-30, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-30o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-felix-simplicius-faustinus-and-beatrix.yml

@@ -0,0 +1,20 @@
+# Secondary commemoration on 07-29, pulled from Divinum Officium's
+# kalendar headline (Monastic Tridentinum 1617) -- loses the day to
+# St. Martha (also a fixed July 29 saint, not movable -- see st-martha.yml), so unlike most other stubs
+# in this set, this isn't just an artifact of the specific year
+# checked: their competing observance is likewise fixed-date, meaning
+# no year exists where they'd win independently. That query doesn't
+# expose a secondary entry's own rank, only its name -- simplex here
+# is an unverified placeholder, same caveat as every other stub. No
+# text pulled at all yet.
+id: ss-felix-simplicius-faustinus-and-beatrix
+name: "Ss. Felix, Simplicius, Faustinus, and Beatrix, Martyrs"
+nameLa: "Sancti Felix, Simplicius, Faustinus et Beatrix, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-felix-simplicius-faustinus-and-beatrix"
+# No [Ant 1] of its own in the source (07-29cc.txt) -- [Rule]/[Rank] point to
+# Commune/C3a instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-gervase-and-protase.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-19, no Sunday collision) -- winner outright, Simplex. Own
+# proper collect, no unique antiphon of their own.
+id: ss-gervase-and-protase
+name: "Ss. Gervase and Protase, Martyrs"
+nameLa: "Sancti Gervasius et Protasius, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-gervase-and-protase"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-19o.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-hippolytus-and-cassian.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/08-13.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-hippolytus-and-cassian
+name: "Ss. Hippolytus and Cassian, Martyrs"
+nameLa: "Sancti Hippolytus et Cassianus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-hippolytus-and-cassian"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-john-and-paul.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-26, no Sunday collision) -- winner outright, Semiduplex.
+# Roman martyrs John and Paul -- not St. John the Baptist/Evangelist or
+# St. Paul the Apostle, despite the shared names. Own proper collect and
+# antiphon.
+id: ss-john-and-paul
+name: "Ss. John and Paul, Martyrs"
+nameLa: "Sancti Joannes et Paulus, Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-john-and-paul"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-26.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-machabees.yml

@@ -0,0 +1,15 @@
+# Genuinely unwinnable stub (verified 2026-08-01, 2029-08-01) -- always
+# commemorated under St. Peter's Chains (see st-peter-ad-vincula.yml),
+# never wins outright; both are fixed, non-movable dates, so this isn't
+# an artifact of the tested year. rank/propers unverified placeholders.
+id: ss-machabees
+name: "Ss. Machabees, Martyrs"
+nameLa: "Sancti Machabæi, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-machabees"
+# No [Ant 1] of its own in the source (08-01r.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-marcellinus-peter-and-erasmus.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2026-06-02, a year this date isn't a Saturday, clear of the generic
+# "Sanctae Mariae Sabbato" votive that otherwise wins on Saturdays) --
+# winner outright, Simplex. Own proper collect, no unique antiphon of
+# their own.
+id: ss-marcellinus-peter-and-erasmus
+name: "Ss. Marcellinus, Peter, and Erasmus, Bishop, Martyrs"
+nameLa: "Sancti Marcellinus et Petrus, et Sanctus Erasmus, Episcopus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-marcellinus-peter-and-erasmus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-02.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-marius-martha-audifax-and-abachum.yml

@@ -0,0 +1,18 @@
+# Secondary commemoration on 01-19 (loses the day to St. Paul the First Hermit), pulled from
+# Divinum Officium's kalendar headline (Monastic Tridentinum 1617, 2029-01-19).
+# That query doesn't expose a secondary entry's rank, only its name -- simplex
+# here is an unverified placeholder (the safest default, not a real reading),
+# expected to need hand correction like the rest of this first-pass pull. No
+# text pulled at all yet, matching the "first pass, detect but don't fully
+# author" scope for merely-commemorated saints.
+id: ss-marius-martha-audifax-and-abachum
+name: "Ss. Marius, Martha, Audifax, and Abachum, Martyrs"
+nameLa: "Sancti Marius, Martha, Audifax et Abachum, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-marius-martha-audifax-and-abachum"
+# No [Ant 1] of its own in the source (01-19.txt) -- [Rule]/[Rank] point to
+# Commune/C3a instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-mark-and-marcellian.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-18, no Sunday collision) -- winner outright, Simplex. Own
+# proper collect, no unique antiphon of their own.
+id: ss-mark-and-marcellian
+name: "Ss. Mark and Marcellian, Martyrs"
+nameLa: "Sancti Marcus et Marcellianus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-mark-and-marcellian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-18t.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-maurice-and-companions.yml

@@ -0,0 +1,22 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-09-22) -- winner outright, Simplex, alone. No
+# unique collect: the raw file at this MM-DD slot (Sancti/09-22.txt) is
+# actually St. Thomas of Villanova's, a Bishop (a later, post-1617
+# addition to this filename slot, canonized 1658) -- a live prayTertia
+# query for the Monastic 1617 track returns no Oratio at all, confirming
+# propers: null is correct, same file-naming caution as several of
+# August's entries.
+id: ss-maurice-and-companions
+name: "Ss. Maurice and Companions, Martyrs"
+nameLa: "Sanctus Mauritius et Socii, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-maurice-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-09-22, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-22o.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nabor-and-felix.yml

@@ -0,0 +1,20 @@
+# Secondary commemoration on 07-12, pulled from Divinum Officium's
+# kalendar headline (Monastic Tridentinum 1617) -- loses the day to
+# St. John Gualbert (also a fixed July 12 saint, not movable -- see st-john-gualbert.yml), so unlike most other stubs
+# in this set, this isn't just an artifact of the specific year
+# checked: their competing observance is likewise fixed-date, meaning
+# no year exists where they'd win independently. That query doesn't
+# expose a secondary entry's own rank, only its name -- simplex here
+# is an unverified placeholder, same caveat as every other stub. No
+# text pulled at all yet.
+id: ss-nabor-and-felix
+name: "Ss. Nabor and Felix, Martyrs"
+nameLa: "Sancti Nabor et Felix, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-nabor-and-felix"
+# No [Ant 1] of its own in the source (07-12o.txt) -- [Rule]/[Rank] point to
+# Commune/C3a-1 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nazarius-celsus-victor-and-innocent.yml

@@ -0,0 +1,17 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2028-07-28, no Sunday collision) -- winner outright, Semiduplex.
+# Four saints sharing one feast day, including one (Innocent I) who was a
+# confessor rather than a martyr -- "common-of-several-martyrs" is a loose
+# fit but the closest existing category. Own proper collect, no unique
+# antiphon of their own.
+id: ss-nazarius-celsus-victor-and-innocent
+name: "Ss. Nazarius and Celsus, Martyrs, St. Victor I, Pope and Martyr, and St. Innocent I, Pope and Confessor"
+nameLa: "Sancti Nazarius et Celsus, Martyres, Sanctus Victor I, Papa et Martyr, et Sanctus Innocentius I, Papa et Confessor"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-nazarius-celsus-victor-and-innocent"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-28.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nereus-achilleus-domitilla-and-pancras.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-05-12, no Sunday collision) -- winner outright, Semiduplex.
+# Own proper collect, no unique antiphon of their own.
+id: ss-nereus-achilleus-domitilla-and-pancras
+name: "Ss. Nereus, Achilleus, Domitilla, and Pancras, Martyrs"
+nameLa: "Sancti Nereus, Achilleus et Pancratius, et Sancta Domitilla, Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-nereus-achilleus-domitilla-and-pancras"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (05-12.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-perpetua-and-felicity.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/03-06.txt` -- "vide C7b;;Duplex;;3;;".
+# No [Oratio]/[Ant 1] of her own -- both fall back to Common of several
+# women Martyrs (C7b), newly authored here (collect-c7b.yml,
+# benedictus-antiphon-common-of-several-women-martyrs.yml).
+id: ss-perpetua-and-felicity
+name: "Ss. Perpetua and Felicity, Martyrs"
+nameLa: "Sanctæ Perpetua et Felicitas, Martyres"
+rank: duplex
+common: common-of-several-women-martyrs
+propers: null
+collectCommon: collect-c7b
+collectName:
+  la: ["Perpétuæ", "Felicitátis"]
+  en: ["Perpetua", "Felicitas"]
+benedictusCommon: common-of-several-women-martyrs

src/data/calendar/saints/ss-peter-and-paul.yml

@@ -0,0 +1,12 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2035-06-29, no Sunday collision) -- winner outright, Duplex I.
+# classis. Own proper collect; own [Ant 1] is a deliberate cross-reference
+# to the Chair-of-Peter-at-Antioch antiphon ("Tu es pastor ovium") --
+# duplicated here rather than shared, see ss-peter-and-paul-antiphon.yml.
+id: ss-peter-and-paul
+name: "Ss. Peter and Paul, Apostles"
+nameLa: "Sancti Petrus et Paulus, Apostoli"
+rank: duplex-1-classis
+common: common-of-an-apostle
+propers: "ss-peter-and-paul"
+minorHoursCommon: common-of-st-peter

src/data/calendar/saints/ss-philip-and-james.yml

@@ -0,0 +1,10 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2029-05-01, no Sunday collision) -- winner outright, Duplex II.
+# classis. Own proper collect and antiphon.
+id: ss-philip-and-james
+name: "Ss. Philip and James, Apostles"
+nameLa: "Sancti Philippus et Jacobus, Apostoli"
+rank: duplex-2-classis
+common: common-of-an-apostle
+propers: "ss-philip-and-james"
+minorHoursCommon: common-of-apostles

src/data/calendar/saints/ss-placid-and-companions.yml

@@ -0,0 +1,22 @@
+# A monastic-calendar-specific addition: absent from the base Tridentine
+# table (1570.txt) entirely, added by the monastic-specific delta table
+# (M1617.txt) -- fittingly, since St. Placid is St. Benedict's own famous
+# disciple. Verified live (Monastic Tridentinum 1617, 2026-10-05 and
+# again 2032-10-05) -- winner outright, Duplex II. classis, alone; the
+# highest-ranked monastic-only addition found in this pull so far. No
+# unique collect: the raw file's [Oratio] is a plain cross-reference to a
+# generic Common-of-several-martyrs formula (@Commune/C3a), not unique
+# text, so propers: null is correct (Common-of-Saints only), same
+# treatment as any other saint whose own file just points at the Common.
+id: ss-placid-and-companions
+name: "Ss. Placid and Companions, Martyrs"
+nameLa: "Sanctus Placidus et Socii, Martyres"
+rank: duplex-2-classis
+common: common-of-several-martyrs
+propers: null
+collectCommon: collect-c3a
+collectName:
+  la: ["Plácidi", "Sociórum ejus"]
+  en: ["Placidus", "his companions"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-primus-and-felicianus.yml

@@ -0,0 +1,16 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2027-06-09, clear of both the "Sanctae Mariae Sabbato" Saturday
+# votive and the movable Corpus Christi Octave that otherwise overshadow
+# this date) -- winner outright, Simplex. Own proper collect, no unique
+# antiphon of their own.
+id: ss-primus-and-felicianus
+name: "Ss. Primus and Felicianus, Martyrs"
+nameLa: "Sancti Primus et Felicianus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-primus-and-felicianus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-09.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-protus-and-hyacinth.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-11.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-protus-and-hyacinth
+name: "Ss. Protus and Hyacinth, Martyrs"
+nameLa: "Sancti Protus et Hyacinthus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-protus-and-hyacinth"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-seven-brothers-rufina-and-secunda.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2028-07-10, no Sunday collision) -- winner outright, Semiduplex.
+# Own proper collect, no unique antiphon of their own.
+id: ss-seven-brothers-rufina-and-secunda
+name: "Ss. Seven Brothers, Martyrs, and Ss. Rufina and Secunda, Virgins and Martyrs"
+nameLa: "Septem Fratres, Martyres, et Sanctæ Rufina et Secunda, Virgines et Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: "ss-seven-brothers-rufina-and-secunda"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-10.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-seven-founders-of-the-servite-order.yml

@@ -0,0 +1,12 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/02-12.txt` -- "vide C5c;;Duplex;;3;;".
+# Own proper [Oratio]/[Ant 1]/Nocturn 2 vita; Nocturn 3 is a direct
+# `@Commune/C1:LectioN` cross-reference to the Common of Apostles' own
+# Gospel-and-homily (Matt 19:27-29, "we have forsaken all"), fitting for
+# a group of founders, not the saints' own text.
+id: ss-seven-founders-of-the-servite-order
+name: "Ss. Seven Holy Founders of the Order of the Servants of the Blessed Virgin Mary"
+nameLa: "Septem Sancti Fundatores Ordinis Servorum Beatæ Mariæ Virginis"
+rank: duplex
+common: common-of-several-confessors
+propers: "ss-seven-founders-of-the-servite-order"

src/data/calendar/saints/ss-simon-and-jude.yml

@@ -0,0 +1,10 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-10-28) -- winner outright, Duplex II. classis,
+# alone. Own proper collect, no unique antiphon of their own.
+id: ss-simon-and-jude
+name: "Ss. Simon and Jude, Apostles"
+nameLa: "Sancti Simon et Judas, Apostoli"
+rank: duplex-2-classis
+common: common-of-an-apostle
+propers: "ss-simon-and-jude"
+minorHoursCommon: common-of-apostles

src/data/calendar/saints/ss-soter-and-caius.yml

@@ -0,0 +1,18 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2042-04-22, no Sunday collision) -- winner outright, Semiduplex.
+# The source shows an alternate [Officium] block tagged "(rubrica 196)"
+# -- a later rubric renumbering, not this app's target era, so the
+# untagged/default block is used, same convention as every other saint in
+# this set. No unique Oratio/Antiphon -- Common of Several Martyrs only.
+id: ss-soter-and-caius
+name: "Ss. Soter and Caius, Popes and Martyrs"
+nameLa: "Sancti Soter et Cajus, Papæ et Martyres"
+rank: semiduplex
+common: common-of-several-martyrs
+propers: null
+collectCommon: collect-c3b
+collectName:
+  la: ["Sotérem", "Cajum"]
+  en: ["Soter", "Caius"]
+minorHoursCommon: common-of-pope-martyrs
+benedictusCommon: common-of-pope-martyrs

src/data/calendar/saints/ss-symphorosa-and-seven-sons.yml

@@ -0,0 +1,14 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2028-07-18, no Sunday collision) -- winner outright, Simplex. Own
+# proper collect, no unique antiphon of their own.
+id: ss-symphorosa-and-seven-sons
+name: "Ss. Symphorosa and Her Seven Sons, Martyrs"
+nameLa: "Sancta Symphorosa et Septem Filii Ejus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-symphorosa-and-seven-sons"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-18o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tiburtius-and-susanna.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/08-11.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-tiburtius-and-susanna
+name: "Ss. Tiburtius and Susanna, Martyrs"
+nameLa: "Sanctus Tiburtius et Sancta Susanna, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-tiburtius-and-susanna"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tiburtius-valerian-and-maximus.yml

@@ -0,0 +1,15 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
+# check (2043-04-14, a year St. Francis of Paola doesn't transfer here) --
+# winner outright, Simplex. Own proper collect, no unique antiphon of
+# their own.
+id: ss-tiburtius-valerian-and-maximus
+name: "Ss. Tiburtius, Valerian, and Maximus, Martyrs"
+nameLa: "Sancti Tiburtius, Valerianus et Maximus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-tiburtius-valerian-and-maximus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (04-14t.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tryphon-and-companions.yml

@@ -0,0 +1,20 @@
+# Verified against Divinum Officium (Monastic Tridentinum 1617), live
+# kalendar check (2025-11-10) -- winner outright, Simplex, alone. No
+# unique collect: the raw file at this MM-DD slot (Sancti/11-10.txt) is
+# actually St. Andrew Avellino's (a later, 1712 canonization) -- a live
+# prayTertia query for the Monastic 1617 track returns no Oratio at all,
+# confirming propers: null is correct.
+id: ss-tryphon-and-companions
+name: "Ss. Tryphon, Respicius, and Nympha, Martyrs"
+nameLa: "Sancti Tryphon, Respicius et Nympha, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-tryphon-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-11-10, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (11-10o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-twelve-brothers.yml

@@ -0,0 +1,15 @@
+# Genuinely unwinnable stub (verified 2025-09-01, 2026-09-01) -- always
+# commemorated under St. Giles (see st-giles.yml), never wins outright;
+# both are fixed, non-movable dates, so this isn't an artifact of the
+# tested year. rank/propers unverified placeholders.
+id: ss-twelve-brothers
+name: "Ss. Twelve Brothers, Martyrs"
+nameLa: "Duodecim Fratres, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-twelve-brothers"
+# No [Ant 1] of its own in the source (09-01cc.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs