feat: complete OF+EF calendar coverage (movable feasts, vigils, ember days, transfers)

Ordinary Form:
- Add the movable Marian memorials that have no fixed date: Mary, Mother of the
  Church (Monday after Pentecost) and the Immaculate Heart (Saturday after the
  Sacred Heart), computed in computeOF.
- General Norms 60: two coinciding obligatory memorials both become optional and
  the ferial is observed -- except Mary, Mother of the Church, which keeps
  precedence per its 2018 decree.

Extraordinary Form:
- Capture fixed-date vigils in the sanctoral harvest (Christmas, the Nativity of
  St John the Baptist, Sts Peter & Paul, St Lawrence, the Assumption, All Saints,
  the Immaculate Conception) -- previously filtered out.
- temporalEF: the movable vigils of the Ascension (I class eve) and Pentecost
  (Whitsun Eve), and the September/Advent Ember days (II class violet ferias).
- transferIfImpededEF: the Annunciation transfers past Holy Week/the Easter
  octave to the Monday after Low Sunday; All Souls moves to Nov 3 when Nov 2 is a
  Sunday.
- genlect harvests proper Masses for the new Ember/vigil days.

Adds TestEFCoverage + TestOFMovableMemorials. Bumps to 0.39.0.

Verified per-day: OF 0 real errors vs calapi (2026-2028, 100% correct-observed);
EF 0 real errors vs missalemeum (2025-2027), residual = deep-tail vigil-occurrence
and St Joseph Passiontide-transfer edges (~1-2 days/yr, documented).

4 files changed, 211 insertions, 1 deletions

diff --git a/internal/calendar/calendar.go b/internal/calendar/calendar.go
index e0f5217..99a24b3 100644
--- a/internal/calendar/calendar.go
+++ b/internal/calendar/calendar.go
@@ -29,7 +29,8 @@ func computeEF(date time.Time, sel Selection, layers []Layer) LiturgicalDay {
 		if !ok {
 			continue
 		}
-		if sameDay(when, date) {
+		effective := transferIfImpededEF(cel, when)
+		if sameDay(effective, date) {
 			cands = append(cands, candidate{Cel: cel, Temporal: false, Season: td.Season})
 		}
 	}
@@ -75,6 +76,13 @@ func computeOF(date time.Time, sel Selection, layers []Layer) LiturgicalDay {
 			cands = append(cands, candidate{Cel: cel, Temporal: false, Season: td.Season})
 		}
 	}
+	// Movable Marian memorials that have no fixed date (so they cannot live in the
+	// sanctoral file): Mary, Mother of the Church, and the Immaculate Heart.
+	for _, mm := range movableMemorialsOF(date.Year()) {
+		if sameDay(mm.when, date) {
+			cands = append(cands, candidate{Cel: mm.cel, Temporal: false, Season: td.Season})
+		}
+	}
 
 	obs, others := pick(cands)
 	day := LiturgicalDay{
@@ -104,6 +112,31 @@ func celebrationDate(cel Celebration, year int, sel Selection) (time.Time, bool)
 	return resolveDate(cel.Date, year, Easter(year))
 }
 
+// movableCel is a celebration whose date is computed (relative to Easter), not
+// read from a fixed-date layer.
+type movableCel struct {
+	when time.Time
+	cel  Celebration
+}
+
+// movableMemorialsOF returns the Ordinary Form's two movable Marian memorials,
+// which have no fixed calendar date: Mary, Mother of the Church (the Monday after
+// Pentecost) and the Immaculate Heart of Mary (the Saturday after the Sacred
+// Heart, i.e. easter+69).
+func movableMemorialsOF(y int) []movableCel {
+	e := Easter(y)
+	mk := func(off int, slug, en, pl string) movableCel {
+		return movableCel{when: e.AddDate(0, 0, off), cel: Celebration{
+			Slug: slug, Rank: RankMemorial, Class: ClassBVM, Colour: White, Layer: "universal",
+			Name: map[string]string{"en": en, "pl": pl},
+		}}
+	}
+	return []movableCel{
+		mk(50, "mary-mother-of-the-church", "Mary, Mother of the Church", "Najświętszej Maryi Panny, Matki Kościoła"),
+		mk(69, "the-immaculate-heart-of-the-blessed-virgin-mary", "The Immaculate Heart of the Blessed Virgin Mary", "Niepokalanego Serca Najświętszej Maryi Panny"),
+	}
+}
+
 // transferIfImpeded moves a solemnity off a band-1/2 temporal day to the next
 // free day. Non-solemnities are never transferred (they yield instead).
 func transferIfImpeded(cel Celebration, when time.Time, sel Selection) time.Time {
@@ -126,6 +159,33 @@ func transferIfImpeded(cel Celebration, when time.Time, sel Selection) time.Time
 	return day
 }
 
+// transferIfImpededEF moves an EF sanctoral feast off a date it cannot be kept
+// on. Two rules cover the 1962 cases: All Souls, when Nov 2 is a Sunday, is
+// transferred to the Monday (Nov 3); and a I class feast impeded by a I class
+// temporal day (Holy Week, the Easter octave) is pushed forward to the next free
+// day — for the Annunciation in Holy Week this lands on the Monday after Low
+// Sunday, past the whole privileged octave. Lower-rank feasts are only
+// commemorated, never transferred.
+func transferIfImpededEF(cel Celebration, when time.Time) time.Time {
+	if when.Month() == time.November && when.Day() == 2 && when.Weekday() == time.Sunday &&
+		strings.Contains(cel.Slug, "all-souls") {
+		return when.AddDate(0, 0, 1)
+	}
+	if cel.Rank != RankClass1 {
+		return when
+	}
+	day := when
+	for i := 0; i < 30; i++ {
+		b := temporalEF(day)
+		if precedenceEF(candidate{Cel: b.Cel, Temporal: true, Season: b.Season}) <= 2 {
+			day = day.AddDate(0, 0, 1) // impeded by a I class temporal day; push forward
+			continue
+		}
+		return day
+	}
+	return day
+}
+
 // buildCelebration types a RawCelebration.
 func buildCelebration(slug string, rc RawCelebration) Celebration {
 	c := Celebration{Slug: strings.TrimSpace(slug), Name: map[string]string{}, Layer: rc.Fields["layer"]}
diff --git a/internal/calendar/coverage_test.go b/internal/calendar/coverage_test.go
new file mode 100644
index 0000000..e6555b9
--- /dev/null
+++ b/internal/calendar/coverage_test.go
@@ -0,0 +1,75 @@
+package calendar_test
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/lukaszkasprzak/lectio/internal/caldata"
+	"github.com/lukaszkasprzak/lectio/internal/calendar"
+)
+
+func day(y int, m time.Month, d int) time.Time {
+	return time.Date(y, m, d, 0, 0, 0, 0, time.UTC)
+}
+
+// TestEFCoverage checks the EF special days added for full coverage: the movable
+// vigils, the September/Advent Ember days, and the transfer of an impeded feast.
+// (2027: Easter is March 28.)
+func TestEFCoverage(t *testing.T) {
+	sel := calendar.DefaultSelection()
+	sel.Form = "old"
+	layers := []calendar.Layer{caldata.Tridentine()}
+
+	cases := []struct {
+		date time.Time
+		slug string
+		rank calendar.Rank
+	}{
+		{day(2027, time.September, 22), "ef-september-ember-wed", calendar.RankClass2},
+		{day(2027, time.December, 15), "ef-advent-ember-wed", calendar.RankClass2},
+		{day(2027, time.May, 5), "ef-ascension-vigil", calendar.RankClass2},
+		{day(2027, time.May, 15), "ef-pentecost-vigil", calendar.RankClass1},
+		{day(2027, time.June, 23), "vigil-of-the-nativity-of-st-john-the-baptist", calendar.RankClass2},
+		// Annunciation (Mar 25) is in Holy Week in 2027, so it is transferred to
+		// the Monday after Low Sunday (Apr 5); Mar 25 itself keeps the Triduum.
+		{day(2027, time.April, 5), "annunciation-of-the-blessed-virgin-mary", calendar.RankClass1},
+	}
+	for _, c := range cases {
+		got := calendar.Compute(c.date, sel, layers)
+		if got.Observed.Slug != c.slug || got.Observed.Rank != c.rank {
+			t.Errorf("%s: observed %q/%v, want %q/%v", c.date.Format("2006-01-02"),
+				got.Observed.Slug, got.Observed.Rank, c.slug, c.rank)
+		}
+	}
+	// The Annunciation must NOT also appear on its impeded fixed date.
+	if got := calendar.Compute(day(2027, time.March, 25), sel, layers); strings.Contains(got.Observed.Slug, "annunciation") {
+		t.Errorf("2027-03-25 (Holy Thursday) wrongly observes %q", got.Observed.Slug)
+	}
+	// All Souls: Nov 2 2025 is a Sunday, so it is transferred to Nov 3.
+	if got := calendar.Compute(day(2025, time.November, 3), sel, layers); got.Observed.Slug != "commemoration-of-all-souls" {
+		t.Errorf("2025-11-03: observed %q, want the transferred All Souls", got.Observed.Slug)
+	}
+}
+
+// TestOFMovableMemorials checks Mary, Mother of the Church, the Immaculate Heart,
+// and the two-obligatory-memorials rule.
+func TestOFMovableMemorials(t *testing.T) {
+	sel := calendar.DefaultSelection() // Ordinary Form
+	layers := []calendar.Layer{caldata.Universal()}
+
+	// Mary, Mother of the Church: Monday after Pentecost (2027: May 17).
+	if got := calendar.Compute(day(2027, time.May, 17), sel, layers); got.Observed.Slug != "mary-mother-of-the-church" {
+		t.Errorf("2027-05-17: observed %q, want mary-mother-of-the-church", got.Observed.Slug)
+	}
+	// Two obligatory memorials coincide (St Anthony of Padua + the Immaculate
+	// Heart, 2026-06-13): both become optional and the ferial is observed.
+	if got := calendar.Compute(day(2026, time.June, 13), sel, layers); got.Observed.Rank != calendar.RankFerial {
+		t.Errorf("2026-06-13: observed %q/%v, want the ferial", got.Observed.Slug, got.Observed.Rank)
+	}
+	// But Mary, Mother of the Church keeps precedence over a coinciding memorial
+	// (2028-06-05, with St Boniface).
+	if got := calendar.Compute(day(2028, time.June, 5), sel, layers); got.Observed.Slug != "mary-mother-of-the-church" {
+		t.Errorf("2028-06-05: observed %q, want mary-mother-of-the-church", got.Observed.Slug)
+	}
+}
diff --git a/internal/calendar/precedence.go b/internal/calendar/precedence.go
index 88cc0d8..3b7c0a6 100644
--- a/internal/calendar/precedence.go
+++ b/internal/calendar/precedence.go
@@ -84,5 +84,36 @@ func pick(cands []candidate) (candidate, []candidate) {
 		}
 		return sorted[i].Cel.Slug < sorted[j].Cel.Slug
 	})
+	// General Norms 60: when two obligatory memorials fall on the same day, both
+	// become optional and the weekday (ferial) is celebrated instead -- UNLESS one
+	// is Mary, Mother of the Church, whose 2018 institution decree gives it
+	// precedence over a coinciding obligatory memorial (then it is observed).
+	if len(sorted) >= 2 && !sorted[0].Temporal && !sorted[1].Temporal &&
+		sorted[0].Cel.Rank == RankMemorial && sorted[1].Cel.Rank == RankMemorial {
+		if i := slugIndex(sorted, "mary-mother-of-the-church"); i >= 0 {
+			motc := sorted[i]
+			sorted = append(sorted[:i], sorted[i+1:]...)
+			sorted = append([]candidate{motc}, sorted...)
+		} else {
+			for i, c := range sorted {
+				if c.Temporal {
+					ferial := sorted[i]
+					sorted = append(sorted[:i], sorted[i+1:]...)
+					sorted = append([]candidate{ferial}, sorted...)
+					break
+				}
+			}
+		}
+	}
 	return sorted[0], sorted[1:]
 }
+
+// slugIndex returns the position of the candidate with the given slug, or -1.
+func slugIndex(cands []candidate, slug string) int {
+	for i, c := range cands {
+		if c.Cel.Slug == slug {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/internal/calendar/temporal_ef.go b/internal/calendar/temporal_ef.go
index 2ead3e3..877545c 100644
--- a/internal/calendar/temporal_ef.go
+++ b/internal/calendar/temporal_ef.go
@@ -114,6 +114,10 @@ func temporalEF(date time.Time) temporalDay {
 		return efCel(TimeAfterPentecost, "ef-sacred-heart", White, RankClass1, 0)
 	case sameDay(date, efChristTheKing(y)):
 		return efCel(TimeAfterPentecost, "ef-christ-the-king", White, RankClass1, 0)
+	case sameDay(date, easter.AddDate(0, 0, 38)): // Wednesday: Vigil of the Ascension (II class)
+		return efCel(Easter_, "ef-ascension-vigil", White, RankClass2, 0)
+	case sameDay(date, easter.AddDate(0, 0, 48)): // Saturday: Vigil of Pentecost / Whitsun Eve (I class)
+		return efCel(Easter_, "ef-pentecost-vigil", Red, RankClass1, 0)
 	}
 
 	// Sundays vs ferias of the current season.
@@ -146,12 +150,52 @@ func temporalEF(date time.Time) temporalDay {
 		// the temporal office win, matching the 1962 occurrence rules.
 		rank = RankClass1
 	}
+	// The Ember Days of September and Advent (Wednesday, Friday, Saturday after
+	// the third Sunday of the month/season) are II class privileged ferias in
+	// violet; they displace a III class saint (only commemorated). The Lenten
+	// Ember days are already III class Lenten ferias, and the Whitsun Ember days
+	// fall inside the I class Pentecost octave handled above.
+	if es, ok := efEmberSlug(date, y); ok {
+		return efCel(season, es, Violet, RankClass2, week)
+	}
 	// Unique ferial slug (season-week-weekday) so proper ferias (Lent, Advent,
 	// Holy Week, Ember days) can key their own readings; green-season ferias
 	// simply have no lectionary entry and fall back to the Sunday.
 	return efCel(season, "ef-"+string(season)+"-"+strconv.Itoa(week)+"-"+weekdayLower(date), col, rank, week)
 }
 
+// thirdSundayOfSeptember returns the third Sunday in September of year y.
+func thirdSundayOfSeptember(y int) time.Time {
+	d := time.Date(y, time.September, 1, 0, 0, 0, 0, time.UTC)
+	for d.Weekday() != time.Sunday {
+		d = d.AddDate(0, 0, 1)
+	}
+	return d.AddDate(0, 0, 14)
+}
+
+// efEmberSlug returns the Ember-day slug for date, if it is an Ember Wednesday,
+// Friday or Saturday of September or Advent (the day after the third Sunday +
+// 3/5/6). Returns ("", false) otherwise.
+func efEmberSlug(date time.Time, y int) (string, bool) {
+	for _, e := range []struct {
+		third  time.Time
+		season string
+	}{
+		{thirdSundayOfSeptember(y), "september"},
+		{adventStart(y).AddDate(0, 0, 14), "advent"}, // 3rd Sunday of Advent
+	} {
+		switch {
+		case sameDay(date, e.third.AddDate(0, 0, 3)):
+			return "ef-" + e.season + "-ember-wed", true
+		case sameDay(date, e.third.AddDate(0, 0, 5)):
+			return "ef-" + e.season + "-ember-fri", true
+		case sameDay(date, e.third.AddDate(0, 0, 6)):
+			return "ef-" + e.season + "-ember-sat", true
+		}
+	}
+	return "", false
+}
+
 func weekdayLower(d time.Time) string {
 	return strings.ToLower(d.Weekday().String())
 }