bizdays-toolkit 0.14.1 → 0.16.0

package/CHANGELOG.md

@@ -4,6 +4,55 @@
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-23
+
+### 移行
+
+日時の文字列の区切りは `T` だけになり、空白で区切った文字列（`"2026-11-23 10:00"`）は `invalid-time` の Error になる（これまでは実行時だけ受け付けていた。型 `DateTimeInput` は以前から `T` 区切りだけ）。合成した `dayInfo` に `decidedByPath` が加わるので、`deepEqual` で比べているテストは期待値に足す。ほかは動作が変わらない（祝前日の規則・サブパス・合成の項目の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 繰り返しの規則に祝前日の形 `{ dayBeforeHoliday: true }` を追加した（型 `DayBeforeHolidayPattern`）。翌日が提供元の祝日でその日自身は祝日でない日に当てはまり、連休なら連休の初日の前日だけ。`{ dayAfterHoliday: true }` の鏡像で、`weekdays`・`months`・有効期間を付けられ、`onHolidayRule` は `invalid-option`。宿泊の祝前日料金・飲食店の祝前日の営業時間・祝前日の出荷の締めの繰り上げを規則として書ける。診断の `never-matches`・`shadowed` も扱う
+- 祝日の提供元を実装する人向けのサブパス `bizdays-toolkit/provider` を追加した（`@beta`）。内部で使っている暦の計算 `easterSunday(year)`（グレゴリオ暦の復活祭。英国の祝日で GOV.UK のデータと照合済み）、`nthWeekdayOfMonth(year, month, weekday, n)`（`n` は 1〜5 と -1（最後））、`daysInMonth`、`isLeapYear` を、入力の検証を付けて公開する。米国の連邦祝日やドイツ・豪州の州の祝日のように、第 n 曜日と復活祭で決まる提供元が書ける
+- 合成したカレンダーの `dayInfo` に `decidedByPath`（判定を決めたカレンダーまでの番号の列。外側から順）を追加した。合成したカレンダーをさらに合成したとき、`rulePath` がどのカレンダーの設定の位置かを結果だけから辿れる。`decidedBy` は外側の番号のまま
+
+### Changed
+
+- 日時の文字列の区切りを `T` だけにし、空白で区切った文字列は `invalid-time` にした（上の「移行」）
+- README: 繰り返しの規則の節に祝前日、他の国・地域の祝日の節に `bizdays-toolkit/provider` と復活祭で決まる提供元の例、合成の節に `decidedByPath`、日付・日時の入力の節に区切りの条件、確かめている環境に Bun・Deno を足した。サイズの値を測り直した（ルート約 9.8KB・日本の祝日込み約 11.6KB・英国の祝日込み約 11.5KB。0.16.0 で測定）
+- `docs/decisions.md`: 14 番に年ごとの列挙で足りる理由、26 番に Bun・Deno、29 番に空白区切りの廃止、33 番に祝前日を足した経緯、36 番に曜日の日に `rulePath` を付けない理由の書き直し（位置は書けるが冗長）、41 番に次の月に併合する側を選んだ理由を書き、43 番（祝前日・provider・`decidedByPath`・空白区切りの廃止・Bun と Deno の確認）を追加した
+- `RELEASING.md`: 確認の表と固定する版の一覧に `bun`・`deno` ジョブを足した
+
+### 開発
+
+- CI に `bun`・`deno` ジョブを追加した。公開する `dist` を Bun 1.4.3 と Deno 2.9.7（`--unstable-temporal`。本物の Temporal も確かめる）で、`test/compat/runtime.mjs` から `smoke.mjs` を実行して確かめる。どちらも版と SHA-256 を固定した公式のリリースを取得する（workerd と同じ方式）。`smoke.mjs` に `bizdays-toolkit/provider` の確認を足した（Node.js・ブラウザー・workerd・CJS の確認も同じものを呼ぶ）
+- `easterSunday` を `src/uk/rules.ts` から `src/core/date.ts` に移した（結果は変わらない。provider のサブパスが英国のデータを引き込まないため）
+- 規則の診断の性質のテストの生成器に祝前日を加えた。`test/day-before-holiday.test.ts`・`test/provider.test.ts` を新規に足し、利用者の型チェックに祝前日・`decidedByPath`・provider を足した
+- サイズの上限（`size-limits.json`）を上げ、`./provider` のエントリーを足した。ルート 23,000 → 24,000、`./jp` 26,000 → 27,000、`./diagnose` 29,500 → 30,500（gzip）。祝前日の検証・判定・診断と `decidedByPath` のため。`./provider` は 4,500（日付とエラーの共通の実装を含む）
+
+## [0.15.0] - 2026-10-21
+
+### 移行
+
+`businessDayOnOrAfter` に `cutoff` を指定するときは、時刻を持つ入力（`Date`・日時の文字列・時刻を持つ Temporal の値）を渡す。時刻のない入力（暦日の文字列・`PlainDate`）との組み合わせは、これまで暦日を 0 時として扱い締め時刻を黙って無視していたが、`invalid-argument` の Error になる。ほかは動作が変わらない（規則の絞り込み・カレンダーのメソッド・型の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 祝日の規則（`{ holiday: true }`）と祝日の翌日の規則（`{ dayAfterHoliday: true }`）に、曜日の絞り込み `weekdays`（`months`・`kinds` と同じ絞り込みの配列）を追加した。「祝日の翌日は休館（土日に当たる場合は開館）」は `{ dayAfterHoliday: true, weekdays: [1, 2, 3, 4, 5] }`、「土曜の祝日は午前診療」は `{ holiday: true, weekdays: [6], value: … }`。曜日・日の規則に `weekdays` を付けると `invalid-option`。診断の `never-matches`・`shadowed` も曜日の絞り込みを扱う
+- 営業日カレンダーに、営業日を考慮した締め日 `closingMonth(input, closingDay, { convention })`・`closingPeriod(monthOrDate, closingDay, { convention })` を追加した。各月の締め日を `adjust` と同じ `convention`（必須）で営業日に調整し、日付は調整後の締め日がその日以降になる最初の月に属する。前月の締め日から当月の締め日までに営業日がない月（長期休業）は固有の期間を持たず、その日は次の月に属し、その月の `closingPeriod` は `no-business-day`。合成したカレンダー・スケジュールからのカレンダーにも付く。ルートの `closingMonth`・`closingPeriod` は暦日のまま
+- `HolidayPattern`・`RecurringPattern`・`RecurringRule`・`RecurringValue` に祝日の種別の型引数 `Kind`（既定 `string`）を追加し、`kinds` を `readonly Kind[]` にした。`holidays: jp` のカレンダー・スケジュールでは `kinds` に日本の祝日の種別の補完が効く（型は開いているので、ほかの文字列も通る）。型引数なしの利用はこれまでどおり
+
+### Changed
+
+- `businessDayOnOrAfter` の `cutoff` を、時刻を持たない入力と組み合わせると `invalid-argument` にした（上の「移行」）
+- README: `businessDaysBetween` が `addBusinessDays` の逆算になるのは起点が営業日のときで、休業日の起点では `addBusinessDays` が翌営業日を 1 と数える（`+0` と `+1` が同じ日）ことを明記した。`weekdays`、営業日を考慮した締め日、`cutoff` の入力の条件、バッジに npm のダウンロード数（直近 18 か月）を足した。サイズの値を測り直した（ルート約 9.7KB・日本の祝日込み約 11.5KB・英国の祝日込み約 11.4KB。0.15.0 で測定）
+- `docs/decisions.md`: 31 番に「起点が営業日のとき」の条件と休業日の起点の定義を、37 番に「別名」と「文脈を持つ経路」の線引きを、30 番に `reason`・`rulePath`・診断の違いを足した。41 番（`weekdays`・営業日を考慮した締め日と空の月の扱い）・42 番（`kinds` の型・`cutoff` の例外）を追加した
+
+### 開発
+
+- 性質のテストに、休業日を起点にした `addBusinessDays`（`addBusinessDays(a, n) = addBusinessDays(businessDayOnOrAfter(a), n − 1)`、n ≥ 1）と、営業日を考慮した締め日（複数のカレンダー × 4 つの方法 × 締め日 1〜31・−1 で、空でない期間が敷き詰められ `closingMonth` と往復する）を足した。規則の診断の性質のテストに `weekdays` を加えた
+- サイズの上限（`size-limits.json`）を上げた。ルート 22,000 → 23,000、`./jp` 25,000 → 26,000、`./diagnose` 28,500 → 29,500（gzip）。`weekdays` の検証・判定と営業日を考慮した締め日のため
+
 ## [0.14.1] - 2026-10-20
 
 ライブラリの結果は 0.14.0 と同じ（内部の改善と文書だけ）。
@@ -382,7 +431,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.1...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...HEAD
+[0.16.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.15.0...v0.16.0
+[0.15.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.1...v0.15.0
 [0.14.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...v0.13.0

package/README.md

@@ -7,6 +7,7 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/bizdays-toolkit"><img src="https://img.shields.io/npm/v/bizdays-toolkit" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/bizdays-toolkit"><img src="https://img.shields.io/npm/d18m/bizdays-toolkit" alt="npm downloads"></a>
   <a href="https://github.com/inohan77/bizdays-toolkit/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/inohan77/bizdays-toolkit/ci.yml?branch=main&amp;label=CI" alt="CI status"></a>
   <a href="https://github.com/inohan77/bizdays-toolkit/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/bizdays-toolkit" alt="license"></a>
   <img src="https://img.shields.io/node/v/bizdays-toolkit" alt="Node.js version">
@@ -28,7 +29,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **A calendar from a schedule**: `createCalendarFromSchedule` turns a schedule such as store hours into a business-day calendar, so the hours are the only configuration and business-day arithmetic works on them
 - **Combining calendars**: `combineCalendars` builds a calendar of the days on which all of several calendars are open (your company and the bank, for a remittance date) or any of them is open (any of several stores), and business-day arithmetic works on the result
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 9.3 KB min+gzip (about 11.1 KB with Japanese holidays, about 11.1 KB with UK bank holidays; measured for 0.14.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
+- **Lightweight, zero dependencies**: about 9.8 KB min+gzip (about 11.6 KB with Japanese holidays, about 11.5 KB with UK bank holidays; measured for 0.16.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari, Cloudflare Workers, Bun and Deno
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -37,7 +38,7 @@ A business-day calendar that combines public holidays with company or store clos
 pnpm add bizdays-toolkit
 ```
 
-Node.js 22.12 or later. CI tests the package on Node.js 22.12, 22, 24 and 26, on Chrome, Firefox and Edge (Linux) and Safari (macOS), and on Cloudflare Workers (workerd, the open-source Workers runtime). The browsers are the latest stable versions on GitHub's runners, so their versions change as the runners are updated. The package is ESM only, but it can also be loaded from CommonJS with `require()` (tested in CI as well; on Node.js 22.12, `require()` prints an experimental-feature warning, which does not affect the result, and Node.js 26 prints none). Other runtimes (such as Deno, Bun or Vercel's Edge Runtime) are not tested.
+Node.js 22.12 or later. CI tests the package on Node.js 22.12, 22, 24 and 26, on Chrome, Firefox and Edge (Linux) and Safari (macOS), on Cloudflare Workers (workerd, the open-source Workers runtime), and on Bun (1.4) and Deno (2.9). The browsers are the latest stable versions on GitHub's runners, so their versions change as the runners are updated. The package is ESM only, but it can also be loaded from CommonJS with `require()` (tested in CI as well; on Node.js 22.12, `require()` prints an experimental-feature warning, which does not affect the result, and Node.js 26 prints none). Vercel's Edge Runtime is not tested.
 
 Types are bundled. CI type-checks a consumer project against the published type definitions with TypeScript 5.0, 5.5, 5.8, 6.0 and 7.0 (the native compiler), each with `moduleResolution` set to `node16`, `nodenext` and `bundler`, and confirms that an intentional type error is reported by each.
 
@@ -112,14 +113,14 @@ shipping.addBusinessDays("2026-12-30", 1); // "2027-01-04"
 shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // business days from (inclusive) to (exclusive)
 
 // Orders before 14:00 ship today, later orders on the next business day
-shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
+shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" }); // the input must carry a time of day
 
 shipping.dayInfo("2027-01-01");
 // { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "New Year closure", holiday: {…}, rulePath: "closedAnnual[0]" }
 shipping.daysBetween("2026-12-30", "2027-01-04").map((d) => d.businessDay); // [true, false, false, false, false, true]
 ```
 
-`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included). `listBusinessDays` and `holidaysBetween` include both ends too; only `businessDaysBetween(from, to)` counts from `from` (inclusive) to `to` (exclusive), so that `businessDaysBetween(a, b) + businessDaysBetween(b, c)` equals `businessDaysBetween(a, c)` and it is the inverse of `addBusinessDays`.
+`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included). `listBusinessDays` and `holidaysBetween` include both ends too; only `businessDaysBetween(from, to)` counts from `from` (inclusive) to `to` (exclusive), so that `businessDaysBetween(a, b) + businessDaysBetween(b, c)` equals `businessDaysBetween(a, c)` and, when `a` is a business day, `businessDaysBetween(a, addBusinessDays(a, n))` is `n` (the inverse of `addBusinessDays`). From a closed day, `addBusinessDays` counts the next business day as 1 (so `+0` and `+1` give the same day, as `n = 0` is `businessDayOnOrAfter`), while `businessDaysBetween` does not count the closed start, so the two differ by one there.
 
 `createCalendar` and `createSchedule` validate the options when they are created, so the usual pattern is to create them once and reuse them. Creating is also cheap (about 0.02 ms for a calendar and 0.04 ms for a schedule with Japanese holidays on a development machine), so creating one per request is not a problem in practice.
 
@@ -136,9 +137,9 @@ Each day is decided in this order of priority (top first).
 
 This order is fixed. Only the relation between a recurring rule and holidays can be chosen per rule with `onHolidayRule` (next section).
 
-### Recurring rules (weekly, every other week, nth weekday, day of month, holidays, day after a holiday)
+### Recurring rules (weekly, every other week, nth weekday, day of month, holidays, day after or before a holiday)
 
-Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "closed every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays (on the next weekday if Monday is a holiday)", "open on substitute holidays" or "closed on the day after a holiday" go in `closedRecurring` and `openRecurring`.
+Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "closed every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays (on the next weekday if Monday is a holiday)", "open on substitute holidays", "closed on the day after a holiday" or "late opening on the day before a holiday" go in `closedRecurring` and `openRecurring`.
 
 ```ts
 const museum = createCalendar({
@@ -173,14 +174,16 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 | `{ day: 20 }`                                       | The 20th of every month. `day` is 1–31 or -1 (last day); an array gives several                                      |
 | `{ holiday: true, kinds: ["substitute"] }`          | Holidays, optionally narrowed to the given kinds (`Holiday.kind`); judged before `holidayPolicy` (see below)         |
 | `{ dayAfterHoliday: true }`                         | The day after a holiday: the first non-holiday after a holiday or a run of holidays (holidays of the provider only)  |
+| `{ dayBeforeHoliday: true }`                        | The day before a holiday: the non-holiday just before a holiday or a run of holidays (holidays of the provider only) |
 | `months: [8, 12]`                                   | Narrows any pattern to these months                                                                                  |
 | `effectiveFrom: "2027-04-01"`, `effectiveTo: "…"`   | The period the rule is in effect (both ends included). Outside it, the rule is as if it were not written (see below) |
 
 - **The nth weekday** is the nth occurrence of that weekday in the month (days 1–7 hold the 1st). It is not the weekday in the nth row of a printed calendar
 - **Days that do not exist in a month** (`nth: 5` or `day: 31` in a month without one) do not match. Use `day: -1` for the last day
 - **Every other week** (`interval: 2`) is not the same as the 1st and 3rd weekdays (`nth: [1, 3]`): a month with five Wednesdays shifts the latter by a week. `interval` is the number of weeks (an integer of 2 or more) and `anchor` is a date on the same weekday that the cycle passes through; the rule matches that date and every `interval` weeks before and after it. Stores announce "every other Wednesday from January 7", so copy that date. To start at the anchor rather than also matching earlier dates, add `effectiveFrom`. `interval` cannot be combined with `nth`
-- **Holiday rules** (`{ holiday: true }`) write exceptions to the default holiday handling: "open on holidays from April 2027" is `openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]` with `holidayPolicy: "closed"` kept for the past, "open on substitute holidays and citizens' holidays" is `openRecurring: [{ holiday: true, kinds: ["substitute", "citizens"] }]`, and "special hours on the May holidays" in a schedule is `recurring: [{ holiday: true, months: [5], value: … }]`. `kinds` narrows to those `Holiday.kind` values (see the provider's list), `months` to those months; omit both for all holidays. The rule is judged at the "over the holiday" step, before `holidayPolicy` or a schedule's `holiday`, and also with `holidayPolicy: "ignore"`. Its days are holidays, so `onHolidayRule` cannot be set on it (`invalid-option`); `holiday` still shows the holiday
-- **The day after a holiday** is never itself a holiday, so `onHolidayRule` cannot be set on such a rule (it is an `invalid-option`). "Holidays" are those of the holiday provider, not annual closures. A rule of this kind matches no day without a holiday provider
+- **Holiday rules** (`{ holiday: true }`) write exceptions to the default holiday handling: "open on holidays from April 2027" is `openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]` with `holidayPolicy: "closed"` kept for the past, "open on substitute holidays and citizens' holidays" is `openRecurring: [{ holiday: true, kinds: ["substitute", "citizens"] }]`, and "special hours on the May holidays" in a schedule is `recurring: [{ holiday: true, months: [5], value: … }]`. `kinds` narrows to those `Holiday.kind` values (see the provider's list; with `holidays: jp` the editor completes them), `weekdays` to those weekdays ("morning hours on a Saturday holiday" is `{ holiday: true, weekdays: [6], value: … }`), `months` to those months; omit them for all holidays. The rule is judged at the "over the holiday" step, before `holidayPolicy` or a schedule's `holiday`, and also with `holidayPolicy: "ignore"`. Its days are holidays, so `onHolidayRule` cannot be set on it (`invalid-option`); `holiday` still shows the holiday
+- **The day after a holiday** is never itself a holiday, so `onHolidayRule` cannot be set on such a rule (it is an `invalid-option`). "Holidays" are those of the holiday provider, not annual closures. A rule of this kind matches no day without a holiday provider. `weekdays` narrows it to those weekdays: a museum "closed on the day after a holiday, except when that day is a Saturday or Sunday" is `{ dayAfterHoliday: true, weekdays: [1, 2, 3, 4, 5] }` (opening the weekend with `openRecurring` instead would override every other weekend closure)
+- **The day before a holiday** (`{ dayBeforeHoliday: true }`) is the mirror image: the day whose next day is a holiday and which is not a holiday itself, so before a run of holidays it is only the day before the run (in May 2026 it is Saturday May 2; May 4 and 5 are holidays themselves). The same rules apply (`weekdays`, `months`, effective periods, no `onHolidayRule`, no match without a provider). It writes "eve-of-holiday rates" in a schedule, "open until 2 a.m. on the day before a holiday" (`weekdays: [1, 2, 3, 4, 5]` keeps weekends as usual), or an earlier shipping cutoff on the day before a holiday (put the cutoff time in a schedule and pass `cutoffs.valueOn(date)` as `cutoff`)
 - Among recurring rules, the one written first in the array wins, and `openRecurring` wins over `closedRecurring`. The day after Labor Thanksgiving Day on a Monday (2026-11-23) is both the day the Monday rule moves to and the day after a holiday; the rule written first decides, and `dayInfo` shows which
 
 **Effective periods** (`effectiveFrom`, `effectiveTo`) let one calendar represent a change of rules and still reproduce past dates. They go on recurring rules and on annual closures (`closedAnnual` in object form).
@@ -228,8 +231,15 @@ const hours = createSchedule<Hours>({
   recurring: [
     { weekday: 1, value: null, name: "Closed on Mondays", onHolidayRule: "after-holiday" },
     { day: -1, value: { open: "10:00", close: "17:00" }, name: "Short hours at month end" },
+    {
+      dayBeforeHoliday: true,
+      value: { open: "10:00", close: "23:00" },
+      name: "Late on the eve of a holiday",
+    },
   ],
 });
+hours.valueOn("2026-05-02"); // { open: "10:00", close: "23:00" } (the day before the May 3–6 holidays)
+hours.dayInfo("2026-05-04").reason; // "weekday" (a holiday in the run is not the day before a holiday)
 ```
 
 ### Combining calendars
@@ -255,7 +265,7 @@ const bank = createCalendar({
 const remittance = combineCalendars([company, bank], { businessDay: "all" });
 remittance.addBusinessDays("2026-12-28", 2); // "2027-01-05"
 remittance.dayInfo("2026-12-29");
-// { date: "2026-12-29", weekday: 2, businessDay: false, reason: "closed-annual", name: "New Year closure", rulePath: "closedAnnual[0]", decidedBy: 0 }
+// { date: "2026-12-29", weekday: 2, businessDay: false, reason: "closed-annual", name: "New Year closure", rulePath: "closedAnnual[0]", decidedBy: 0, decidedByPath: [0] }
 
 // Any of several stores is open
 const anyStore = combineCalendars([company, bank], { businessDay: "any" });
@@ -263,6 +273,7 @@ anyStore.isBusinessDay("2026-12-29"); // true
 ```
 
 - `dayInfo` reports `reason`, `name`, `shiftedFrom` and `rulePath` from the first calendar whose result equals the combined result, and the index of that calendar in `decidedBy` (`rulePath` is a position in that calendar's options). With `"all"`, a closed day is explained by the first calendar that is closed, and an open day by calendar 0 (all are open). With `"any"` it is the other way round
+- `decidedByPath` is the list of indexes down to the calendar that decided, outermost first, so that `rulePath` can be traced from the result alone when combined calendars are combined again: `[0]` for a plain combination (the same as `decidedBy`), `[0, 1]` for calendar 1 inside calendar 0. `decidedBy` stays the outer index
 - `holiday`, `isHoliday`, `holidaysInYear` and so on use the union of the calendars' holiday providers: the same provider object counts once, a wrapped provider (such as `jp` with some kinds filtered out) counts as a different one, and when two providers have a holiday on the same date, the provider of the earlier calendar decides the holiday shown. Combining a calendar with a wrapped `jp` and one with `jp` itself therefore keeps the business-day results but still shows the filtered-out holidays in `holiday`. `outOfRange` is `"throw"` if any calendar throws outside its supported years
 - All calendars must share a time zone (`time-zone-conflict` otherwise). Passing fewer than two calendars, or the same calendar twice, is an `invalid-argument`. `maxSearchDays` (default 3660) can be given in the options
 - A combined calendar can be combined again. Option diagnostics work on options, not on calendars, so diagnose each calendar's options separately
@@ -407,6 +418,18 @@ const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
 office.listBusinessDays(from, to).length; // 22 (business days in the November period)
 ```
 
+**Closing days that move to a business day**: when the contract says "closed on the 20th, or the previous business day if the 20th is not one", use the calendar's `closingMonth(date, closingDay, { convention })` and `closingPeriod(monthOrDate, closingDay, { convention })`. Each month's closing day (the last day when it does not exist) is adjusted with the `convention` of `adjust` (required, no default), and a date belongs to the first month whose adjusted closing day is on or after it. The root functions keep closing on calendar days.
+
+```ts
+const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
+// September 20, 2026 is a Sunday: with "preceding" the September closing day is Friday the 18th
+office.closingMonth("2026-09-19", 20, { convention: "preceding" }); // "2026-10" (the 19th is after the September closing)
+closingMonth("2026-09-19", 20); // "2026-09" (closing on calendar days)
+office.closingPeriod("2026-10", 20, { convention: "preceding" }); // { from: "2026-09-19", to: "2026-10-20" }
+```
+
+A month whose closing day is not preceded by any business day since the previous closing day (a long closure for renovation, say) has no period of its own: its days belong to the next month, `closingMonth` never returns that month, and `closingPeriod` for that month throws `no-business-day`. With `"following"` a closing day can move past a long closure into a later month; the period is then longer, not empty.
+
 The `day` of `dueDate` also maps days that do not exist in a month (such as February 30) to the last day. Recurring rules (`{ day: 31 }`) do not match such days, so the two behave differently: a due date must always fall somewhere in its month.
 
 ### Day-by-day values (e.g. store hours)
@@ -500,7 +523,7 @@ Every method accepts the following inputs. Returned dates are always `"YYYY-MM-D
 | Temporal `PlainDate`, `PlainDateTime`                | A civil date or date and time (no dependency on Temporal)         |
 | Temporal `Instant`, `ZonedDateTime`                  | An instant                                                        |
 
-Temporal objects are recognized by their shape, so the package does not depend on Temporal. CI also checks real Temporal objects in the runtimes that provide Temporal (the CI log shows whether each runtime had it).
+The separator between the date and the time is `T` (upper or lower case), as in the `DateTimeInput` type; a space (`"2026-11-23 10:00"`) is an `invalid-time` error. Temporal objects are recognized by their shape, so the package does not depend on Temporal. CI also checks real Temporal objects in the runtimes that provide Temporal (the CI log shows whether each runtime had it).
 
 The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
@@ -549,6 +572,38 @@ const myCountry: HolidayProvider = {
 const calendar = createCalendar({ holidays: myCountry, closedWeekdays: [0, 6] });
 ```
 
+Most holidays of other countries are an nth weekday of a month (the US federal holidays) or a fixed number of days from Easter Sunday (much of Europe). `bizdays-toolkit/provider` exposes the calendar arithmetic the bundled providers use for these, so a provider does not have to reimplement and verify it: `nthWeekdayOfMonth(year, month, weekday, n)` (`n` is 1–5 or -1 for the last), `easterSunday(year)` (Gregorian; verified against GOV.UK for the UK providers), `daysInMonth(year, month)` and `isLeapYear(year)`. Combine them with `addDays` and `weekdayOf` from the root. These functions are `@beta` (they may change in a minor version while their use settles).
+
+```ts
+import { addDays, createCalendar, type HolidayProvider } from "bizdays-toolkit";
+import { easterSunday, nthWeekdayOfMonth } from "bizdays-toolkit/provider";
+
+const bavaria: HolidayProvider<"public"> = {
+  id: "DE-BY",
+  timeZone: "Europe/Berlin",
+  supportedYears: { from: 2000, to: 2100 },
+  dataVersion: "example",
+  holidaysInYear: (year) => {
+    const easter = easterSunday(year);
+    const day = (date: string, name: string, nameEn: string) => ({
+      date,
+      name,
+      nameEn,
+      kind: "public" as const,
+      confirmed: true,
+    });
+    return [
+      day(addDays(easter, -2), "Karfreitag", "Good Friday"),
+      day(addDays(easter, 1), "Ostermontag", "Easter Monday"),
+      day(addDays(easter, 60), "Fronleichnam", "Corpus Christi"),
+    ];
+  },
+};
+createCalendar({ holidays: bavaria }).isHoliday("2026-06-04"); // true (Corpus Christi)
+nthWeekdayOfMonth(2026, 11, 4, 4); // "2026-11-26" (the 4th Thursday of November: Thanksgiving Day)
+nthWeekdayOfMonth(2026, 5, 1, -1); // "2026-05-25" (the last Monday of May: Memorial Day)
+```
+
 Holidays can carry names in other languages in `names`. The keys are canonical BCP 47 language tags (`"zh-Hant"`, `"ko"` and so on). The bundled Japanese holidays have no `names` (only the officially sourced Japanese and English names are bundled); among the UK providers, only Wales has Welsh names. If you need more, wrap the provider.
 
 ```ts

package/dist/core/calendar.d.ts

@@ -81,9 +81,9 @@ export interface CalendarOptions<Kind extends string = string> extends HolidaySo
      * 祝日に当たったときの扱いは規則ごとに onHolidayRule で指定する（既定: "under-holiday"）。
      * 有効期間（effectiveFrom・effectiveTo）を付けると、期間の外では書かれていないのと同じに扱う
      */
-    readonly closedRecurring?: readonly RecurringRule[];
+    readonly closedRecurring?: readonly RecurringRule<Kind>[];
     /** 繰り返しの営業日。closedRecurring と同じ日に当たる場合はこちらが優先 */
-    readonly openRecurring?: readonly RecurringRule[];
+    readonly openRecurring?: readonly RecurringRule<Kind>[];
     /** 祝日の扱い（既定: "closed"） */
     readonly holidayPolicy?: HolidayPolicy;
     /** 営業日を探すときに調べる最大日数（既定: 3660）。超えたら Error */
@@ -126,6 +126,12 @@ export interface DayInfo<Kind extends string = string> {
      * reason・name・shiftedFrom・rulePath はそのカレンダーの結果。合成していないカレンダーでは付かない
      */
     readonly decidedBy?: number;
+    /**
+     * 合成したカレンダーで、判定を決めたカレンダーまでの番号の列（外側から順）。入れ子でない合成では長さ 1 で、
+     * 先頭は decidedBy と同じ。合成したカレンダーをさらに合成したとき、rulePath がどのカレンダーの設定の位置かを
+     * 結果だけから辿れる（例: [0, 1] は 0 番のカレンダーの中の 1 番）。合成していないカレンダーでは付かない
+     */
+    readonly decidedByPath?: readonly number[];
 }
 /**
  * カレンダーの合成のオプション。
@@ -147,7 +153,8 @@ export interface CombineOptions {
 export interface BusinessDayOptions {
     /**
      * 締め時刻 "HH:mm"（カレンダーのタイムゾーン）。
-     * 入力の時刻がこの時刻以降なら、その日は対象にしない。暦日だけの入力は 0 時として扱う
+     * 入力の時刻がこの時刻以降なら、その日は対象にしない。時刻を持たない入力（暦日の文字列・Temporal の PlainDate など）
+     * と組み合わせると code: "invalid-argument" の Error（締め時刻が黙って無視されるのを防ぐ。0.15.0 から）
      */
     readonly cutoff?: string;
 }
@@ -195,7 +202,10 @@ export interface Calendar<Kind extends string = string> extends HolidayLookup<Ki
     nextBusinessDay(input: DateInput): DateString;
     /** 前営業日（入力日の前日以前） */
     previousBusinessDay(input: DateInput): DateString;
-    /** 入力日が営業日ならその日、そうでなければ翌営業日。cutoff で締め時刻を指定できる */
+    /**
+     * 入力日が営業日ならその日、そうでなければ翌営業日。cutoff で締め時刻を指定できる
+     * （cutoff を指定するときの入力は、時刻を持つもの。時刻のない入力と組み合わせると invalid-argument）
+     */
     businessDayOnOrAfter(input: DateInput, options?: BusinessDayOptions): DateString;
     /** 入力日が営業日ならその日、そうでなければ前営業日 */
     businessDayOnOrBefore(input: DateInput): DateString;
@@ -227,6 +237,23 @@ export interface Calendar<Kind extends string = string> extends HolidayLookup<Ki
      * その月にない日は末日に読み替えてから調整する（例: 2 月の 30 日払いは 2 月末日）
      */
     dueDate(month: MonthString, options: DueDateOptions): DateString;
+    /**
+     * 営業日を考慮した締め日で区切ったときに、日付が属する月。
+     * 各月の締め日（締め日がその月にない場合は末日）を convention で営業日に調整した日を D(m) とし、
+     * 日付が D(m) 以下となる最小の m を返す。前月の締め日から当月の締め日までに営業日がない月（長期休業）は
+     * 固有の期間を持たず、その日は次の月に属する
+     */
+    closingMonth(input: DateInput, closingDay: number, options: AdjustOptions): MonthString;
+    /**
+     * 営業日を考慮した締め日で区切ったときの、その月分の期間（両端を含む暦日。前月の調整後の締め日の翌日から
+     * 当月の調整後の締め日まで）。暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+     * 月を渡して、その月に固有の期間がない（前月の締め日から当月の締め日までに営業日がない）ときは
+     * code: "no-business-day" の Error。返す値は変更できず、name は付かない
+     */
+    closingPeriod(input: DateInput | MonthString, closingDay: number, options: AdjustOptions): {
+        readonly from: DateString;
+        readonly to: DateString;
+    };
 }
 interface CompiledCalendar<Kind extends string> {
     readonly schedule: CompiledSchedule<boolean, Kind>;
@@ -247,7 +274,8 @@ export declare function createCalendar<Kind extends string = string>(options?: C
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
  * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
- *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ *   その番号を decidedBy で返す。入れ子の合成では、内側の番号まで含めた列を decidedByPath で返す。
+ *   holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
  * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、

package/dist/core/calendar.js

@@ -21,7 +21,7 @@
 import { addDays, daysInMonth, formatDate, fromDayNumber, toDayNumber, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
 import { parseTimeOfDay, toCivil } from "./input.js";
-import { dayOfMonth, isDayOfMonthValue, parseMonth } from "./month.js";
+import { checkClosingDay, closingDayIn, closingMonth as calendarClosingMonth, dayOfMonth, formatMonth, isDayOfMonthValue, parseMonth, shiftMonth, } from "./month.js";
 import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, infoOfSchedule, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
@@ -181,6 +181,23 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         "modified-following",
         "modified-preceding",
     ];
+    /** 月 m の、営業日に調整した締め日 D(m)（decisions.md の 41 番） */
+    function closingDate(month, closingDay, options) {
+        return adjustDate(dayOfMonth(month, closingDayIn(month, closingDay)), options);
+    }
+    /** 営業日を考慮した締め日で日付が属する月（date ≤ D(m) となる最小の m）。暦日の締めの月の前月から順に調べる */
+    function closingMonthOf(date, closingDay, options) {
+        checkClosingDay(closingDay);
+        let month = parseMonth(calendarClosingMonth(date, closingDay));
+        // D は月とともに単調に増える（減らない）ので、暦日の締めの月から、後ろへ（following で前月の締め日が
+        // 長期休業を越えて当月以降に来た場合）、前へ（preceding で当月の締め日が date より前に来た場合）順に探す
+        while (date <= closingDate(shiftMonth(month, -1), closingDay, options)) {
+            month = shiftMonth(month, -1);
+        }
+        while (date > closingDate(month, closingDay, options))
+            month = shiftMonth(month, 1);
+        return month;
+    }
     function adjustDate(date, options) {
         const convention = options?.convention;
         if (!CONVENTIONS.includes(convention)) {
@@ -265,7 +282,10 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
             let start = civil.date;
             if (opts.cutoff !== undefined) {
                 const cutoff = parseTimeOfDay(opts.cutoff);
-                if (civil.minutes !== null && civil.minutes >= cutoff)
+                if (civil.minutes === null) {
+                    throw rangeError("invalid-argument", "cutoff requires an input with a time of day (a Date, a date-time string or a Temporal value with a time); a date-only input would silently ignore the cutoff");
+                }
+                if (civil.minutes >= cutoff)
                     start = addDays(start, 1);
             }
             return search(start, 1);
@@ -305,6 +325,21 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         nthBusinessDayOfMonth: nthOfMonth,
         firstBusinessDayOfMonth: (month) => nthOfMonth(month, 1),
         lastBusinessDayOfMonth: (month) => nthOfMonth(month, -1),
+        closingMonth: (input, closingDay, options) => formatMonth(closingMonthOf(dateOf(input), closingDay, options)),
+        closingPeriod(input, closingDay, options) {
+            checkClosingDay(closingDay);
+            // "YYYY-MM" だけを月として扱い、それ以外（暦日・日時の文字列・Date・Temporal の値）は dateOf で暦日にする
+            const isMonth = typeof input === "string" && /^\d{4}-\d{2}$/.test(input);
+            const month = isMonth
+                ? parseMonth(input)
+                : closingMonthOf(dateOf(input), closingDay, options);
+            const to = closingDate(month, closingDay, options);
+            const from = addDays(closingDate(shiftMonth(month, -1), closingDay, options), 1);
+            if (from > to) {
+                throw rangeError("no-business-day", `${formatMonth(month)} has no closing period of its own: there is no business day between the previous closing day and ${to} (its days belong to the next month)`);
+            }
+            return Object.freeze({ from, to });
+        },
         dueDate(month, options) {
             const day = options?.day;
             if (!isDayOfMonthValue(day)) {
@@ -326,7 +361,8 @@ const isCalendarLike = (v) => typeof v === "object" &&
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
  * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
- *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ *   その番号を decidedBy で返す。入れ子の合成では、内側の番号まで含めた列を decidedByPath で返す。
+ *   holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
  * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、
@@ -391,6 +427,8 @@ export function combineCalendars(calendars, options) {
         if (base.rulePath !== undefined)
             result.rulePath = base.rulePath;
         result.decidedBy = decidedBy;
+        // 内側が合成したカレンダーなら、その経路の前に自分の番号を付ける（入れ子でなければ長さ 1）
+        result.decidedByPath = Object.freeze([decidedBy, ...(base.decidedByPath ?? [])]);
         return Object.freeze(result);
     }
     return buildCalendar(lookup, isOpen, info, maxSearchDays);

package/dist/core/date.d.ts

@@ -52,3 +52,8 @@ export declare function diffDays(from: DateString, to: DateString): number;
 export declare function weekdayOf(date: DateString): Weekday;
 /** その月の第 n 何曜日（n は 1 始まり） */
 export declare function nthWeekdayOfMonth(year: number, month: number, weekday: Weekday, n: number): DateString;
+/**
+ * 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm）。英国の祝日の計算に使い、提供元の実装者向けに
+ * bizdays-toolkit/provider からも公開する（入力の検証はそちらで行う）
+ */
+export declare function easterSunday(year: number): DateString;

package/dist/core/date.js

@@ -99,3 +99,24 @@ export function nthWeekdayOfMonth(year, month, weekday, n) {
     const offset = (weekday - weekdayOf(formatDate(year, month, 1)) + 7) % 7;
     return formatDate(year, month, 1 + offset + (n - 1) * 7);
 }
+/**
+ * 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm）。英国の祝日の計算に使い、提供元の実装者向けに
+ * bizdays-toolkit/provider からも公開する（入力の検証はそちらで行う）
+ */
+export function easterSunday(year) {
+    const a = year % 19;
+    const b = Math.floor(year / 100);
+    const c = year % 100;
+    const d = Math.floor(b / 4);
+    const e = b % 4;
+    const f = Math.floor((b + 8) / 25);
+    const g = Math.floor((b - f + 1) / 3);
+    const h = (19 * a + b - d - g + 15) % 30;
+    const i = Math.floor(c / 4);
+    const k = c % 4;
+    const l = (32 + 2 * e + 2 * i - h - k) % 7;
+    const m = Math.floor((a + 11 * h + 22 * l) / 451);
+    const month = Math.floor((h + l - 7 * m + 114) / 31);
+    const day = ((h + l - 7 * m + 114) % 31) + 1;
+    return formatDate(year, month, day);
+}

package/dist/core/diagnose.d.ts

@@ -8,7 +8,7 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日、など）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則

package/dist/core/diagnose.js

@@ -8,7 +8,7 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日、など）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則
@@ -360,7 +360,7 @@ function analyze(c, compiled, isCalendar) {
     });
     // --- 繰り返しの規則: 当てはまる日がない・覆われている ---
     const recurringBits = recurring.map(patternBits);
-    /** 祝日・祝日の翌日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
+    /** 祝日・祝日の翌日・祝前日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
     const holidayOfSafe = (date) => {
         try {
             return lookup.holidayOn(date);
@@ -369,7 +369,7 @@ function analyze(c, compiled, isCalendar) {
             return undefined;
         }
     };
-    /** 祝日に従属する規則（祝日・祝日の翌日）が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
+    /** 祝日に従属する規則（祝日・祝日の翌日・祝前日）が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
     const holidayRuleMatches = (rule) => {
         if (source.providers.length === 0 || !window)
             return false;
@@ -381,7 +381,7 @@ function analyze(c, compiled, isCalendar) {
     const setCovers = (a, b) => a === null || (b !== null && [...b].every((v) => a.has(v)));
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
-        const holidayBased = rule.holiday || rule.dayAfterHoliday;
+        const holidayBased = rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday;
         const matches = holidayBased ? holidayRuleMatches(rule) : matchesAnyDay(rule, cycle);
         if (!matches) {
             unused.add(rule);
@@ -389,23 +389,32 @@ function analyze(c, compiled, isCalendar) {
                 ? source.providers.length === 0
                     ? "This rule matches no day: there are no holidays without a holiday provider"
                     : rule.holiday
-                        ? "This rule matches no day: no holiday of the selected kinds within the selected months and effective period"
-                        : "This rule matches no day: no day after a holiday within its effective period"
+                        ? "This rule matches no day: no holiday of the selected kinds, weekdays and months within its effective period"
+                        : rule.dayAfterHoliday
+                            ? "This rule matches no day: no day after a holiday on the selected weekdays and months within its effective period"
+                            : "This rule matches no day: no day before a holiday on the selected weekdays and months within its effective period"
                 : rule.effectiveFrom === null && rule.effectiveTo === null
                     ? "This rule matches no day (for example, a day that does not exist in the selected months)"
                     : "This rule matches no day within its effective period");
             return;
         }
-        // 祝日・祝日の翌日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・月の絞り込み）だけで調べる
+        // 祝日・祝日の翌日・祝前日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・曜日・月の絞り込み）だけで調べる
         const k = recurring.findIndex((r, i) => i < j &&
             canCover(r, rule) &&
             periodCovers(r, rule) &&
             (rule.holiday
-                ? r.holiday && setCovers(r.kinds, rule.kinds) && setCovers(r.months, rule.months)
-                : rule.dayAfterHoliday
-                    ? r.dayAfterHoliday && setCovers(r.months, rule.months)
+                ? r.holiday &&
+                    setCovers(r.kinds, rule.kinds) &&
+                    setCovers(r.weekdays, rule.weekdays) &&
+                    setCovers(r.months, rule.months)
+                : rule.dayAfterHoliday || rule.dayBeforeHoliday
+                    ? r.dayAfterHoliday === rule.dayAfterHoliday &&
+                        r.dayBeforeHoliday === rule.dayBeforeHoliday &&
+                        setCovers(r.weekdays, rule.weekdays) &&
+                        setCovers(r.months, rule.months)
                     : !r.holiday &&
                         !r.dayAfterHoliday &&
+                        !r.dayBeforeHoliday &&
                         intervalCovers(r, rule) &&
                         isSubset(bits, recurringBits[i])));
         if (k < 0)

package/dist/core/input.js

@@ -10,7 +10,8 @@
  */
 import { formatDate, parseDate } from "./date.js";
 import { rangeError, typeError } from "./errors.js";
-const DATETIME_RE = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:?\d{2})?$/i;
+// 日付と時刻の区切りは "T" だけ（型 DateTimeInput と同じ）。空白で区切った文字列は 0.16.0 から invalid-time
+const DATETIME_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:?\d{2})?$/i;
 const formatters = new Map();
 function formatterFor(timeZone) {
     let f = formatters.get(timeZone);

package/dist/core/month.d.ts

@@ -48,6 +48,10 @@ export declare function monthOf(input: DateString | MonthString, offset?: number
  * @public
  */
 export declare function closingMonth(date: DateString, closingDay: number): MonthString;
+/** @internal 締め日の検証（closingMonth・closingPeriod・営業日カレンダーの締め日で共用） */
+export declare function checkClosingDay(closingDay: number): void;
+/** @internal その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+export declare function closingDayIn({ year, month }: YearMonth, closingDay: number): number;
 /**
  * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
  *

package/dist/core/month.js

@@ -71,13 +71,14 @@ export function closingMonth(date, closingDay) {
     const { year, month, day } = parseDate(date);
     return formatMonth(shiftMonth({ year, month }, day <= closingDayIn({ year, month }, closingDay) ? 0 : 1));
 }
-function checkClosingDay(closingDay) {
+/** @internal 締め日の検証（closingMonth・closingPeriod・営業日カレンダーの締め日で共用） */
+export function checkClosingDay(closingDay) {
     if (!isDayOfMonthValue(closingDay)) {
         throw rangeError("invalid-argument", `closingDay must be an integer from 1 to 31, or -1 (last day): ${closingDay}`);
     }
 }
-/** その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
-function closingDayIn({ year, month }, closingDay) {
+/** @internal その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+export function closingDayIn({ year, month }, closingDay) {
     const last = daysInMonth(year, month);
     return closingDay === -1 || closingDay > last ? last : closingDay;
 }

package/dist/core/schedule.d.ts

@@ -13,6 +13,7 @@
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
  * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝前日の規則（dayBeforeHoliday）は、翌日が祝日でその日自身は祝日でない日に当てはまる（同じく提供元の祝日だけ）。
  * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
@@ -90,7 +91,10 @@ export interface WeekdayPattern {
     readonly months?: readonly Month[];
     readonly day?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
 }
 /**
  * 毎月の日の繰り返し（例: 毎月 20 日、毎月末日）。その月にない日（2 月 30 日など）は当てはまらない。
@@ -106,7 +110,10 @@ export interface DayOfMonthPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
 }
 /**
  * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
@@ -115,6 +122,8 @@ export interface DayOfMonthPattern {
  */
 export interface DayAfterHolidayPattern {
     readonly dayAfterHoliday: true;
+    /** 当てはめる曜日（翌日の曜日。省略時はすべての曜日。例: [1, 2, 3, 4, 5] で土日に当たる翌日は除く） */
+    readonly weekdays?: readonly Weekday[];
     /** 当てはめる月（翌日の月。省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly weekday?: never;
@@ -122,7 +131,30 @@ export interface DayAfterHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
+    readonly kinds?: never;
+}
+/**
+ * 祝前日（翌日が祝日で、その日自身は祝日でない日。連休なら連休の初日の前日）。「祝日」は提供元の祝日だけ。
+ * 祝日の翌日（dayAfterHoliday）の鏡像で、祝前日料金・祝前日の営業時間の延長・締め時刻の繰り上げなどを規則として書く。
+ * 当てはまる日は祝日でないので、onHolidayRule は指定できない（指定すると invalid-option）。
+ * @public
+ */
+export interface DayBeforeHolidayPattern {
+    readonly dayBeforeHoliday: true;
+    /** 当てはめる曜日（祝前日の曜日。省略時はすべての曜日。例: [1, 2, 3, 4, 5] で土日に当たる祝前日は除く） */
+    readonly weekdays?: readonly Weekday[];
+    /** 当てはめる月（祝前日の月。省略時はすべての月） */
+    readonly months?: readonly Month[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly day?: never;
+    readonly dayAfterHoliday?: never;
+    readonly holiday?: never;
+    readonly kinds?: never;
 }
 /**
  * 祝日（提供元の祝日である日）。kinds で祝日の種別を絞れる（省略時はすべての祝日）。
@@ -131,10 +163,12 @@ export interface DayAfterHolidayPattern {
  * 当てはまる日は祝日なので、onHolidayRule は指定できない（指定すると invalid-option）。
  * @public
  */
-export interface HolidayPattern {
+export interface HolidayPattern<Kind extends string = string> {
     readonly holiday: true;
-    /** 当てはめる祝日の種別（Holiday.kind。省略時はすべて） */
-    readonly kinds?: readonly string[];
+    /** 当てはめる祝日の種別（Holiday.kind。省略時はすべて）。提供元の種別の型で補完が効く（型は開いているので他の文字列も通る） */
+    readonly kinds?: readonly Kind[];
+    /** 当てはめる曜日（省略時はすべての曜日。例: [6] で土曜の祝日だけ） */
+    readonly weekdays?: readonly Weekday[];
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly weekday?: never;
@@ -143,17 +177,18 @@ export interface HolidayPattern {
     readonly anchor?: never;
     readonly day?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | HolidayPattern;
+export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
  */
-export type RecurringRule = RecurringPattern & EffectivePeriod & {
+export type RecurringRule<Kind extends string = string> = RecurringPattern<Kind> & EffectivePeriod & {
     readonly name?: string;
     /** 祝日に当たったときの扱い（既定: "under-holiday"） */
     readonly onHolidayRule?: OnHolidayRule;
@@ -162,7 +197,7 @@ export type RecurringRule = RecurringPattern & EffectivePeriod & {
  * 繰り返しの規則の値（スケジュールの recurring）。
  * @public
  */
-export type RecurringValue<T> = RecurringRule & {
+export type RecurringValue<T, Kind extends string = string> = RecurringRule<Kind> & {
     readonly value: T;
 };
 /**
@@ -228,7 +263,7 @@ export interface ScheduleOptions<T, Kind extends string = string> extends Holida
     /** 祝日の値の決め方（既定: "weekday"） */
     readonly holiday?: HolidayValueRule<T>;
     /** 繰り返しの規則（毎週・毎月の第 n 曜日・毎月の日）の値 */
-    readonly recurring?: readonly RecurringValue<T>[];
+    readonly recurring?: readonly RecurringValue<T, Kind>[];
     /** 毎年の月日の値 */
     readonly annual?: readonly (AnnualValue<T> | AnnualRangeValue<T>)[];
     /** 個別の日付の値 */
@@ -366,10 +401,14 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly days: ReadonlySet<number> | null;
     /** 祝日の翌日の規則か */
     readonly dayAfterHoliday: boolean;
+    /** 祝前日の規則か */
+    readonly dayBeforeHoliday: boolean;
     /** 祝日の規則か */
     readonly holiday: boolean;
     /** 祝日の規則で絞る種別（null はすべての祝日） */
     readonly kinds: ReadonlySet<string> | null;
+    /** 祝日・祝日の翌日・祝前日の規則で絞る曜日（null はすべての曜日） */
+    readonly weekdays: ReadonlySet<number> | null;
     /** 月の集合（null はすべての月） */
     readonly months: ReadonlySet<number> | null;
     readonly onHolidayRule: OnHolidayRule;
@@ -378,12 +417,12 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
 }
 /** @internal 繰り返しの規則を検証して取り込む */
 export declare function compileRecurringRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, keys: readonly string[]): RecurringRuleCompiled<T>[];
-/** @internal その日の祝日を返す関数（祝日・祝日の翌日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
+/** @internal その日の祝日を返す関数（祝日・祝日の翌日・祝前日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
 export type HolidayOf = (date: DateString) => Holiday<string> | undefined;
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
  */
 export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf): boolean;
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */

package/dist/core/schedule.js

@@ -13,6 +13,7 @@
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
  * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝前日の規則（dayBeforeHoliday）は、翌日が祝日でその日自身は祝日でない日に当てはまる（同じく提供元の祝日だけ）。
  * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
@@ -211,9 +212,15 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const hasWeekday = "weekday" in entry;
         const hasDay = "day" in entry;
         const hasAfter = "dayAfterHoliday" in entry;
+        const hasBefore = "dayBeforeHoliday" in entry;
         const hasHoliday = "holiday" in entry;
-        if (Number(hasWeekday) + Number(hasDay) + Number(hasAfter) + Number(hasHoliday) !== 1) {
-            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday" or "holiday"');
+        if (Number(hasWeekday) +
+            Number(hasDay) +
+            Number(hasAfter) +
+            Number(hasBefore) +
+            Number(hasHoliday) !==
+            1) {
+            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
             return;
         }
         let kinds = null;
@@ -281,7 +288,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                     ok = false;
             }
             else {
-                const key = hasAfter ? "dayAfterHoliday" : "holiday";
+                const key = hasAfter ? "dayAfterHoliday" : hasBefore ? "dayBeforeHoliday" : "holiday";
                 if (entry[key] !== true) {
                     c.error("invalid-option", `${p}.${key}`, "must be true");
                     ok = false;
@@ -289,7 +296,9 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 if ("onHolidayRule" in entry) {
                     c.error("invalid-option", `${p}.onHolidayRule`, hasAfter
                         ? 'cannot be used with "dayAfterHoliday" (the day after a holiday is never a holiday)'
-                        : 'cannot be used with "holiday" (the rule applies on holidays; it is judged before holidayPolicy)');
+                        : hasBefore
+                            ? 'cannot be used with "dayBeforeHoliday" (the day before a holiday is never a holiday)'
+                            : 'cannot be used with "holiday" (the rule applies on holidays; it is judged before holidayPolicy)');
                     ok = false;
                 }
                 if (hasHoliday && entry["kinds"] !== undefined && !Array.isArray(entry["kinds"])) {
@@ -309,6 +318,24 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
             c.error("invalid-option", `${p}.kinds`, '"kinds" can be used only with "holiday"');
             ok = false;
         }
+        let weekdays = null;
+        if ("weekdays" in entry) {
+            if (!hasHoliday && !hasAfter && !hasBefore) {
+                c.error("invalid-option", `${p}.weekdays`, '"weekdays" can be used only with "holiday", "dayAfterHoliday" or "dayBeforeHoliday"');
+                ok = false;
+            }
+            else if (!Array.isArray(entry["weekdays"])) {
+                c.error("invalid-option", `${p}.weekdays`, "must be a non-empty array of weekdays (0 = Sunday to 6 = Saturday)");
+                ok = false;
+            }
+            else {
+                const set = checkSet(c, `${p}.weekdays`, entry["weekdays"], isWeekday, "a weekday (0 = Sunday to 6 = Saturday)");
+                if (set)
+                    weekdays = set;
+                else
+                    ok = false;
+            }
+        }
         let months = null;
         if (entry["months"] !== undefined) {
             if (!Array.isArray(entry["months"])) {
@@ -339,8 +366,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 anchor,
                 days,
                 dayAfterHoliday: hasAfter,
+                dayBeforeHoliday: hasBefore,
                 holiday: hasHoliday,
                 kinds,
+                weekdays,
                 months,
                 onHolidayRule: onHoliday,
                 value,
@@ -352,22 +381,27 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
     return rules;
 }
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
  */
 export function matchPattern(rule, date, holidayOf) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
-    if (rule.holiday) {
-        const h = holidayOf?.(date);
-        return h !== undefined && (rule.kinds === null || rule.kinds.has(h.kind));
-    }
-    if (rule.dayAfterHoliday) {
-        return (holidayOf !== undefined &&
-            holidayOf(date) === undefined &&
-            holidayOf(addDays(date, -1)) !== undefined);
+    if (rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday) {
+        if (holidayOf === undefined)
+            return false;
+        if (rule.weekdays && !rule.weekdays.has(weekdayOf(date)))
+            return false;
+        if (rule.holiday) {
+            const h = holidayOf(date);
+            return h !== undefined && (rule.kinds === null || rule.kinds.has(h.kind));
+        }
+        // 祝日の翌日は前日が祝日、祝前日は翌日が祝日（どちらもその日自身は祝日でない）
+        if (holidayOf(date) !== undefined)
+            return false;
+        return holidayOf(addDays(date, rule.dayAfterHoliday ? -1 : 1)) !== undefined;
     }
     const dim = daysInMonth(year, month);
     if (rule.weekday !== null) {
@@ -617,8 +651,10 @@ export const RECURRING_RULE_KEYS = [
     "anchor",
     "day",
     "dayAfterHoliday",
+    "dayBeforeHoliday",
     "holiday",
     "kinds",
+    "weekdays",
     "months",
     "name",
     "onHolidayRule",

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
 export { combineCalendars, createCalendar, createCalendarFromSchedule, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, type CombineOptions, type DateRange, type DayInfo, type DayReason, type DueDateOptions, type HolidayPolicy, type KnownDayReason, type SpecificDate, } from "./core/calendar.ts";
-export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
+export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayBeforeHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
 export { closingMonth, closingPeriod, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";

package/dist/provider/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 祝日の提供元（HolidayProvider）を実装する人向けの暦の計算（bizdays-toolkit/provider）。
+ *
+ * 多くの国・地域の祝日は「月の第 n 何曜日」（米国の連邦祝日など）と「復活祭からの日数」（ヨーロッパの多くの国）で
+ * 書ける。この 2 種類の計算と、月の日数・うるう年の判定を、ライブラリ内部で使っている実装のまま公開する
+ * （復活祭の計算は英国の祝日で GOV.UK のデータと照合済み）。ルートの addDays・weekdayOf と組み合わせて使う。
+ * 同梱の提供元の実装とは別に、アプリの本体に不要なものが入らないようサブパスに分けている。
+ *
+ * 公開する関数は @beta（マイナー版で変わりうる）。使われ方が固まったら @public にする。
+ */
+import { type DateString, type Weekday } from "../core/date.ts";
+/**
+ * 復活祭の日曜日（グレゴリオ暦）。Good Friday は −2 日、Easter Monday は +1 日、Ascension は +39 日、
+ * Whit Monday は +50 日、Corpus Christi は +60 日（ルートの addDays で求める）。
+ * 年は 1000〜9999 の整数（それ以外は invalid-argument）。
+ * @beta
+ */
+export declare function easterSunday(year: number): DateString;
+/**
+ * その月の第 n 何曜日（n は 1〜5、-1 は最後。曜日は 0 = 日曜日〜6 = 土曜日）。
+ * 例: 1 月の第 3 月曜日は nthWeekdayOfMonth(2026, 1, 1, 3)、5 月の最終月曜日は nthWeekdayOfMonth(2026, 5, 1, -1)。
+ * その月に n 回目のその曜日がないとき（第 5 回目）は invalid-argument。
+ * @beta
+ */
+export declare function nthWeekdayOfMonth(year: number, month: number, weekday: Weekday, n: number): DateString;
+/**
+ * その月の日数（28〜31）。
+ * @beta
+ */
+export declare function daysInMonth(year: number, month: number): number;
+/**
+ * うるう年か（グレゴリオ暦）。
+ * @beta
+ */
+export declare function isLeapYear(year: number): boolean;

package/dist/provider/index.js

@@ -0,0 +1,76 @@
+/**
+ * 祝日の提供元（HolidayProvider）を実装する人向けの暦の計算（bizdays-toolkit/provider）。
+ *
+ * 多くの国・地域の祝日は「月の第 n 何曜日」（米国の連邦祝日など）と「復活祭からの日数」（ヨーロッパの多くの国）で
+ * 書ける。この 2 種類の計算と、月の日数・うるう年の判定を、ライブラリ内部で使っている実装のまま公開する
+ * （復活祭の計算は英国の祝日で GOV.UK のデータと照合済み）。ルートの addDays・weekdayOf と組み合わせて使う。
+ * 同梱の提供元の実装とは別に、アプリの本体に不要なものが入らないようサブパスに分けている。
+ *
+ * 公開する関数は @beta（マイナー版で変わりうる）。使われ方が固まったら @public にする。
+ */
+import { daysInMonth as daysInMonthOf, easterSunday as easterSundayOf, formatDate, isLeapYear as isLeapYearOf, nthWeekdayOfMonth as nthWeekdayOfMonthIn, weekdayOf, } from "../core/date.js";
+import { rangeError } from "../core/errors.js";
+function checkYear(year) {
+    if (!Number.isInteger(year) || year < 1000 || year > 9999) {
+        throw rangeError("invalid-argument", `year must be an integer from 1000 to 9999: ${String(year)}`);
+    }
+}
+function checkMonth(month) {
+    if (!Number.isInteger(month) || month < 1 || month > 12) {
+        throw rangeError("invalid-argument", `month must be an integer from 1 to 12: ${String(month)}`);
+    }
+}
+/**
+ * 復活祭の日曜日（グレゴリオ暦）。Good Friday は −2 日、Easter Monday は +1 日、Ascension は +39 日、
+ * Whit Monday は +50 日、Corpus Christi は +60 日（ルートの addDays で求める）。
+ * 年は 1000〜9999 の整数（それ以外は invalid-argument）。
+ * @beta
+ */
+export function easterSunday(year) {
+    checkYear(year);
+    return easterSundayOf(year);
+}
+/**
+ * その月の第 n 何曜日（n は 1〜5、-1 は最後。曜日は 0 = 日曜日〜6 = 土曜日）。
+ * 例: 1 月の第 3 月曜日は nthWeekdayOfMonth(2026, 1, 1, 3)、5 月の最終月曜日は nthWeekdayOfMonth(2026, 5, 1, -1)。
+ * その月に n 回目のその曜日がないとき（第 5 回目）は invalid-argument。
+ * @beta
+ */
+export function nthWeekdayOfMonth(year, month, weekday, n) {
+    checkYear(year);
+    checkMonth(month);
+    if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) {
+        throw rangeError("invalid-weekday", `weekday must be an integer from 0 (Sunday) to 6 (Saturday): ${String(weekday)}`);
+    }
+    if (!Number.isInteger(n) || n === 0 || n < -1 || n > 5) {
+        throw rangeError("invalid-argument", `n must be an integer from 1 to 5, or -1 (last): ${String(n)}`);
+    }
+    const days = daysInMonthOf(year, month);
+    if (n === -1) {
+        const last = formatDate(year, month, days);
+        const offset = (weekdayOf(last) - weekday + 7) % 7;
+        return formatDate(year, month, days - offset);
+    }
+    const first = ((weekday - weekdayOf(formatDate(year, month, 1)) + 7) % 7) + 1;
+    if (first + (n - 1) * 7 > days) {
+        throw rangeError("invalid-argument", `${year}-${String(month).padStart(2, "0")} has no ${n}th weekday ${weekday}`);
+    }
+    return nthWeekdayOfMonthIn(year, month, weekday, n);
+}
+/**
+ * その月の日数（28〜31）。
+ * @beta
+ */
+export function daysInMonth(year, month) {
+    checkYear(year);
+    checkMonth(month);
+    return daysInMonthOf(year, month);
+}
+/**
+ * うるう年か（グレゴリオ暦）。
+ * @beta
+ */
+export function isLeapYear(year) {
+    checkYear(year);
+    return isLeapYearOf(year);
+}

package/dist/uk/rules.d.ts

@@ -10,7 +10,6 @@
  * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
  * 規則による予測（confirmed: false）。
  */
-import { type DateString } from "../core/date.ts";
 import type { Holiday } from "../core/types.ts";
 /**
  * 英国の祝日の種別（既知の値）。
@@ -40,7 +39,5 @@ export declare const SUPPORTED_YEARS: Readonly<{
 export declare const CONFIRMED_THROUGH = 2028;
 /** @internal 反映済みの GOV.UK のデータの年月（2026 年の Scotland の World Cup bank holiday の追加） */
 export declare const DATA_VERSION = "2026-02";
-/** @internal 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm） */
-export declare function easterSunday(year: number): DateString;
 /** @internal その年・区分の祝日（日付順） */
 export declare function computeUkHolidays(division: UkDivision, year: number): Holiday<UkHolidayKind>[];

package/dist/uk/rules.js

@@ -10,7 +10,7 @@
  * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
  * 規則による予測（confirmed: false）。
  */
-import { addDays, daysInMonth, formatDate, nthWeekdayOfMonth, weekdayOf, } from "../core/date.js";
+import { addDays, daysInMonth, easterSunday, formatDate, nthWeekdayOfMonth, weekdayOf, } from "../core/date.js";
 import { rangeError } from "../core/errors.js";
 /** @internal 対応年 */
 export const SUPPORTED_YEARS = Object.freeze({ from: 2012, to: 2099 });
@@ -62,24 +62,6 @@ const RENAMED = [
     { division: "scotland", date: "2023-01-02", name: NEW_YEAR, kind: "substitute" },
     { division: "scotland", date: "2023-01-03", name: SECOND_JANUARY, kind: "substitute" },
 ];
-/** @internal 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm） */
-export function easterSunday(year) {
-    const a = year % 19;
-    const b = Math.floor(year / 100);
-    const c = year % 100;
-    const d = Math.floor(b / 4);
-    const e = b % 4;
-    const f = Math.floor((b + 8) / 25);
-    const g = Math.floor((b - f + 1) / 3);
-    const h = (19 * a + b - d - g + 15) % 30;
-    const i = Math.floor(c / 4);
-    const k = c % 4;
-    const l = (32 + 2 * e + 2 * i - h - k) % 7;
-    const m = Math.floor((a + 11 * h + 22 * l) / 451);
-    const month = Math.floor((h + l - 7 * m + 114) / 31);
-    const day = ((h + l - 7 * m + 114) % 31) + 1;
-    return formatDate(year, month, day);
-}
 function lastMonday(year, month) {
     const last = formatDate(year, month, daysInMonth(year, month));
     return addDays(last, -((weekdayOf(last) - 1 + 7) % 7));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Holidays, business-day calendar and day-by-day schedules (e.g. store hours) with time zone support. Japanese holidays verified against the Cabinet Office data; UK bank holidays (England, Wales, Scotland, Northern Ireland) verified against GOV.UK. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK のデータで全日照合）",
   "keywords": [
     "bank-holidays",
@@ -50,6 +50,10 @@
       "types": "./dist/diagnose/index.d.ts",
       "default": "./dist/diagnose/index.js"
     },
+    "./provider": {
+      "types": "./dist/provider/index.d.ts",
+      "default": "./dist/provider/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {