Dedupe Matins nocturn readings pooled from two ids on the same day

post-pentecost-15 and month-week-092 land on the same Sunday
(2026-09-06) and independently reuse the identical Gregory the Great
Moralia in Job excerpt -- a real duplication in the reference engine's
own Tempora files, not a vu authoring error. buildReadingPool pooled
both ids and rendered the reading twice; now dedupes by text.

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

src/app-state.ts

@@ -56,8 +56,25 @@ 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 {

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

@@ -83,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 };
 }
 
 /**
@@ -143,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: [],
@@ -188,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

@@ -12,12 +12,15 @@
 //
 // 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) have no authored Latin form anywhere in `data/` today — those use
-// the English string as their own `la` value too (same "surface real text
-// rather than block on missing" convention used elsewhere in this app),
-// rather than leaving Latin mode showing blanks. Only the closed,
-// mechanism-level vocabulary here (weekdays, ranks, season/ordinal
-// phrasing) has real Latin authored.
+// 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';
@@ -36,16 +39,49 @@ function bi(en: string, la: string): Bi {
   return { en, la };
 }
 
-/** A proper name with no authored Latin form yet — the English string
- * stands in for `la` too. See file-header note. */
-function biFallback(name: string): Bi {
-  return { en: name, la: name };
+/** 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'),
+};
+
+function emberDayLabel(id: string): Bi | undefined {
+  return EMBER_DAY_NAMES[id];
+}
+
 function capitalize(text: string): string {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
@@ -348,13 +384,13 @@ function temporalLabel(day: LiturgicalDay): Bi {
  * 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). The octave's own `name` has no authored Latin form
- * (see file header), so both languages currently show the same name text
- * — only the surrounding phrasing differs. */
+ * 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 ${octave.name}`, `In Octava ${octave.name}`)
-    : bi(`${ordinal(octave.dayNumber)} Day within the Octave of ${octave.name}`, `${ordinalLa(octave.dayNumber)} die infra Octavam ${octave.name}`);
+    ? bi(`Octave of ${name.en}`, `In Octava ${name.la}`)
+    : bi(`${ordinal(octave.dayNumber)} Day within the Octave of ${name.en}`, `${ordinalLa(octave.dayNumber)} die infra Octavam ${name.la}`);
 }
 
 function octaveLabel(octave: ActiveOctave): Bi {
@@ -405,8 +441,8 @@ const CROSS_DAY_VESPERS_LABELS: Record<'today' | 'tomorrow', Bi> = {
  * - `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). No authored Latin saint names exist yet
- *   (see file header), so `la` falls back to the same English name.
+ *   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
@@ -438,19 +474,31 @@ function collectCommemorations(
   const octaves: Bi[] = [];
   for (const c of day.commemorations) {
     if (c.kind === 'sanctoral') {
-      const name = biFallback(c.name);
-      sanctoral.push(
-        c.vespersNote
-          ? bi(`${name.en} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].en})`, `${name.la} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].la})`)
-          : name,
-      );
+      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') {
       if (c.id === temporalId) {
         temporal.push(anchorDayName(day, false) ?? temporalLabel(day));
+      } else {
+        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) : biFallback(c.name));
+      octaves.push(octave ? octaveCommemorationLabel(octave) : biName(c.name, c.nameLa));
     }
   }
   return { sanctoral, temporal, octaves };
@@ -500,16 +548,60 @@ const TEMPORAL_CATEGORY_RANK_LABELS: Record<TemporalCategory, Bi> = {
  * 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` —
- * only that carries the `vespersFrom` tag this reads.
+ * `calendar/vespers.ts`'s `resolveEveningDay`, not a plain `resolveDay`,
+ * plus the originally-requested date — comparing the two directly (rather
+ * than checking `winner.vespersFrom`, which only ever gets set for a
+ * *sanctoral* tomorrow-winner, see `vespers.ts`'s `tagVespersFrom`) is
+ * what makes this correct even when tomorrow's winner is `temporal` (e.g.
+ * an ordinary Sunday winning outright over a merely-commemorated Simplex
+ * saint) — a case `winner.vespersFrom` can never detect since that field
+ * doesn't exist on the temporal variant of `DayWinner` at all.
  */
-export function getVespersStatusLabel(day: LiturgicalDay): Bi {
-  if (day.winner.kind === 'sanctoral' && day.winner.vespersFrom === 'firstVespersOfTomorrow') {
+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,
@@ -536,9 +628,11 @@ export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>>
       showOctaves: day.temporalCategory === 'ordinary-feria',
     });
     const rank = formatRank(day.winner.rank);
-    const winnerName = biFallback(day.winner.name);
-    const winner = bi(`${winnerName.en} (${rank.en})`, `${winnerName.la} (${rank.la})`);
-    return joinBi([winner, ...temporal, ...sanctoral, ...octaves]);
+    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, ...)
@@ -548,12 +642,12 @@ export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>>
   // temporal-feasts.ts) and fall through further down.
   const namedFeast = getTemporalFeastRecord(day.winner.id);
   if (namedFeast) {
-    const name = biFallback(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 joinBi([primary, ...sanctoral]);
+    return withTransferNote(day, joinBi([primary, ...sanctoral]));
   }
 
   // A season's own named anchor day (Trinity Sunday, Easter, Ash
@@ -561,12 +655,12 @@ export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>>
   // 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.
-  // Existing convention: a commemorated saint *leads* here, before the
-  // anchor name — not "winner first" like every branch above.
+  // Winner first, same as every other branch here — the anchor day is
+  // what's actually being celebrated even when a lesser saint rides along.
   const anchorName = anchorDayName(day);
   if (anchorName) {
     const { sanctoral } = collectCommemorations(day, { showOctaves: false });
-    return joinBi([...sanctoral, anchorName]);
+    return withTransferNote(day, joinBi([anchorName, ...sanctoral]));
   }
 
   // An active octave (St. Lawrence's, ...) is this day's real primary
@@ -602,12 +696,12 @@ export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>>
   if (activeOctave) {
     const { sanctoral, octaves } = collectCommemorations(day, { showOctaves: true, excludeOctaveId: activeOctave.id });
     const primary = octaveLabel(activeOctave);
-    return joinBi([primary, ...octaves, ...sanctoral]);
+    return withTransferNote(day, joinBi([primary, ...octaves, ...sanctoral]));
   }
 
   const temporalRank = TEMPORAL_CATEGORY_RANK_LABELS[day.temporalCategory];
-  const label = temporalLabel(day);
+  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 joinBi([...sanctoral, temporal]);
+  return withTransferNote(day, joinBi([temporal, ...sanctoral]));
 }

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,6 +78,19 @@ 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;
@@ -125,6 +141,7 @@ for (const mod of Object.values(saintModules)) {
 export interface SanctoralCandidate {
   id: string;
   name: string;
+  nameLa?: string;
   rank: FeastClass;
 }
 
@@ -144,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,9 +1,9 @@
-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 } 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';
@@ -13,10 +13,13 @@ 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);
@@ -37,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,
+      };
     }
   }
 
@@ -51,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
@@ -69,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 };
 }
 
 /**
@@ -94,14 +188,34 @@ 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);
@@ -109,8 +223,15 @@ export function resolveDay(isoDate: string): LiturgicalDay {
   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 };
 }
 
 /**
@@ -141,6 +262,32 @@ function applyEpiphany6Commemoration(isoDate: string, commemorations: Commemorat
   commemorations.push({ kind: 'temporal', id: 'post-epiphany-6' });
 }
 
+/**
+ * When Advent 4's own Sunday lands on Dec 24 (its latest possible date),
+ * `resolveTemporalId` already gives that day the Vigil of Christmas's own
+ * identity (`vigil-of-christmas` — collect, Lauds antiphons, Matins Gospel
+ * nocturn), matching the reference engine's own rule that the Vigil's rank
+ * governs. Per direct instruction (2026-08), unlike the reference engine's
+ * own `no commemoratio` for this exact day, Advent 4 itself is still
+ * commemorated here — the Sundays of Advent have real standing of their
+ * own, distinct from an ordinary saint quietly ceding to a Vigil. Purely
+ * additive, same shape as applyEpiphany6Commemoration just above: no new
+ * `Commemoration` variant needed, `getDayCollects` already resolves any
+ * `{ kind: 'temporal' }` commemoration's own `${id}-collect` for free.
+ * `advent-4` is hardcoded rather than recomputed because Dec 24 always
+ * falls at or after Advent's own 4th Sunday by construction (it's the
+ * latest date Advent's 4th Sunday can ever land on).
+ */
+function applyAdventFourVigilCommemoration(
+  isoDate: string,
+  weekday: ReturnType<typeof weekdayOf>,
+  commemorations: Commemoration[],
+): void {
+  if (isoDate.slice(5) === '12-24' && weekday === 'sunday') {
+    commemorations.push({ kind: 'temporal', id: 'advent-4' });
+  }
+}
+
 /**
  * Per direct instruction, scoped to exactly Dec 26-30 — every year
  * contains exactly one real Sunday somewhere in that 5-day window.
@@ -210,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 };
     }
   }
 
@@ -263,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;
 }
 
@@ -316,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) };
       }
     }
@@ -329,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 });
     }
   }
 

src/calendar/movable-feasts.ts

@@ -83,7 +83,7 @@ export function applyMovableFeasts(isoDate: string, winner: DayWinner, commemora
       if (resolvedWinner.kind === 'temporal') {
         commemorations.push({ kind: 'temporal', id: resolvedWinner.id });
       } else {
-        commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, rank: resolvedWinner.rank });
+        commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
       }
       resolvedWinner = FEAST_WINNER;
       continue;
@@ -95,7 +95,7 @@ export function applyMovableFeasts(isoDate: string, winner: DayWinner, commemora
     } 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, rank: resolvedWinner.rank });
+      commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
       resolvedWinner = FEAST_WINNER;
     }
   }

src/calendar/octaves.ts

@@ -17,6 +17,9 @@ 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);
       }
     }
   }

src/calendar/temporal-feasts.ts

@@ -30,6 +30,9 @@ export type MovableAnchor =
 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;
@@ -87,6 +90,7 @@ const FIXED_DATE_STARTS: [string, string][] = [['12-25', 'christmas-day']];
 
 /** Easter-offset starts (offset -> temporal feast id). */
 const EASTER_OFFSET_STARTS: [number, string][] = [
+  [17, 'patronage-of-st-joseph'],
   [39, 'ascension'],
   [49, 'pentecost-sunday'],
   [60, 'corpus-christi'],

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

@@ -202,12 +202,33 @@ export function adventEmberDayOffset(isoDate: string): number | undefined {
  * 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;
   }
 

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);
 
 /**
@@ -179,8 +194,16 @@ export type Commemoration =
       // 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 };
+  | { kind: 'octave'; id: string; name: string; nameLa?: string };
 
 export interface LiturgicalDay {
   /** ISO date, e.g. "2026-08-09" */
@@ -194,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,7 @@ 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';
 
@@ -53,18 +53,27 @@ function hasFirstVespers(day: LiturgicalDay): boolean {
   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');
+  );
 }
 
 /**
@@ -85,7 +94,7 @@ function commemorationOfDisplacedPredecessor(loser: DayWinner): Commemoration |
   if (loser.kind !== 'sanctoral' || loser.rank === 'simplex') {
     return undefined;
   }
-  return { kind: 'sanctoral', id: loser.id, name: loser.name, rank: loser.rank, vespersNote: 'today' };
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'today' };
 }
 
 /**
@@ -120,7 +129,7 @@ function commemorationOfDisplacedSuccessor(winner: DayWinner, loser: DayWinner):
   if (forbids) {
     return undefined;
   }
-  return { kind: 'sanctoral', id: loser.id, name: loser.name, rank: loser.rank, vespersNote: 'tomorrow' };
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'tomorrow' };
 }
 
 function tagVespersFrom(tomorrow: LiturgicalDay): LiturgicalDay {
@@ -200,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);
@@ -208,7 +234,19 @@ export function resolveEveningDay(isoDate: string): LiturgicalDay {
   if (isMajorFixedFeastOfTheLord(tomorrow.date)) {
     return tagVespersFrom(tomorrow);
   }
+
+  let todayWins: boolean;
   if (keepsOwnSecondVespers(today)) {
+    todayWins = true;
+  } else if (today.winner.kind === 'sanctoral' && tomorrow.winner.kind === 'sanctoral') {
+    todayWins = compareFeastClass(today.winner.rank, tomorrow.winner.rank) > 0;
+  } else if (today.winner.kind === 'sanctoral' && isAtLeast(today.winner.rank, 'duplex-2-classis')) {
+    todayWins = true;
+  } else {
+    todayWins = !hasFirstVespers(tomorrow);
+  }
+
+  if (todayWins) {
     // Today wins outright, but tomorrow is still commemorated here as
     // long as it's a real sanctoral winner — see
     // commemorationOfDisplacedSuccessor's own doc comment for why this
@@ -216,8 +254,5 @@ export function resolveEveningDay(isoDate: string): LiturgicalDay {
     const commemoration = commemorationOfDisplacedSuccessor(today.winner, tomorrow.winner);
     return commemoration ? { ...today, commemorations: [...today.commemorations, commemoration] } : today;
   }
-  if (!hasFirstVespers(tomorrow)) {
-    return 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,6 +6,7 @@
 # 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"

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

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

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"

src/data/calendar/saints/st-albert-the-great.yml

@@ -9,6 +9,7 @@
 # itself a cross-reference to C4).
 id: st-albert-the-great
 name: "St. Albert the Great, Bishop, Confessor and Doctor of the Church"
+nameLa: "Sanctus Albertus Magnus, Episcopus, Confessor et Ecclesiæ Doctor"
 rank: duplex
 common: common-of-a-confessor-doctor
 propers: "st-albert-the-great"

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

@@ -5,6 +5,7 @@
 # so no antiphon is recorded -- Common of a Confessor only.
 id: st-alexius
 name: "St. Alexius, Confessor"
+nameLa: "Sanctus Alexius, Confessor"
 rank: simplex
 common: common-of-a-confessor
 propers: null

src/data/calendar/saints/st-aloysius-gonzaga.yml

@@ -8,6 +8,7 @@
 # -- ignored per the untagged-block convention.
 id: st-aloysius-gonzaga
 name: "St. Aloysius Gonzaga, Confessor"
+nameLa: "Sanctus Aloysius Gonzaga, Confessor"
 rank: duplex
 common: common-of-a-confessor
 propers: "st-aloysius-gonzaga"