Close latent Matins Gospel-homily dedup gap

When a Gospel+homily pair is folded into one pool entry, the homily's
own text was never registered in seenReadingText -- only the Gospel
pericope's text was. Not live for any date today, but the same
structural mistake already fixed once for two ids pooling the same
Gregory the Great excerpt: a later pooled id whose solo lesson happens
to share a homily's exact text would render as a visible duplicate.

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

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

@@ -19,11 +19,11 @@ export interface CollisionResult {
 }
 
 function asWinner(candidate: SanctoralIdentity): DayWinner {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  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, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 /**

src/calendar/commemorations.ts

@@ -38,6 +38,34 @@ 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. */
@@ -55,11 +83,11 @@ export interface OccurrenceResult {
 }
 
 function sanctoralCommemoration(candidate: SanctoralIdentity): Commemoration {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  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, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 /**
@@ -115,11 +143,22 @@ export function decideOccurrence(
       };
 
     case 'privileged-feria-major':
-      // Ash Wednesday, Holy Week, the Easter Octave, the Vigil of
-      // Christmas — never displaced, same as privileged-sunday.
-      if (isAtLeast(sanctoral.rank, 'duplex-majus')) {
-        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
-      }
+      // 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: [],
@@ -137,8 +176,22 @@ export function decideOccurrence(
         return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
       }
       // Semiduplex or Vigil: no room here at all, in either direction —
-      // better to preserve the feast whole on another day than downgrade
-      // it to a bare commemoration.
+      // 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: [],
@@ -146,13 +199,22 @@ export function decideOccurrence(
       };
 
     case 'privileged-sunday':
-      if (isAtLeast(sanctoral.rank, 'duplex-majus')) {
-        // Never displaced, but a sufficiently high feast still gets a nod.
-        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
-      }
-      // Below duplex-majus, a privileged Sunday wants nothing at all —
-      // not even the bare commemoration an ordinary Sunday would allow a
-      // Simplex — so everything here transfers.
+      // 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: [],

src/calendar/day-label.ts

@@ -9,14 +9,79 @@
 // 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.
-import type { Commemoration, FeastClass, LiturgicalDay } from './types';
+//
+// 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 { resolveActiveOctave, type ActiveOctave } from './octaves';
+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);
 }
@@ -38,6 +103,56 @@ function ordinal(n: number): string {
   }
 }
 
+// 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;
@@ -45,48 +160,80 @@ interface OrdinalSeason {
    * 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. */
-  anchorName: string;
-  /** Used in "the Nth Sunday/week {preposition} {ordinalName}". */
-  ordinalName: string;
+  /** 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: 'Advent',
-    ordinalName: 'Advent',
+    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: 'Epiphany',
-    ordinalName: 'Epiphany',
+    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: 'Ash Wednesday',
-    ordinalName: 'Lent',
+    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: 'Easter',
-    ordinalName: 'Easter',
+    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: 'Trinity Sunday',
-    ordinalName: 'Trinity',
+    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',
   },
 };
 
@@ -98,14 +245,16 @@ const ORDINAL_SEASONS: Partial<Record<string, OrdinalSeason>> = {
  * 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): string | undefined {
+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 config.anchorName;
+    return withRank && config.anchorRank
+      ? bi(`${config.anchorName.en} (${formatRank(config.anchorRank).en})`, `${config.anchorName.la} (${formatRank(config.anchorRank).la})`)
+      : config.anchorName;
   }
   return undefined;
 }
@@ -138,47 +287,57 @@ const FIXED_LAST_SUNDAY_ORDINAL = 23;
  *     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.
+ * their own native season. Trinitytide isn't in the weekday-drop set, so
+ * both languages keep their weekday prefix here.
  */
-function trinitytideOverrideLabel(day: LiturgicalDay): string | undefined {
+function trinitytideOverrideLabel(day: LiturgicalDay): Bi | undefined {
   if (day.season !== 'trinitytide') {
     return undefined;
   }
   const id = resolveTemporalId(day.date);
-  const weekdayName = capitalize(day.weekday);
+  const weekdayName = weekdayLabel(day);
 
   const epiphanyMatch = id.match(/^post-epiphany-(\d)$/);
   if (epiphanyMatch) {
     const n = Number(epiphanyMatch[1]);
     return day.weekday === 'sunday'
-      ? `The ${ordinal(n)} Sunday after Epiphany`
-      : `${weekdayName} in the ${ordinal(n)} week after Epiphany`;
+      ? 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'
-      ? `The ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} Sunday after Trinity`
-      : `${weekdayName} in the ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} week after Trinity`;
+      ? 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): string {
+function temporalLabel(day: LiturgicalDay): Bi {
   const trinitytideOverride = trinitytideOverrideLabel(day);
   if (trinitytideOverride) {
     return trinitytideOverride;
   }
 
-  const weekdayName = capitalize(day.weekday);
+  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.
-    return `${weekdayName} in ${capitalize(day.season.replace(/-/g, ' '))}`;
+    // 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));
@@ -190,54 +349,182 @@ function temporalLabel(day: LiturgicalDay): string {
 
   const firstNumberedSunday = config.includeAnchorWeek ? anchor : firstSundayStrictlyAfter(anchor);
   if (day.date < firstNumberedSunday) {
-    return `${weekdayName} after ${config.anchorName}`;
+    // 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 `The ${ordinalStr} Sunday ${config.preposition} ${config.ordinalName}`;
+    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}`);
   }
-  return `${weekdayName} in the ${ordinalStr} week ${config.preposition} ${config.ordinalName}`;
+  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" — the real DO title an
- * octave day carries on its own (e.g. "Tertia die infra Octavam S.
- * Laurentii Martyris") when nothing else has displaced it. Day 1 shouldn't
- * normally reach this (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). */
-function octaveLabel(octave: ActiveOctave): string {
-  return `${ordinal(octave.dayNumber)} Day within the Octave of ${octave.name}`;
+/** "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}`);
 }
 
-/** Every `kind: 'octave'` commemoration on `day` other than `excludeId` —
- * an octave already serving as the day's own headline (a sanctoral
- * winner sharing an octave's id, or the octave `resolveActiveOctave`
- * itself picked as primary below) would be redundant to list again.
- * Plain names, not `octaveLabel`'s "Nth Day within the Octave of ..."
- * phrasing — that fuller phrasing is reserved for an octave that's
- * actually the day's own primary identity, not a secondary mention
- * alongside it (same plain-name convention `commemoratedSaint` already
- * uses below). Real gap this closes: a *second*, non-winning active
- * octave (e.g. the Assumption's own day 3, alongside St. Lawrence's
- * winning closing day) was previously dropped from the label entirely,
- * regardless of which branch below actually renders the primary name. */
-function otherActiveOctaveNames(day: LiturgicalDay, excludeId: string | undefined): string[] {
-  return day.commemorations
-    .filter((c): c is Extract<Commemoration, { kind: 'octave' }> => c.kind === 'octave' && c.id !== excludeId)
-    .map((c) => c.name);
+function octaveLabel(octave: ActiveOctave): Bi {
+  const core = octaveCoreName(octave);
+  const rank = formatRank(octave.wins);
+  return bi(`${core.en} (${rank.en})`, `${core.la} (${rank.la})`);
 }
 
-const RANK_LABELS: Record<FeastClass, string> = {
-  simplex: 'Simplex',
-  vigil: 'Vigil',
-  semiduplex: 'Semiduplex',
-  duplex: 'Duplex',
-  'duplex-majus': 'Duplex Majus',
-  'duplex-2-classis': 'Duplex II Class',
-  'duplex-1-classis': 'Duplex I Class',
+/** 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 —
@@ -245,84 +532,189 @@ const RANK_LABELS: Record<FeastClass, string> = {
  * 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): string {
+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'),
+};
+
 /**
- * The full "day being celebrated" label: a feast name when
- * calendar/commemorations.ts says the day has one, combined with (or
- * replaced by) the ordinal temporal label depending on whether the feast
- * won outright or was merely commemorated. See the plan discussion this
- * came from for the three cases.
+ * 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 getDayLabel(day: LiturgicalDay): string {
+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') {
-    // A sanctoral winner can still share the day with an active octave
-    // it didn't come from (e.g. winning a tie-break against one octave
-    // while a second, unrelated octave is also active) — append those,
-    // same "winner is primary, commemorations ride along" shape every
-    // other branch below already uses. Gated on `ordinary-feria`, same
-    // as the octave-headline branch further down: a day with real
-    // standing of its own (e.g. Trinity Sunday, which is incidentally
-    // also day 8 of Pentecost's own octave) never mentions an octave —
-    // same "nobody calls it that" convention anchorDayName's own doc
-    // comment already established for the anchor-day case.
-    const otherOctaves = day.temporalCategory === 'ordinary-feria' ? otherActiveOctaveNames(day, undefined) : [];
-    const winnerName = `${day.winner.name} (${formatRank(day.winner.rank)})`;
-    return [winnerName, ...otherOctaves].join(' — ');
+    // 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 to the ordinal label as before.
+  // temporal-feasts.ts) and fall through further down.
   const namedFeast = getTemporalFeastRecord(day.winner.id);
   if (namedFeast) {
-    return namedFeast.name;
+    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]));
   }
 
-  const commemoratedSaint = day.commemorations.find((c) => c.kind === '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) {
-    return commemoratedSaint ? `${commemoratedSaint.name} — ${anchorName}` : 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`), same gate as hours/resolve-common.ts's
+  // 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 — 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 (otherActiveOctaveNames), 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) : undefined;
+  // 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);
-    const rest = [...otherActiveOctaveNames(day, activeOctave.id), ...(commemoratedSaint ? [commemoratedSaint.name] : [])];
-    return [primary, ...rest].join(' — ');
+    return withTransferNote(day, joinBi([primary, ...octaves, ...sanctoral]));
   }
 
-  const temporal = temporalLabel(day);
-  return commemoratedSaint ? `${commemoratedSaint.name} — ${temporal}` : temporal;
+  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/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

@@ -15,6 +15,9 @@ 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;
@@ -75,9 +78,53 @@ export interface SaintRecord {
    * 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[]> };
@@ -94,6 +141,7 @@ for (const mod of Object.values(saintModules)) {
 export interface SanctoralCandidate {
   id: string;
   name: string;
+  nameLa?: string;
   rank: FeastClass;
 }
 
@@ -113,6 +161,6 @@ export function getSanctoralCandidatesFor(isoDate: string): SanctoralCandidate[]
     if (!saint) {
       throw new Error(`sanctoral-calendar.yml references unknown saint id '${id}'`);
     }
-    return { id: saint.id, name: saint.name, rank: saint.rank };
+    return { id: saint.id, name: saint.name, nameLa: saint.nameLa, rank: saint.rank };
   });
 }

src/calendar/index.ts

@@ -1,20 +1,25 @@
-import type { Commemoration, DayWinner, LiturgicalDay, SanctoralIdentity, TemporalCategory } from './types';
+import type { Commemoration, DayWinner, FeastClass, LiturgicalDay, SanctoralIdentity, TemporalCategory } from './types';
 import { weekdayOf } from './weekday';
-import { resolveSeason, resolveTemporalCategory, sundayOnOrBefore } from './temporal';
+import { resolveSeason, resolveTemporalCategory, easterOffsetOf } from './temporal';
 import { resolveTemporalId } from './temporal-id';
 import { getSanctoralCandidatesFor } from './feasts';
-import { decideOccurrence, compareFeastClass, type OccurrenceResult } from './commemorations';
+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.
+ * 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);
@@ -35,7 +40,12 @@ function resolveNativeOccurrence(isoDate: string): { temporalCategory: TemporalC
     const collision = resolveCollision(candidate, topCandidate);
     clashCommemorations.push(...collision.commemorations);
     if (collision.winner.kind === 'sanctoral') {
-      topCandidate = { id: collision.winner.id, name: collision.winner.name, rank: collision.winner.rank };
+      topCandidate = {
+        id: collision.winner.id,
+        name: collision.winner.name,
+        nameLa: collision.winner.nameLa,
+        rank: collision.winner.rank,
+      };
     }
   }
 
@@ -49,17 +59,34 @@ function applyIncomingTransfer(
   temporalCategory: TemporalCategory,
   winner: DayWinner,
   commemorations: Commemoration[],
+  fromDate: string,
 ): DayWinner {
   if (temporalCategory === 'privileged-feria-major') {
-    // Deferred: a transfer landing on one of these (the concrete case is
-    // Holy Week, right after Palm Sunday) needs its own Easter-date-keyed
-    // lookup table, the same way the reference engine handles it — not
-    // modeled yet. The transfer is simply not delivered here rather than
-    // guessed at. The lesser privileged-feria tier doesn't need this —
-    // ordinary collision/transfer logic is fine there, same as any
-    // ordinary-sunday landing.
+    // 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
@@ -67,15 +94,84 @@ function applyIncomingTransfer(
     // 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(...decided.commemorations);
-    // If the candidate fails here too (decided.transfer set), that's a
-    // transfer chain — not modeled, same "not delivered rather than
-    // guessed at" stance as the privileged-feria-major case above.
-    return decided.winner;
+    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(...collision.commemorations);
-  return collision.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 };
 }
 
 /**
@@ -92,22 +188,50 @@ export function resolveDay(isoDate: string): LiturgicalDay {
   let winner = result.winner;
   const commemorations = [...result.commemorations];
 
-  const yesterday = resolveNativeOccurrence(addDays(isoDate, -1));
-  if (yesterday.result.transfer?.direction === 'forward') {
-    winner = applyIncomingTransfer(yesterday.result.transfer.candidate, temporalCategory, winner, 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 tomorrow = resolveNativeOccurrence(addDays(isoDate, 1));
+  const tomorrowIso = addDays(isoDate, 1);
+  const tomorrow = resolveNativeOccurrence(tomorrowIso);
   if (tomorrow.result.transfer?.direction === 'backward') {
-    winner = applyIncomingTransfer(tomorrow.result.transfer.candidate, temporalCategory, winner, commemorations);
+    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 = applyChristTheKing(isoDate, winner, commemorations);
   winner = applyChristmasOctaveSunday(isoDate, weekday, winner, commemorations);
+  winner = applyMovableFeasts(isoDate, winner, commemorations);
   applyEpiphany6Commemoration(isoDate, commemorations);
+  applyAdventFourVigilCommemoration(isoDate, weekday, commemorations);
 
-  return { date: isoDate, weekday, season, temporalCategory, winner, 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 };
 }
 
 /**
@@ -138,34 +262,30 @@ function applyEpiphany6Commemoration(isoDate: string, commemorations: Commemorat
   commemorations.push({ kind: 'temporal', id: 'post-epiphany-6' });
 }
 
-/** The Sunday on or before Oct 31 — always lands in October since Oct 31
- * is at most 6 days after the month's last Sunday. */
-function lastSundayOfOctober(year: number): string {
-  return sundayOnOrBefore(`${year}-10-31`);
-}
-
 /**
- * Per direct instruction: the last Sunday of October is always Christ the
- * King, full stop — unlike every other layer in this file, nothing here
- * loses gracefully or gets a rank check; whatever was winning (a plain
- * numbered Sunday after Pentecost in every ordinary year, but modeled
- * generally in case a high-ranked sanctoral candidate is ever assigned to
- * that date too) is demoted straight to a commemoration. Confirmed live
- * (see data/calendar/temporal-feasts/christ-the-king.yml): Duplex I.
- * classis, well above anything that could contest it under this
- * project's own calendar.
+ * 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 applyChristTheKing(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
-  const year = Number(isoDate.slice(0, 4));
-  if (isoDate !== lastSundayOfOctober(year)) {
-    return winner;
+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' });
   }
-  if (winner.kind === 'temporal') {
-    commemorations.push({ kind: 'temporal', id: winner.id });
-  } else {
-    commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, rank: winner.rank });
-  }
-  return { kind: 'temporal', id: 'christ-the-king' };
 }
 
 /**
@@ -197,6 +317,23 @@ function applyChristmasOctaveSunday(
   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' };
   }
 
@@ -220,7 +357,7 @@ function applyChristmasOctaveSunday(
       if (idx !== -1) {
         commemorations.splice(idx, 1);
       }
-      return { kind: 'sanctoral', id: displaced.id, name: displaced.name, rank: displaced.rank };
+      return { kind: 'sanctoral', id: displaced.id, name: displaced.name, nameLa: displaced.nameLa, rank: displaced.rank };
     }
   }
 
@@ -273,7 +410,7 @@ function applyMarianSaturday(
   if (winner.rank !== 'simplex') {
     return winner;
   }
-  commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, rank: winner.rank });
+  commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
   return MARIAN_SATURDAY;
 }
 
@@ -326,7 +463,7 @@ function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commem
     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, rank: winner.rank });
+        commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
         resolvedWinner = { kind: 'temporal', id: resolveTemporalId(isoDate) };
       }
     }
@@ -339,7 +476,7 @@ function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commem
     // 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 });
+      commemorations.push({ kind: 'octave', id: octave.id, name: octave.name, nameLa: octave.nameLa });
     }
   }
 
@@ -356,10 +493,11 @@ export function isSundayOrFeast(day: LiturgicalDay): boolean {
   return day.weekday === 'sunday' || day.winner.kind === 'sanctoral';
 }
 
-export { compareFeastClass, isAtLeast, decideOccurrence } from './commemorations';
+export { compareFeastClass, isAtLeast, decideOccurrence, minimumOutrightWinningRank } from './commemorations';
 export { resolveCollision } from './collision';
 export { resolveTemporalId } from './temporal-id';
-export { activeOctavesFor, strictestThreshold, resolveActiveOctave } from './octaves';
+export { monthWeekId } from './month-week-id';
+export { activeOctavesFor, strictestThreshold, resolveActiveOctave, octaveGoverningPrivilegedDay } from './octaves';
 export type { ActiveOctave } from './octaves';
 export type {
   LiturgicalDay,

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

@@ -8,15 +8,18 @@
 // 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, OctaveConfig } from './types';
+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 } from './commemorations';
+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).
@@ -49,6 +52,7 @@ function considerCandidate(
   startDate: string,
   id: string,
   name: string,
+  nameLa: string | undefined,
   octave: OctaveConfig | undefined,
 ): void {
   if (!octave?.enabled || seen.has(id)) {
@@ -63,7 +67,7 @@ function considerCandidate(
   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, wins, dayNumber, isClosingDay });
+  active.push({ id, name, nameLa, wins, dayNumber, isClosingDay });
 }
 
 /** Every octave (sanctoral or temporal) whose window covers `isoDate`,
@@ -80,14 +84,14 @@ export function activeOctavesFor(isoDate: string): ActiveOctave[] {
     for (const candidate of getSanctoralCandidatesFor(candidateDate)) {
       const record = getSaintRecord(candidate.id);
       if (record) {
-        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.octave);
+        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.octave);
+        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.nameLa, record.octave);
       }
     }
   }
@@ -115,11 +119,19 @@ export function strictestThreshold(octaves: ActiveOctave[]): FeastClass {
  *
  * - Highest effective rank (`wins`, already elevated on either octave's
  *   own closing day) wins outright.
- * - Tied rank: 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.
+ * - 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
@@ -131,6 +143,46 @@ 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
@@ -147,6 +199,9 @@ export function pickWinningOctave(active: ActiveOctave[]): ActiveOctave | undefi
     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

@@ -5,13 +5,58 @@
 // 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 { OctaveConfig } from './types';
+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 }>(
@@ -28,13 +73,29 @@ export function getTemporalFeastRecord(id: string): TemporalFeastRecord | undefi
   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][] = [[49, 'pentecost-sunday']];
+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[] {

src/calendar/temporal-id.ts

@@ -78,6 +78,24 @@ 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;

src/calendar/temporal.ts

@@ -42,12 +42,21 @@ function fixedDateFor(id: string): { month: number; day: number } {
 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 {
-  const nov30 = `${year}-11-30`;
-  const dow = dayOfWeek(nov30);
-  const delta = dow <= 3 ? -dow : 7 - dow;
-  return addDays(nov30, delta);
+  return nearestSunday(`${year}-11-30`);
 }
 
 /**
@@ -68,6 +77,15 @@ export function firstSundayStrictlyAfter(isoDate: string): string {
   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) {
@@ -126,6 +144,53 @@ export function easterOffsetOf(isoDate: string): number {
   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
@@ -137,12 +202,33 @@ export function easterOffsetOf(isoDate: string): number {
  * 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.
+ * 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;
   }
 
@@ -151,6 +237,15 @@ export function resolveTemporalCategory(isoDate: string, season: Season, weekday
     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)];

src/calendar/types.ts

@@ -76,12 +76,16 @@ export type FeastClass =
 // 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 at all, confirmed by
-// checking St. Mark, Duplex II. classis, merely commemorated rather than
-// winning within the Easter Octave). 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.
+// (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
@@ -103,6 +107,11 @@ export type TemporalCategory =
 export interface SanctoralIdentity {
   id: string;
   name: string;
+  /** 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;
 }
 
@@ -156,6 +165,12 @@ export type DayWinner =
       // 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);
 
 /**
@@ -168,8 +183,27 @@ export type DayWinner =
  */
 export type Commemoration =
   | { kind: 'temporal'; id: string }
-  | ({ kind: 'sanctoral' } & SanctoralIdentity)
-  | { kind: 'octave'; id: string; name: 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" */
@@ -183,4 +217,20 @@ export interface LiturgicalDay {
   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

@@ -12,7 +12,9 @@ import type { Commemoration, DayWinner, LiturgicalDay } from './types';
 import { resolveDay } from './index';
 import { addDays } from './date-math';
 import { easterOffsetOf } from './temporal';
-import { isAtLeast } from './commemorations';
+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
@@ -39,53 +41,95 @@ function hasFirstVespers(day: LiturgicalDay): boolean {
   }
   // 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 — so Semiduplex clears
-  // this bar, not duplex-majus as originally guessed (unverified at the
-  // time). Matches keepsOwnSecondVespers's own privileged-feria-minor
-  // threshold just below, which uses the same cutoff.
-  return day.winner.kind === 'sanctoral' && isAtLeast(day.winner.rank, 'semiduplex');
+  // 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? */
+/** 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 {
-  if (
+  return (
     day.weekday === 'sunday' ||
     day.temporalCategory === 'privileged-feria-minor' ||
     day.temporalCategory === 'privileged-feria' ||
     day.temporalCategory === 'privileged-feria-major' ||
     isMajorFixedFeastOfTheLord(day.date)
-  ) {
-    return true;
-  }
-  return day.winner.kind === 'sanctoral' && isAtLeast(day.winner.rank, 'duplex-2-classis');
+  );
 }
 
 /**
- * Whichever of today/tomorrow does *not* govern tonight's Vespers is still
- * commemorated there, unless 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 both directions, 2026-08:
+ * 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").
- *   - Jul 25 -> 26 (St. James, Duplex II. classis, kept second Vespers
- *     regardless): tomorrow (St. Anne) loses the evening but is still
- *     commemorated ("commemoratio de sequenti").
  *   - Aug 7 -> 8 (St. Donatus, Simplex, before Ss. Cyriaci/etc.): today
  *     loses the evening and is *not* commemorated ("nihil de
- *     præcedenti") — the one live case pinning down the Simplex
- *     exclusion specifically, not just inferred from the daytime rule.
- * Not yet checked against a case where the losing side is Simplex on the
- * *winning* side of the pair (i.e. today keeps its own Vespers and
- * tomorrow is the Simplex one) — inferred to behave the same way by
- * symmetry with the daytime rule, not independently live-verified.
+ *     præcedenti") — pins down the Simplex exclusion specifically for
+ *     this direction.
  */
-function commemorationOf(loser: DayWinner): Commemoration | undefined {
+function commemorationOfDisplacedPredecessor(loser: DayWinner): Commemoration | undefined {
   if (loser.kind !== 'sanctoral' || loser.rank === 'simplex') {
     return undefined;
   }
-  return { kind: 'sanctoral', id: loser.id, name: loser.name, rank: loser.rank };
+  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 {
@@ -95,16 +139,49 @@ function tagVespersFrom(tomorrow: LiturgicalDay): LiturgicalDay {
   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 commemorationOf). Not used
- * by the isMajorFixedFeastOfTheLord override below — whether Christmas/
+ * 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 = commemorationOf(today.winner);
+  const commemoration = isVigilOfTomorrow(today, tomorrow) ? undefined : commemorationOfDisplacedPredecessor(today.winner);
   if (!commemoration) {
     return tagged;
   }
@@ -119,9 +196,10 @@ function anticipated(today: LiturgicalDay, tomorrow: LiturgicalDay): LiturgicalD
  * '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 commemorationOf) — except
- * under the isMajorFixedFeastOfTheLord override just below, which doesn't
- * apply that at all yet.
+ * `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,
@@ -131,6 +209,23 @@ function anticipated(today: LiturgicalDay, tomorrow: LiturgicalDay): LiturgicalD
  * 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);
@@ -139,16 +234,25 @@ export function resolveEveningDay(isoDate: string): LiturgicalDay {
   if (isMajorFixedFeastOfTheLord(tomorrow.date)) {
     return tagVespersFrom(tomorrow);
   }
+
+  let todayWins: boolean;
   if (keepsOwnSecondVespers(today)) {
-    // Today wins outright, but tomorrow can still be commemorated here if
-    // it clears its own bar (live-verified: St. James, Duplex II.
-    // classis, keeps his own Second Vespers on Jul 25 and still
-    // commemorates St. Anne's Jul 26 — see commemorationOf).
-    const commemoration = commemorationOf(tomorrow.winner);
-    return commemoration ? { ...today, commemorations: [...today.commemorations, commemoration] } : 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 (!hasFirstVespers(tomorrow)) {
-    return today;
+
+  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/saints/all-saints-of-the-benedictine-order.yml

@@ -11,6 +11,7 @@
 # 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

@@ -5,6 +5,7 @@
 # was sourced).
 id: all-saints
 name: "All Saints"
+nameLa: "Omnes Sancti"
 rank: duplex-1-classis
 common: proper-to-all-saints
 propers: "all-saints"

src/data/calendar/saints/annunciation.yml

@@ -9,6 +9,7 @@
 # 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

@@ -6,6 +6,7 @@
 # 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

@@ -8,6 +8,7 @@
 # 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

@@ -6,9 +6,21 @@
 # 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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -8,6 +8,7 @@
 # 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"

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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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

@@ -2,14 +2,12 @@
 # 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.
-# "common-of-an-apostle" is a loose fit (he isn't one) but the closest
-# existing category to "a major male saint honored with his own high
-# feast" -- same judgment call as nativity-of-st-john-the-baptist.yml.
 # 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-an-apostle
+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

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

@@ -15,6 +15,7 @@
 # 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

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

@@ -8,6 +8,7 @@
 # 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

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

@@ -15,6 +15,7 @@
 # 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/finding-of-st-stephen.yml

@@ -13,6 +13,7 @@
 # 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"

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

@@ -13,6 +13,7 @@
 # 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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -8,6 +8,7 @@
 # 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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -10,6 +10,7 @@
 # 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

@@ -4,10 +4,17 @@
 # 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/immaculate-heart-of-mary.yml

@@ -1,13 +0,0 @@
-# Read directly from the reference engine: untagged/default [Rank]
-# block of `web/www/horas/Latin/Sancti/08-22.txt` -- "Immaculati Cordis
-# Beatæ Mariæ Virginis;;Duplex II classis;;5.1;;ex C11". Own real
-# [Oratio] and own [Ant 1]. Own Nocturn 2-3 content (Nocturn 3 is St.
-# Robert Bellarmine's own homily on the seven words of Christ on the
-# Cross, not a cross-reference). Instituted 1942 by Pius XII (see the
-# feast's own Lectio6, quoted in nocturn-readings, drawn from
-# ecclesiastical documents).
-id: immaculate-heart-of-mary
-name: "The Immaculate Heart of the Blessed Virgin Mary"
-rank: duplex-2-classis
-common: common-of-the-bvm
-propers: "immaculate-heart-of-mary"

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

@@ -8,6 +8,7 @@
 # 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

@@ -9,6 +9,7 @@
 # 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

@@ -5,10 +5,18 @@
 # 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

@@ -3,12 +3,22 @@
 # 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-
-# of-an-apostle" is a loose fit (he isn't one) but the closest existing
-# category to "a major male saint honored with his own high feast" --
-# worth reconsidering if a more precise category becomes worth adding.
+# 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

@@ -13,6 +13,7 @@
 # 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

@@ -18,6 +18,7 @@
 # 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

@@ -10,6 +10,7 @@
 # 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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -16,6 +16,7 @@
 # `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

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

@@ -19,6 +19,7 @@
 # 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

@@ -10,6 +10,7 @@
 # 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

@@ -18,6 +18,7 @@
 # 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

@@ -9,6 +9,7 @@
 # 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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -9,6 +9,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -7,6 +7,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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

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

@@ -8,6 +8,7 @@
 # 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

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -10,6 +10,7 @@
 # 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"

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

@@ -7,6 +7,7 @@
 # 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"

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

@@ -10,6 +10,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -4,6 +4,7 @@
 # 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

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

@@ -1,16 +1,22 @@
 # Verified against Divinum Officium (Monastic Tridentinum 1617), live
 # kalendar check on a clean weekday (2027-08-30, 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-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: the raw file at
-# this MM-DD slot (Sancti/08-30.txt) is actually St. Rose of Lima's (a
-# much later, 17th-century addition to this filename slot) -- a live
-# prayTertia query for the Monastic 1617 track returns no Oratio at all,
-# confirming propers: null is correct.
+# 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"

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

@@ -9,6 +9,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -4,6 +4,7 @@
 # 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"

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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -7,6 +7,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -8,6 +8,7 @@
 # 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"

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

@@ -9,6 +9,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -5,6 +5,7 @@
 # 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

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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -10,6 +10,7 @@
 # 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

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

@@ -5,6 +5,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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

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

@@ -3,6 +3,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -4,6 +4,7 @@
 # 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"

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

@@ -6,6 +6,7 @@
 # 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"

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

@@ -4,6 +4,7 @@
 # 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"

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

@@ -15,6 +15,7 @@
 # anyway (resolveOfficeWinner only ever returns the day's actual winner).
 id: ss-ursula-and-companions
 name: "Ss. Ursula and Companions, Virgins and Martyrs"
+nameLa: "Sancta Ursula et Sociæ, Virgines et Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: null

src/data/calendar/saints/ss-vincent-and-anastasius.yml

@@ -3,6 +3,7 @@
 # proper collect, no unique antiphon of their own.
 id: ss-vincent-and-anastasius
 name: "Ss. Vincent and Anastasius, Martyrs"
+nameLa: "Sancti Vincentius et Anastasius, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-vincent-and-anastasius"

src/data/calendar/saints/ss-vitus-modestus-and-crescentia.yml

@@ -3,6 +3,7 @@
 # proper collect, no unique antiphon of their own.
 id: ss-vitus-modestus-and-crescentia
 name: "Ss. Vitus, Modestus, and Crescentia, Martyrs"
+nameLa: "Sancti Vitus, Modestus et Crescentia, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-vitus-modestus-and-crescentia"

src/data/calendar/saints/st-agatha.yml

@@ -8,6 +8,7 @@
 # saint's own original authoring, hence the gap).
 id: st-agatha
 name: "St. Agatha, Virgin and Martyr"
+nameLa: "Sancta Agatha, Virgo et Martyr"
 rank: semiduplex
 common: common-of-a-virgin-martyr
 propers: "st-agatha"

src/data/calendar/saints/st-agnes-secunda.yml

@@ -7,6 +7,7 @@
 # author" scope for merely-commemorated saints.
 id: st-agnes-secunda
 name: "St. Agnes, Virgin and Martyr, Second Feast"
+nameLa: "Sancta Agnes, Virgo et Martyr (Secundo)"
 rank: simplex
 common: common-of-a-virgin-martyr
 propers: "st-agnes-secunda"

src/data/calendar/saints/st-agnes.yml

@@ -4,6 +4,7 @@
 # -- see st-agnes-secunda.yml.
 id: st-agnes
 name: "St. Agnes, Virgin and Martyr"
+nameLa: "Sancta Agnes, Virgo et Martyr"
 rank: duplex
 common: common-of-a-virgin-martyr
 propers: "st-agnes"