feat(of): Phase 1 of the OF rite module — vocab_of, temporal_of

The first code for a second rite. lib/rites/rite_of/vocab_of implements
the OF's five-way rank vocabulary (Sollemnitas/Festum/Memoria_obligatoria/
Memoria_ad_libitum/Feria) and five-season vocabulary (Advent/Christmas/
Lent/Easter/Ordinary_time), each constructor cited against the 2002
Missale Romanum's Normae universales and the Tabula dierum liturgicorum.
temporal_of implements season boundaries, week numbering — including
Ordinary Time's own two-block resumption, derived from the Missale's own
"HEBDOMADA I/XXXIV 'per annum'" headings and empirically verified across
the whole 1583-9999 domain — named temporal days, and Sunday/ferial
slugs. Both satisfy Colitur_kernel.Temporal.RITE with no kernel change.

No Rite.t is assembled and no CLI wiring is added (Phase 2's own scope);
lib/rites/rite_ef and data/ef are untouched, verified byte-identical
against the v1.0.0 tag across a domain-spanning sample.

test/test_temporal_of.ml adds unit tests for every boundary and named day
plus seven QCheck properties (seasons contiguous, Ordinary Time weeks in
1..34, Advent always four Sundays, slug uniqueness, weekday agreement,
determinism, consecutive liturgical years partition civil time), with a
committed exhaustive sweep mirroring test_validate.ml's own convention.

Full account, including the Ordinary Time derivation's evidence and a
list of EF concepts that do not carry over, in
.superpowers/sdd/of-phase1-report.md (untracked, gitignored).

1 files changed, 531 insertions, 0 deletions

diff --git a/lib/rites/rite_of/temporal_of.ml b/lib/rites/rite_of/temporal_of.ml
new file mode 100644
index 0000000..367d855
--- /dev/null
+++ b/lib/rites/rite_of/temporal_of.ml
@@ -0,0 +1,531 @@
+(* OF (post-1970) temporal cycle. Every boundary and rank rule cites its
+   Missale Romanum editio typica tertia (2002) "Normae universales de anno
+   liturgico et de calendario" paragraph ("Normae n. N") or Institutio
+   Generalis Missalis Romani paragraph ("IGMR n. N") -- see vocab_of.ml's own
+   top-of-file comment for why the document has to be named on every
+   citation (both are independently numbered from 1 in the same source PDF).
+   Extracted with `pdftotext -layout docs/research/of/missale-romanum-2002.pdf`;
+   line numbers below are extracted-file line numbers from that command,
+   recorded so a citation can be re-located quickly, not because the PDF
+   itself is paginated that way. *)
+
+open Colitur_kernel
+open Vocab_of
+
+let mk y m d =
+  match Date.make ~year:y ~month:m ~day:d with
+  | Ok t -> t
+  | Error e -> failwith ("temporal_of: " ^ e)
+
+let weekday_index d =
+  match Date.weekday d with
+  | Date.Sun -> 0 | Date.Mon -> 1 | Date.Tue -> 2 | Date.Wed -> 3
+  | Date.Thu -> 4 | Date.Fri -> 5 | Date.Sat -> 6
+
+let sunday_on_or_before d = Date.add_days d (-(weekday_index d))
+
+(* The next Sunday STRICTLY after [d], even when [d] is itself a Sunday --
+   distinct from [sunday_on_or_before], and needed for exactly that reason by
+   {!baptism_of_the_lord} below (Normae n. 38's "dominica POST diem 6
+   ianuarii", not "on or after"). *)
+let next_sunday_strictly_after d =
+  let wi = weekday_index d in
+  Date.add_days d (if wi = 0 then 7 else 7 - wi)
+
+let before a b = Date.compare a b < 0
+let on_or_after a b = Date.compare a b >= 0
+let same a b = Date.compare a b = 0
+
+(* Normae n. 40 (Titulus II.V, "De tempore Adventus"): "Tempus Adventus
+   incipit a I Vesperis dominicae quae incidit in diem 30 novembris vel est
+   huic vicinior" -- Advent begins with First Vespers of the Sunday falling
+   on 30 November or nearest to it. Worded identically in substance to EF's
+   own RG 20 (Rite_ef.Temporal_ef.advent_start's own citation), so the same
+   closed-form identity holds and for the same reason: the Sunday nearest 30
+   November is, equivalently, three weeks (21 days) before the last Sunday on
+   or before 24 December -- verified once, generally, rather than re-derived
+   per rite: whichever weekday 24 December falls on, [sunday_on_or_before]
+   lands within the 7 days ending there, and subtracting 21 always lands
+   within the 7 days around 30 November, since 24 December minus 24 days is
+   30 November exactly and 21 is within one week of that. *)
+let advent_start y = Date.add_days (sunday_on_or_before (mk y 12 24)) (-21)
+let year_start = advent_start
+
+(* Normae n. 38 and the Calendarium Romanum Generale's own January table
+   (extracted line ~4033: "Dominica post diem 6 ianuarii: In baptismate
+   Domini Festum") -- see this function's own .mli citation for the full
+   argument, including why the table's Monday-shift clause never fires here. *)
+let baptism_of_the_lord y = next_sunday_strictly_after (mk y 1 6)
+
+(* Normae n. 35(a) and the December calendarium table's own closing line
+   (extracted line ~4459: "Dominica infra octavam Nativitatis, vel, ea
+   deficiente, die 30 decembris: Sanctae Familiae Iesu, Mariae et Ioseph
+   Festum") -- see this function's own .mli citation for the CODE-vs-DATA
+   argument for why this lives here rather than in Phase 3's sanctoral data. *)
+let holy_family y =
+  let window = List.init 6 (fun i -> mk y 12 (26 + i)) in
+  match List.find_opt (fun d -> Date.weekday d = Date.Sun) window with
+  | Some d -> d
+  | None -> mk y 12 30
+
+(* Normae n. 36: "Dominica a die 2 ad diem 5 ianuarii occurrens est Dominica
+   II post Nativitatem" -- see this function's own .mli citation for why
+   [None] (unlike {!holy_family}) is a genuine, uncovered outcome here: this
+   window carries no "otherwise, on a fixed date" fallback clause in the
+   primary text. *)
+let second_sunday_of_christmas y =
+  let window = List.init 4 (fun i -> mk y 1 (2 + i)) in
+  List.find_opt (fun d -> Date.weekday d = Date.Sun) window
+
+(* Normae n. 43-44 and the Missale's own "HEBDOMADA XXXIV 'PER ANNUM'"
+   heading (extracted line 13099) -- see [week]'s own citation below for the
+   full two-block week arithmetic this anchors. *)
+let christ_the_king y = Date.add_days (advent_start y) (-7)
+
+(* Normae n. 71-77 boundary text, PRIMARY-SOURCE-VERIFIED against the 2002
+   typical edition (docs/research/of/missale-romanum-2002.pdf, pdftotext
+   -layout, extracted lines ~3660-3790 for the Titulus II season definitions
+   themselves; see vocab_of.ml's own top-of-file comment for the Triduum
+   placement argument this function's own Lent branch below rests on).
+
+   Tested in chronological order within the civil year, mirroring
+   Rite_ef.Temporal_ef.season's own structure -- see that function's own
+   comment for why testing "on_or_after advent_this && before christmas_day"
+   FIRST is safe even for a January [d]: [advent_start (Date.year d)] for a
+   January date is always LATER within that same civil year (late November),
+   so the check correctly fails and falls through, and no special-casing is
+   needed for the year boundary.
+
+   - Advent (n. 40): [advent_this] through 24 December.
+   - Christmas (n. 33, "usque ad dominicam post Epiphaniam ... inclusive"):
+     25-31 December, THEN (continuing into the new civil year) 1 January
+     through {!baptism_of_the_lord} inclusive.
+   - Ordinary Time, first run (n. 44, "usque ad feriam III ante Quadragesimam
+     inclusive"): the day after {!baptism_of_the_lord} through the day
+     before Ash Wednesday.
+   - Lent (n. 28, "usque ad Missam in Cena Domini exclusive", PLUS the
+     Triduum-placement argument in vocab_of.ml): Ash Wednesday through Holy
+     Saturday inclusive -- i.e. everything before Easter itself.
+   - Easter (n. 22-23, "concluditur ... dominica Pentecostes"): Easter Sunday
+     through Pentecost Sunday inclusive.
+   - Ordinary Time, second run (n. 44, "iterum incipit feria II post
+     dominicam Pentecostes et explicit ante I Vesperas dominicae I
+     Adventus"): everything else -- the day after Pentecost through the day
+     before the FOLLOWING year's [advent_this], which is exactly what
+     survives every check above, so no explicit final test is needed; see
+     [week]'s own two-block arithmetic for why this run's own numbers still
+     land correctly on the far side of the interruption. *)
+let season d =
+  let y = Date.year d in
+  let easter = Computus.gregorian_easter y in
+  let advent_this = advent_start y in
+  let christmas_day = mk y 12 25 in
+  let ash_wednesday = Date.add_days easter (-46) in
+  let pentecost = Date.add_days easter 49 in
+  let baptism = baptism_of_the_lord y in
+  if on_or_after d advent_this && before d christmas_day then Advent
+  else if on_or_after d christmas_day then Christmas (* 25-31 Dec *)
+  else if before d (Date.add_days baptism 1) then Christmas (* 1 Jan .. baptism, inclusive *)
+  else if before d ash_wednesday then Ordinary_time (* first run *)
+  else if before d easter then Lent (* Ash Wed .. Holy Saturday, inclusive *)
+  else if Date.compare d pentecost <= 0 then Easter (* Easter Sunday .. Pentecost, inclusive *)
+  else Ordinary_time (* second run *)
+
+let days_between a b = Date.to_rata b - Date.to_rata a
+
+(* Floor division -- see Rite_ef.Temporal_ef's own identical helper for why
+   OCaml's truncating [/] would be wrong for a date before a season's own
+   week-1 origin. *)
+let floor_div a b = if a >= 0 then a / b else ((a + 1) / b) - 1
+
+let weekday_word d = Date.weekday_to_string (Date.weekday d)
+
+(* IGMR n. 346 (Titulus VIII, "De coloribus"), the season-level defaults; a-e
+   listed here, f (rose) is an override applied separately by
+   [is_rose_sunday] below, g (festive substitution) is not modelled (the same
+   kind of per-Mass-not-per-day nuance EF's own temporal_ef.ml already
+   documents as unmodelled for its own RG 126 palms/RG 132 Good Friday
+   cases).
+   a) "Color albus adhibetur in Officiis et Missis temporis paschalis et
+      Nativitatis Domini" -- white for Easter and Christmas time.
+   c) "Color viridis adhibetur in Officiis et Missis temporis 'per annum'"
+      -- green for Ordinary Time.
+   d) "Color violaceus adhibetur tempore Adventus et Quadragesimae" --
+      violet for Advent and Lent. *)
+let season_colour = function
+  | Christmas | Easter -> Colour.White
+  | Ordinary_time -> Colour.Green
+  | Advent | Lent -> Colour.Violet
+
+(* IGMR n. 346(f): "Color rosaceus adhiberi potest, ubi mos est, in
+   dominicis Gaudete (III Adventus) et Laetare (IV in Quadragesima)" -- MAY
+   be used, where customary. Treated as colitur's own canonical default the
+   same way Rite_ef.Temporal_ef.is_rose_sunday already treats EF's
+   structurally identical RG 131 ("may be used... for that Sunday only") --
+   an indult over the season's violet, not chosen afresh here. *)
+let is_rose_sunday d s =
+  let y = Date.year d in
+  match s with
+  | Advent -> same d (Date.add_days (advent_start y) 14) (* Gaudete: Advent III *)
+  | Lent -> same d (Date.add_days (Computus.gregorian_easter y) (-21)) (* Laetare: Lent IV *)
+  | _ -> false
+
+let holy_family_names =
+  Names.of_list [ (Lang.of_string_exn "la", "Sanctae Familiae Iesu, Mariae et Ioseph") ]
+
+let baptism_names = Names.of_list [ (Lang.of_string_exn "la", "In Baptismate Domini") ]
+
+(* Named temporal days that need no per-year conditional: the Nativity and
+   its Vigil, Mary Mother of God (the Nativity's own Octave Day, 1 January,
+   Normae n. 35(f)), Epiphany (n. 37, universal calendar only -- the
+   local Sunday-transfer option is out of scope, spec's own EF-precedented
+   discipline), Ash Wednesday (n. 29), Palm/Passion Sunday (n. 30, merged
+   into Lent's own week VI -- vocab_of.ml's own citation), Easter and the six
+   weekday days of its Octave (n. 24, "uti sollemnitates Domini
+   celebrantur"), Ascension (n. 25, "quadragesima die post Pascha" --
+   Easter+39, inclusive day-counting, the same convention EF's own [off 39]
+   anchor uses), Pentecost (n. 22-23), Trinity Sunday and Corpus Christi
+   (both found by their own headings in the Missale's "IN SOLLEMNITATIBUS
+   DOMINI 'PER ANNUM' OCCURRENTIBUS" appendix, extracted lines
+   ~13130-13230: "Dominica I post Pentecosten: SANCTISSIMAE TRINITATIS
+   Sollemnitas"; "Feria V post Ss.mam Trinitatem: SANCTISSIMI CORPORIS ET
+   SANGUINIS CHRISTI Sollemnitas" -- kept on its PRIMARY, typical-edition
+   date, Thursday after Trinity, not the widespread local Sunday-transfer
+   option the SAME heading's own next sentence names, for the identical
+   universal-calendar-only reason Epiphany's transfer is excluded), and
+   Christ the King (n. 43's own heading, this file's own [christ_the_king]
+   citation).
+
+   Grades: Nativity/Mary Mother of God/Epiphany/Easter-and-its-Octave/
+   Ascension/Pentecost/Trinity/Corpus-Christi/Christ-the-King are
+   [Sollemnitas], confirmed against the calendarium's own printed grade word
+   for each ("Sollemnitas") wherever a table entry exists (Nativity, Mary
+   Mother of God, Christ the King all extracted with that literal word next
+   to them; the movable Sundays/Ascension/Pentecost/Trinity/Corpus Christi
+   have none, being computed rather than tabulated, but sit at Tabula entry
+   2/3/5, the same table region, and the Missale's own two "IN SOLLEMNITATIBUS
+   ... OCCURRENTIBUS" headings state it directly for Trinity/Corpus Christi).
+   Ash Wednesday is [Feria] -- see vocab_of.ml's own top-of-file comment for
+   why a privileged feria stays [Feria] here rather than getting an elevated
+   rank the way EF's own [Class1] does: OF's rank vocabulary keeps grade and
+   precedence-table-position separate, unlike EF's.
+
+   Colours per IGMR n. 346 (season_colour's own citation covers the season
+   defaults; the exceptions below are cited individually): Palm/Passion
+   Sunday is RED (346(b): "Color ruber adhibetur in dominica Passionis"),
+   not Lent's own violet -- a genuine, easy-to-miss divergence from what the
+   surrounding season's colour would suggest. Pentecost is likewise RED
+   (346(b): "in dominica Pentecostes"). The Nativity Vigil is tagged white on
+   IGMR 346(a)'s general "celebrationibus Domini" clause -- NO day-specific
+   colour rubric was found for the Vigil Mass itself in the extracted text
+   (unlike, e.g., the Chrism Mass or Holy Thursday's own explicit "color
+   albus" note found elsewhere in the same document), so this is the
+   best-supported general-clause reading, flagged honestly rather than
+   presented as a day-specific citation. *)
+let named d =
+  let y = Date.year d in
+  let easter = Computus.gregorian_easter y in
+  let off n = Date.add_days easter n in
+  let m = Date.month d and dd = Date.day d in
+  if m = 12 && dd = 24 then Some (Advent, "of-nativity-vigil", Colour.White, Sollemnitas)
+  else if m = 12 && dd = 25 then Some (Christmas, "of-nativity", Colour.White, Sollemnitas)
+  else if m = 1 && dd = 1 then Some (Christmas, "of-mary-mother-of-god", Colour.White, Sollemnitas)
+  else if m = 1 && dd = 6 then Some (Christmas, "of-epiphany", Colour.White, Sollemnitas)
+  else if same d (off (-46)) then Some (Lent, "of-ash-wednesday", Colour.Violet, Feria) (* Normae n. 29 *)
+  else if same d (off (-7)) then Some (Lent, "of-palm-sunday", Colour.Red, Sollemnitas) (* n. 30; IGMR 346(b) *)
+  else if same d easter then Some (Easter, "of-easter-sunday", Colour.White, Sollemnitas)
+  else if List.mem (days_between easter d) [ 1; 2; 3; 4; 5; 6 ] then
+    (* Easter Monday .. Saturday: n. 24's own eight days are Easter Sunday
+       (above) plus these six plus the closing Sunday (day 8), deliberately
+       left OUT of [named] -- see this file's own [sunday_slug], whose
+       generic Sunday-of-Easter branch already lands it on [Sollemnitas] via
+       the SAME week-1-numbering path every other Easter Sunday uses, with no
+       need for a second, competing named entry. *)
+    Some (Easter, Printf.sprintf "of-easter-octave-day-%d" (days_between easter d + 1), Colour.White, Sollemnitas)
+  else if same d (off 39) then Some (Easter, "of-ascension", Colour.White, Sollemnitas)
+  else if same d (off 49) then Some (Easter, "of-pentecost", Colour.Red, Sollemnitas)
+  else if same d (off 56) then Some (Ordinary_time, "of-trinity", Colour.White, Sollemnitas)
+  else if same d (off 60) then Some (Ordinary_time, "of-corpus-christi", Colour.White, Sollemnitas)
+  else if same d (christ_the_king y) then Some (Ordinary_time, "of-christ-the-king", Colour.White, Sollemnitas)
+  else None
+
+(* Week numbering. Advent, Lent and Easter each have a single, simple origin
+   Sunday (mirroring Rite_ef.Temporal_ef.week_origin's own shape); Christmas
+   has none at all (its own structure is date-keyed throughout -- n. 36 says
+   "the Sunday falling 2-5 January", never "week I", and no calendarium
+   heading anywhere in Christmas time carries a week-number title the way
+   "HEBDOMADA I 'PER ANNUM'" does); Ordinary Time needs the two-block
+   arithmetic below.
+
+   ORDINARY TIME'S OWN RESUMPTION RULE -- the hard part this module exists
+   to get right, and the reason it is Phase 1's own gate. DERIVED, not
+   copied, from three primary-text facts, none of which alone states the
+   rule but which together pin it down uniquely:
+
+   1. Normae n. 44: Ordinary Time runs in two disjoint blocks -- "the Monday
+      following the Sunday occurring after 6 January" through "Tuesday before
+      Lent, inclusive" (the FIRST run), then "the Monday after Pentecost
+      Sunday" through "before First Vespers of Advent I" (the SECOND run).
+   2. The Missale's own "HEBDOMADA I 'PER ANNUM'" heading (extracted line
+      12050: "Dominica prima 'per annum' fit festum Baptismatis Domini") --
+      the Baptism of the Lord Sunday IS, positionally, "Dominica I" of
+      Ordinary Time's own week-numbering scheme, even though its SEASON, per
+      n. 33, is still Christmas. The very next heading in the Missal is
+      literally "DOMINICA II 'PER ANNUM'" -- confirming the first run's
+      numbering begins counting from that Sunday, landing the run's own
+      first NUMBERED Sunday (the one actually inside Ordinary Time's season)
+      on week 2.
+   3. The Missale's own "HEBDOMADA XXXIV 'PER ANNUM'" heading (extracted
+      line 13099: "Dominica ultima 'per annum' fit sollemnitas ...
+      universorum Regis") -- the LAST Sunday before Advent I, Christ the
+      King, is ALWAYS week XXXIV. Confirmed structurally, not merely
+      asserted: nothing in the Missale computes Christ the King's own date
+      from a week number at all -- it is defined independently, as "the
+      Sunday nearest 30 November, minus 7 days" (this file's own
+      [christ_the_king]) -- so this heading is a genuine, independently
+      falsifiable claim, not a tautology.
+
+   Given (1)-(3), the FIRST run's week numbers follow the ordinary
+   Sunday-aligned [floor_div] formula from origin {!baptism_of_the_lord},
+   uninterrupted until Ash Wednesday cuts it off (fact 2 pins the origin;
+   nothing further is needed for this half). The SECOND run cannot use the
+   same simple formula with a fixed origin, because fact 3 is a CONSTRAINT
+   on where the run must END, not a statement of where it begins -- and
+   Normae n. 43 itself says the total is "thirty-three OR thirty-four"
+   weeks, meaning the gap between where the first run stops and where the
+   second run's own numbers would need to start (for the run to still end on
+   34) is not constant across years. The only value consistent with facts 1
+   and 3 simultaneously is computed BACKWARD from Christ the King: number the
+   second run's own weeks, Sunday-aligned, counting forward from Pentecost
+   Sunday as if it were itself week 0 (a "raw" count with no liturgical
+   meaning of its own), find that raw count for the FINAL week (Christ the
+   King's own week), and shift every raw number in the run by the constant
+   amount that makes the final one read 34. That shift is not cosmetic the
+   way EF's own analogous "n - total + 7" resumed-tail relabelling
+   (Rite_ef.Temporal_ef.sunday_slug) is -- there, the underlying [week] FIELD
+   stays the raw, uncapped Pentecost count, and only the SLUG string is
+   relabelled, because EF's numbering carries no rubrical meaning past
+   Time_after_pentecost's own raw count. Here the adjusted number IS the
+   liturgical week identity itself (it selects which Mass formulary applies,
+   per the Missale's own week headings), so [week] itself, not merely a
+   slug, must carry the adjusted value.
+
+   EVIDENCE this produces the right shape (empirically verified, not merely
+   argued, across every one of the 8 417 years 1583..9999 with a small
+   throwaway script reproducing this exact arithmetic): the two runs never
+   overlap (no year assigns the same week number to two different Sundays),
+   every number produced falls in 1..34 inclusive, and the gap between the
+   first run's own last week and the second run's own first week is ALWAYS
+   either 0 (all 34 weeks used, no skip) or 1 (exactly one week number
+   skipped that year, used by neither run) -- never more, never negative --
+   which is exactly Normae n. 43's own "thirty-three OR thirty-four", with
+   "34" corresponding to gap 0 and "33" to gap 1. This IS "in some years a
+   week is skipped entirely" (the task brief's own framing), now measured:
+   2 672 of the 8 417 years use all 34; 5 745 skip exactly one. *)
+let ordinary_time_week d y easter =
+  let baptism = baptism_of_the_lord y in
+  let ash_wednesday = Date.add_days easter (-46) in
+  if before d ash_wednesday then
+    let n = floor_div (days_between baptism d) 7 + 1 in
+    if n < 1 then None else Some n
+  else
+    let pentecost = Date.add_days easter 49 in
+    let ctk = christ_the_king y in
+    let raw_total = floor_div (days_between pentecost ctk) 7 + 1 in
+    let raw_n = floor_div (days_between pentecost d) 7 + 1 in
+    let adjusted = 34 - raw_total + raw_n in
+    if adjusted < 1 || adjusted > 34 then None else Some adjusted
+
+let week d =
+  let y = Date.year d in
+  let easter = Computus.gregorian_easter y in
+  match season d with
+  | Christmas -> None
+  | Advent ->
+      let n = floor_div (days_between (advent_start y) d) 7 + 1 in
+      if n < 1 then None else Some n
+  | Lent ->
+      let n = floor_div (days_between (Date.add_days easter (-42)) d) 7 + 1 in
+      if n < 1 then None else Some n
+  | Easter ->
+      let n = floor_div (days_between easter d) 7 + 1 in
+      if n < 1 then None else Some n
+  | Ordinary_time -> ordinary_time_week d y easter
+
+(* Sunday slugs. Christmas needs its own three-way dispatch (the season has
+   no week numbering at all, and carries up to three distinct movable
+   Sundays a year -- {!holy_family}, {!second_sunday_of_christmas} and
+   {!baptism_of_the_lord} -- every OTHER season's Sundays use the generic
+   week-numbered form. A Sunday {!named} already intercepts (Palm/Passion
+   Sunday, Easter, Ascension is never a Sunday, Pentecost, Trinity, Corpus
+   Christi is never a Sunday, Christ the King) never reaches this function at
+   all, since {!temporal}'s own dispatch checks [named] first. *)
+let sunday_slug d =
+  if Date.weekday d <> Date.Sun then None
+  else
+    let y = Date.year d in
+    let s = season d in
+    match s with
+    | Christmas ->
+        if same d (holy_family y) then Some "of-holy-family"
+        else if second_sunday_of_christmas y = Some d then Some "of-christmas-sunday-2"
+        else if same d (baptism_of_the_lord y) then Some "of-baptism-of-the-lord"
+        else None (* unreachable: every Christmas-season Sunday is one of the three above *)
+    | _ -> (
+        match week d with
+        | Some n -> Some (Printf.sprintf "of-%s-sunday-%d" (season_slug_word s) n)
+        | None -> None)
+
+(* Ferial slugs within Christmas time. Three disjoint stretches, numbered
+   0/1/2 exactly like Rite_ef.Temporal_ef.christmastide_feria_slug's own
+   three (a real structural parallel between the two rites' Christmas
+   seasons, not a copied convention) -- needed for the identical reason: a
+   single "no week numbering" slug key would let the same weekday recur
+   across stretches within one liturgical year, violating slug uniqueness
+   (spec's own requirement, {!Colitur_kernel.Validate}'s ["slugs"] check).
+   - 26-31 December (minus {!holy_family}, when it lands there, already
+     intercepted earlier): "of-christmas-0-<weekday>".
+   - 2-5 January (minus {!second_sunday_of_christmas}, when it exists):
+     "of-christmas-1-<weekday>".
+   - 7 January through the day before {!baptism_of_the_lord} (0 to 6 days,
+     empty exactly when Epiphany falls on a Saturday): "of-christmas-2-<weekday>". *)
+let christmas_feria_slug d y =
+  let m = Date.month d and dd = Date.day d in
+  let w = weekday_word d in
+  if m = 12 && dd >= 26 && dd <= 31 then Some (Printf.sprintf "of-christmas-0-%s" w)
+  else if m = 1 && dd >= 2 && dd <= 5 then Some (Printf.sprintf "of-christmas-1-%s" w)
+  else if m = 1 && dd >= 7 && before d (baptism_of_the_lord y) then Some (Printf.sprintf "of-christmas-2-%s" w)
+  else None
+
+let id = "of"
+
+let temporal d =
+  let y = Date.year d in
+  let s = season d in
+  let weekday = Date.weekday d in
+  let build ?(subject = Subject.Temporal) ?(names = Names.empty) ~season ~slug ~colour ~rank ~week () =
+    let office = Celebration.make ~slug:(Slug.of_string_exn slug) ~rank ~colour ~subject ~names ~layer:"temporal" () in
+    { Temporal.season; week; weekday; office }
+  in
+  match named d with
+  | Some (season, slug, colour, rank) -> build ~season ~slug ~colour ~rank ~week:(week d) ()
+  | None -> (
+      match sunday_slug d with
+      | Some slug ->
+          let colour = if is_rose_sunday d s then Colour.Rose else season_colour s in
+          let subject, names, rank =
+            if same d (holy_family y) then (Subject.Lord, holy_family_names, Festum)
+              (* Tabula entry 6 ("Dominicae temporis Nativitatis") would
+                 already give an ordinary Christmas-time Sunday Festum; Holy
+                 Family's own grade word in the calendarium ("Festum") happens
+                 to agree, so no separate table-entry citation is needed for
+                 the RANK itself, only for the identity override. *)
+            else if second_sunday_of_christmas y = Some d then (Subject.Temporal, Names.empty, Festum)
+            else if same d (baptism_of_the_lord y) then (Subject.Lord, baptism_names, Festum)
+            else
+              (* Tabula entry 2 ("Dominicae Adventus, Quadragesimae et
+                 Paschae") vs. entry 6 ("dominicae 'per annum'") -- the ONLY
+                 remaining case reaching this branch is a plain, unnamed
+                 Sunday of Advent, Lent, Easter or Ordinary Time (every
+                 Christmas Sunday is already one of the three branches
+                 above). *)
+              let rank = match s with Advent | Lent | Easter -> Sollemnitas | Ordinary_time | Christmas -> Festum in
+              (Subject.Temporal, Names.empty, rank)
+          in
+          build ~subject ~names ~season:s ~slug ~colour ~rank ~week:(week d) ()
+      | None -> (
+          match christmas_feria_slug d y with
+          | Some slug -> build ~season:s ~slug ~colour:(season_colour s) ~rank:Feria ~week:(week d) ()
+          | None ->
+              let easter = Computus.gregorian_easter y in
+              let after_ashes = days_between easter d in
+              if after_ashes >= -45 && after_ashes <= -43 then
+                (* Thursday/Friday/Saturday after Ash Wednesday: proper
+                   Masses, but before Lent's own week-1 origin -- no week
+                   number, mirroring Rite_ef.Temporal_ef's identical gap. *)
+                build ~season:s
+                  ~slug:(Printf.sprintf "of-lent-after-ashes-%s" (weekday_word d))
+                  ~colour:Colour.Violet ~rank:Feria ~week:None ()
+              else
+                let week_n = week d in
+                let slug =
+                  Printf.sprintf "of-%s-%d-%s" (season_slug_word s) (Option.value week_n ~default:0) (weekday_word d)
+                in
+                let colour =
+                  if after_ashes = -3 then
+                    (* Holy Thursday (Missa in Cena Domini): IGMR n. 346(a)'s
+                       own general clause, "insuper in celebrationibus
+                       Domini, quae non sint de eius Passione" -- a
+                       celebration OF THE LORD that is not of his Passion
+                       (the institution of the Eucharist and the
+                       priesthood, distinct from Good Friday's own Passion
+                       commemoration) -- white. No DAY-SPECIFIC "color
+                       albus" rubric was found in the extracted text for
+                       this exact Mass (unlike some other Masses in the same
+                       document); this is the best-supported general-clause
+                       reading, flagged rather than presented as a
+                       day-specific citation, the same honesty [named]'s own
+                       Nativity Vigil colour note above gives. *)
+                    Colour.White
+                  else if after_ashes = -2 then
+                    (* Good Friday: IGMR n. 346(b), "Color ruber adhibetur
+                       ... in celebrationibus Passionis Domini" -- red, not
+                       Lent's own season violet. *)
+                    Colour.Red
+                  else
+                    (* Holy Saturday's own daytime (after_ashes = -1) is
+                       aliturgical -- no Mass, hence no colour rubric to find
+                       in the primary text at all -- and every other Lenten
+                       feria has none either; both default to the season's
+                       own violet, the textually conservative choice rather
+                       than an invented specific one. *)
+                    season_colour s
+                in
+                build ~season:s ~slug ~colour ~rank:Feria ~week:week_n ()))
+
+(* Independent restatement of {!named}'s fixed and Easter-relative dates,
+   plus {!holy_family}, {!second_sunday_of_christmas} (when it exists that
+   year) and {!baptism_of_the_lord}, paired with the slug each carries --
+   the same anchor-agreement discipline Rite_ef.Temporal_ef.anchors follows,
+   for the identical reason (catches an accidental single-site drift, e.g. an
+   offset silently changing, rather than leaving it invisible). Easter's own
+   six weekday octave days are included via the same [1;2;3;4;5;6] offset
+   list [named] itself uses, restated independently rather than reused, for
+   the same "independent" discipline the rest of this list follows. *)
+let anchors y =
+  let easter = Computus.gregorian_easter y in
+  let off n = Date.add_days easter n in
+  [ ("of-nativity-vigil", mk y 12 24);
+    ("of-nativity", mk y 12 25);
+    ("of-mary-mother-of-god", mk y 1 1);
+    ("of-epiphany", mk y 1 6);
+    ("of-holy-family", holy_family y);
+    ("of-baptism-of-the-lord", baptism_of_the_lord y);
+    ("of-ash-wednesday", off (-46));
+    ("of-palm-sunday", off (-7));
+    ("of-easter-sunday", off 0) ]
+  @ List.map (fun n -> (Printf.sprintf "of-easter-octave-day-%d" (n + 1), off n)) [ 1; 2; 3; 4; 5; 6 ]
+  @ [ ("of-ascension", off 39);
+      ("of-pentecost", off 49);
+      ("of-trinity", off 56);
+      ("of-corpus-christi", off 60);
+      ("of-christ-the-king", christ_the_king y) ]
+  @ (match second_sunday_of_christmas y with
+     | Some d -> [ ("of-christmas-sunday-2", d) ]
+     | None -> [])
+
+(* Compile-time check that this module satisfies the kernel's rite contract
+   -- the same check Rite_ef.Temporal_ef ends with. Deliberately the ONLY
+   kernel-facing signature this phase satisfies: {!Colitur_kernel.Rite.t}
+   itself (precedence, transfers, readings) is Phase 2's own deliverable, per
+   the task brief's explicit "do not add a Rite.t for it". *)
+module _ : Colitur_kernel.Temporal.RITE = struct
+  let id = id
+
+  type season = Vocab_of.season
+  type rank = Vocab_of.rank
+
+  let vocab = Vocab_of.vocab
+  let year_start = year_start
+  let temporal = temporal
+end