bizdays-toolkit 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-10-17
+
+### Added
+
+- 英国の bank holidays の提供元を `bizdays-toolkit/uk` に追加した。地域ごとに `england`（`GB-ENG`）・`wales`（`GB-WLS`）・`scotland`（`GB-SCT`）・`northernIreland`（`GB-NIR`）の 4 つで、タイムゾーンは `Europe/London`、対応年は 2012〜2099 年。2012 年から GOV.UK が公表している最後の年（2028 年）までのすべての日付と名称が、GOV.UK のデータ（現在の `https://www.gov.uk/bank-holidays.json` と、それより前の年は GOV.UK の公式リポジトリ alphagov/calendars・alphagov/frontend の履歴）と一致することをテストで確かめている。それより後の年は規則による予測（`confirmed: false`）。GOV.UK では England と Wales が 1 つの区分だが、別の提供元にした（日付は現在同じ）。Wales の祝日には、GOV.UK のウェールズ語版の名称を `names.cy` に付ける。種別（`kind`）は `"regular"`（毎年の祝日。布告で移動した年を含む）・`"substitute"`（振替）・`"special"`（布告による臨時の祝日）で、型は `UkHolidayKind`・`KnownUkHolidayKind`・`UkHoliday`
+- `pnpm verify:govuk`（`scripts/verify-govuk.ts`）を追加した。GOV.UK の JSON とウェールズ語の名称（alphagov/frontend の翻訳ファイル）を取得し、ライブラリの計算結果・テスト用フィクスチャと照合する
+
+### Changed
+
+- 公式データの反映（法改正・官報公表・布告による祝日の新設・移動・臨時の祝日、春分・秋分の日の確定、GOV.UK の新しい年の公表）を、マイナー版ではなく**パッチ版**で公開する方針に改めた（RELEASING.md）。0.x の期間は `^0.8.0` が 0.9.0 を受け取らないため、マイナー版では臨時の祝日が利用者に届かない。パッチ版なら 0.x でも 1.0.0 以降でも、`^`・`~` のどちらの指定にも届く
+- README を英語を既定にした（`README.md`）。日本語版は `docs/README.ja.md` に移し、それぞれの冒頭に切り替えのリンクを置いた。npm に公開するファイルは変わらない（日本語版はパッケージに含めない。npm はルートの `README*` を `files` の指定にかかわらず含めるため、`docs/` に置く）。README に書いている minify + gzip のサイズを測り直し、日本の祝日込みを約 8.5KB から約 9.0KB に直した（0.7.0 までの記載が実際より小さかった）。英国の祝日込みは約 9.0KB
+
+### 開発
+
+- `bizdays-toolkit/uk` のサイズの上限（gzip 6,700 バイト）を `size-limits.json` に追加した（エントリーの追加。計測は 6,225 バイト）。README の minify + gzip のサイズは、ルートのすべてと国の提供元（`jp`、または英国の 4 つ）を読み込む入口を esbuild で bundle・minify して gzip で測った（ルート 7,394 バイト、日本 8,953 バイト、英国 9,043 バイト）
+- GOV.UK の bank holidays を毎日照合するワークフロー（`.github/workflows/govuk-watch.yml`）を追加した。差分があれば `pnpm verify:govuk` の結果と alphagov/frontend の該当ファイルの最新のコミットを本文にした issue（ラベル `govuk-data`）を立て、同じ issue が開いていれば内容が変わったときだけ本文を更新してコメントする。取得に失敗した場合も、監視が機能していないことを issue で知らせる。60 日間動きのないリポジトリで定期実行が止まらないよう、実行のたびにワークフローを有効化し直す。フィクスチャはワークフローでは更新せず、規則の修正と同じコミットで更新する
+- CI に、ワークフローを actionlint（1.7.12。版と SHA-256 を固定した公式のリリースを取得）で検査するジョブを追加した。`run:` のシェルスクリプトもランナーの shellcheck で検査する。ワークフローの誤りは `pnpm check` では見つからないため
+- CI・リリース・監視のワークフローの Node.js を 24.21.0 から 24.22.0 に、pnpm を 12.11.2 から 12.14.0 に上げた（手元の開発環境に合わせる）
+- `pnpm check`（`scripts/check-package.ts`）で、`README.md` と `docs/README.ja.md` の見出しの数（段ごと）とコードブロックの数が一致し、互いへの切り替えのリンクがあることを確かめるようにした
+- `pnpm check` が、パッケージの中身を `files` の指定からの推定ではなく、実際の `npm pack --dry-run --json` の結果で確かめるようにした（npm が指定にかかわらず含めるファイルを見落とさないため）。ルートに `README.ja.md` があれば失敗する
+
 ## [0.7.0] - 2026-10-16
 
 ### Added
@@ -158,7 +179,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.4.0...v0.5.0

package/README.md

@@ -14,31 +14,32 @@
   <img src="https://img.shields.io/badge/types-included-blue" alt="TypeScript types included">
 </p>
 
-祝日と、会社・店舗の休業日を組み合わせた営業日カレンダーです。
+<p align="center"><b>English</b> | <a href="https://github.com/inohan77/bizdays-toolkit/blob/main/docs/README.ja.md">日本語</a></p>
 
-- **日本の祝日を内閣府のデータで全日照合**: 1955 年〜官報公表済みの年まで、内閣府「国民の祝日」CSV のすべての日付と一致することをテストで確かめています（振替休日・国民の休日・皇室行事による休日・五輪特措法による移動を含む）
-- **繰り返しの規則**: 「第 3 水曜定休」「毎月末日は棚卸」「月曜休館（祝日の場合は翌平日）」のような規則を、祝日に当たったときの扱い（祝日に従う・祝日でも当てはめる・翌日に振り替える）とあわせて指定できます
-- **日ごとの値（営業時間など）**: 「火曜定休、祝日は日曜の営業時間、元日は休業、大晦日は短縮営業」のように、曜日・祝日・特定日で変わる値を同じ規則で引けます
-- **設定の診断**: `bizdays-toolkit/diagnose` の `diagnoseCalendar`・`diagnoseSchedule` が、決して使われない規則・取り除いても結果が変わらない規則・キーの打ち間違い・営業日が 1 日もない設定などを、例外を投げずに一覧で返します。テストに 1 行足せば、設定の変更で規則が死んでいないかを確かめられます
-- **月の期日**: 「20 日締め翌月 10 日払い（休業日なら翌営業日）」「月末の最終営業日」のような期日を、金融で使われる 4 つの調整方法（following・preceding・modified-following・modified-preceding）で計算します
-- **営業日の計算**: 定休日の曜日・毎年の休業日（年末年始のような年をまたぐ期間も可）・臨時休業日・臨時営業日と祝日を組み合わせ、「N 営業日後」「締め時刻を過ぎたら翌営業日」などを計算します
-- **タイムゾーンを間違えない**: `Date` などの瞬間は、カレンダーのタイムゾーン（日本は `Asia/Tokyo`）で暦日に変換してから判定します。UTC で動くサーバーでも、日本時間 0〜9 時が前日扱いになりません
-- **軽量・依存ゼロ**: minify + gzip で約 7.4KB（日本の祝日込みで約 8.5KB）。ESM・型定義同梱・`sideEffects: false` で、Node.js・ブラウザー・Edge ランタイムで動作します
-- **他の国・地域に拡張できる**: 祝日の提供元はインターフェース（`HolidayProvider`）で差し替えられます。現在は日本のみ同梱しています
+A business-day calendar that combines public holidays with company or store closures.
 
-[English](#english)
+- **Japanese holidays verified day by day against the Cabinet Office data**: from 1955 through the latest year announced in the Official Gazette, every date in the Cabinet Office "National Holidays" CSV is checked in the tests (substitute holidays, citizens' holidays, holidays for imperial ceremonies and the Olympic moves included)
+- **UK bank holidays verified day by day against GOV.UK**: choose England, Wales, Scotland or Northern Ireland. From 2012 through the last year GOV.UK has published, every date and name is checked against the GOV.UK data in the tests, and differences are watched daily
+- **Recurring rules**: rules such as "closed on the 3rd Wednesday", "stocktaking on the last day of the month" or "closed on Mondays (on the next weekday if Monday is a holiday)", together with what happens when they fall on a holiday (follow the holiday, apply anyway, or move to the next day)
+- **Day-by-day values (e.g. store hours)**: values that change by weekday, holiday and specific date, such as "closed on Tuesdays, Sunday hours on holidays, closed on New Year's Day, short hours on New Year's Eve", are looked up with the same rules
+- **Option diagnostics**: `diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` list rules that can never apply, rules whose removal changes nothing, typos in option keys, calendars with no business day and more, without throwing. One line in your tests keeps a change of settings from silently killing a rule
+- **Month-based due dates**: due dates such as "closing on the 20th, paid on the 10th of the next month (next business day if closed)" or "the last business day of the month", with the four adjustment conventions used in finance (following, preceding, modified-following, modified-preceding)
+- **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
+- **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 7.4 KB min+gzip (about 9.0 KB with Japanese holidays, about 9.0 KB with UK bank holidays). ESM, bundled types and `sideEffects: false`; runs on Node.js, browsers and edge runtimes
+- **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
-## インストール
+## Installation
 
 ```sh
 pnpm add bizdays-toolkit
 ```
 
-Node.js 22.12 以上。ESM のみですが、Node.js 22.12 以降は CommonJS からも `require()` で読み込めます。
+Node.js 22.12 or later. The package is ESM only, but Node.js 22.12 and later can also load it from CommonJS with `require()`.
 
-## 使い方
+## Usage
 
-### 祝日を調べる
+### Looking up holidays
 
 ```ts
 import { getHoliday, holidaysInYear, isHoliday } from "bizdays-toolkit/jp";
@@ -48,15 +49,46 @@ getHoliday("2026-09-22");
 // { date: "2026-09-22", name: "国民の休日", nameEn: "Citizens' Holiday", kind: "citizens", confirmed: true }
 holidaysInYear(2027);
 
-// 瞬間（Date）は日本時間で判定する
-isHoliday(new Date("2026-11-22T15:30:00Z")); // true（日本時間では 11/23）
+// Instants (Date) are evaluated in Japan time
+isHoliday(new Date("2026-11-22T15:30:00Z")); // true (Nov 23 in Japan time)
 ```
 
-`kind` は `national`（国民の祝日）・`substitute`（振替休日）・`citizens`（国民の休日）・`special`（皇室行事などによる休日）のいずれかです。
+`kind` is one of `national` (national holiday), `substitute` (substitute holiday), `citizens` (citizens' holiday, a day between two holidays) and `special` (holidays for imperial ceremonies and similar events).
 
-`confirmed` は、その日付が公式に確定しているかを表します。春分・秋分の日は前年 2 月の官報で確定するため、それより先の年は近似式による予測（`confirmed: false`）です。
+`confirmed` tells whether the date is officially fixed. The vernal and autumnal equinox days are fixed in the Official Gazette in February of the previous year, so later years are predictions from an approximation formula (`confirmed: false`).
 
-### 営業日カレンダー
+### UK bank holidays
+
+```ts
+import { createCalendar } from "bizdays-toolkit";
+import { england, northernIreland, scotland, wales } from "bizdays-toolkit/uk";
+
+const edinburgh = createCalendar({ holidays: scotland, closedWeekdays: [0, 6] });
+edinburgh.isBusinessDay("2026-01-02"); // false (2nd January)
+edinburgh.addBusinessDays("2026-06-12", 1); // "2026-06-16" (June 15 is the World Cup bank holiday)
+
+scotland.holidaysInYear(2026)[0];
+// { date: "2026-01-01", name: "New Year’s Day", nameEn: "New Year’s Day", kind: "regular", confirmed: true }
+wales.holidaysInYear(2026)[0]?.names; // { cy: "Dydd Calan" }
+
+// Across several regions, use the union (a holiday in any of them is a holiday)
+const ukWide = createCalendar({ holidays: [england, scotland, northernIreland] });
+```
+
+| Provider          | ID       | GOV.UK division   | Notes                                            |
+| ----------------- | -------- | ----------------- | ------------------------------------------------ |
+| `england`         | `GB-ENG` | England and Wales |                                                  |
+| `wales`           | `GB-WLS` | England and Wales | Welsh names (`names.cy`) included                |
+| `scotland`        | `GB-SCT` | Scotland          | 2nd January, St Andrew’s Day and others          |
+| `northernIreland` | `GB-NIR` | Northern Ireland  | St Patrick’s Day, Battle of the Boyne and others |
+
+- `kind` is one of `regular` (an annual bank holiday, including years when a proclamation moved it), `substitute` (a substitute day for a bank holiday on a Saturday or Sunday) and `special` (a one-off bank holiday by proclamation, such as a jubilee or a state funeral). A substitute day has the name of the original holiday, as on GOV.UK
+- England and Wales are one division on GOV.UK and currently have the same dates, but they are separate providers, so your code keeps working if they ever differ
+- Supported years are 2012–2099. Years after the last year GOV.UK has published (`confirmedThrough`, currently 2028) are predictions from the rules (`confirmed: false`). One-off bank holidays are unknown until announced, so predicted years never contain them
+- Local holidays set by Scottish councils are not included. Whether a bank holiday is a day off depends on the employment contract and similar arrangements
+- One-off bank holidays may be announced only about ten days ahead. Differences from GOV.UK are watched daily and released as patch versions
+
+### Business-day calendars
 
 ```ts
 import { createCalendar } from "bizdays-toolkit";
@@ -64,97 +96,102 @@ import { jp } from "bizdays-toolkit/jp";
 
 const shipping = createCalendar({
   holidays: jp,
-  closedWeekdays: [0], // 日曜日（0 = 日曜 … 6 = 土曜）
-  closedAnnual: [{ from: "12-31", to: "01-03", name: "年末年始" }],
-  closedDates: [{ from: "2027-08-12", to: "2027-08-16", name: "夏季休業" }],
-  openDates: ["2026-12-27"], // 臨時営業日
-  holidayPolicy: "closed", // 祝日は休み（"open": 営業 / "ignore": 判定に使わない）
+  closedWeekdays: [0], // Sunday (0 = Sunday … 6 = Saturday)
+  closedAnnual: [{ from: "12-31", to: "01-03", name: "New Year closure" }],
+  closedDates: [{ from: "2027-08-12", to: "2027-08-16", name: "Summer closure" }],
+  openDates: ["2026-12-27"], // a specific open day
+  holidayPolicy: "closed", // closed on holidays ("open": open / "ignore": not used)
 });
 
-shipping.isBusinessDay("2026-11-23"); // false（勤労感謝の日）
+shipping.isBusinessDay("2026-11-23"); // false (Labor Thanksgiving Day)
 shipping.addBusinessDays("2026-12-30", 1); // "2027-01-04"
-shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // from 以上 to 未満の営業日数
+shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // business days from (inclusive) to (exclusive)
 
-// 14 時より前の注文は当日、それ以降は翌営業日に出荷
+// Orders before 14:00 ship today, later orders on the next business day
 shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
 
 shipping.dayInfo("2027-01-01");
-// { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "年末年始", holiday: {…} }
+// { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "New Year closure", holiday: {…} }
 ```
 
-1 日の判定は次の優先順位で行います（上が優先）。
+Each day is decided in this order of priority (top first).
 
-1. `openDates`（臨時営業日）
-2. `closedDates`（臨時休業日）
-3. `closedAnnual`（毎年の休業日）
-4. `openRecurring`・`closedRecurring` のうち `onHolidayRule: "over-holiday"` の規則（祝日でも当てはめる）
-5. 祝日（`holidayPolicy` に従う。`"open"` は定休日の曜日より優先して営業日にする）
-6. `openRecurring`・`closedRecurring`（既定の `"under-holiday"` と、`"after-holiday"` の振替先）
-7. `closedWeekdays`（定休日の曜日）
-8. それ以外は営業日
+1. `openDates` (specific open days)
+2. `closedDates` (specific closed days)
+3. `closedAnnual` (annual closures)
+4. `openRecurring` and `closedRecurring` rules with `onHolidayRule: "over-holiday"` (applied even on holidays)
+5. Holidays (according to `holidayPolicy`; `"open"` makes them business days even on closed weekdays)
+6. `openRecurring` and `closedRecurring` (the default `"under-holiday"`, and the days moved to by `"after-holiday"`)
+7. `closedWeekdays` (closed weekdays)
+8. Otherwise a business day
 
-この順番は固定です。繰り返しの規則と祝日の関係だけは、規則ごとに `onHolidayRule` で選べます（次の節）。
+This order is fixed. Only the relation between a recurring rule and holidays can be chosen per rule with `onHolidayRule` (next section).
 
-### 繰り返しの規則（毎週・毎月の第 n 曜日・毎月の日）
+### Recurring rules (weekly, nth weekday, day of month)
 
-「第 3 水曜定休」「第 2・第 4 土曜休業」「毎月末日は棚卸」「月曜休館（祝日の場合は翌平日）」のような繰り返しの休業日・営業日は、`closedRecurring`・`openRecurring` で指定します。
+Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "stocktaking on the last day of the month" or "closed on Mondays (on the next weekday if Monday is a holiday)" go in `closedRecurring` and `openRecurring`.
 
 ```ts
 const museum = createCalendar({
   holidays: jp,
-  holidayPolicy: "open", // 祝日は開館
+  holidayPolicy: "open", // open on holidays
   closedRecurring: [
-    { weekday: 1, name: "月曜休館", onHolidayRule: "after-holiday" }, // 祝日の場合は翌平日に休館
-    { weekday: 3, nth: 3, months: [2, 8], name: "2 月・8 月の第 3 水曜は臨時休館" },
-    { day: -1, name: "月末棚卸", onHolidayRule: "over-holiday" }, // 祝日でも休館
+    { weekday: 1, name: "Closed on Mondays", onHolidayRule: "after-holiday" }, // closed on the next weekday instead
+    {
+      weekday: 3,
+      nth: 3,
+      months: [2, 8],
+      name: "Closed on the 3rd Wednesday in February and August",
+    },
+    { day: -1, name: "Stocktaking", onHolidayRule: "over-holiday" }, // closed even on holidays
   ],
 });
 
-museum.isBusinessDay("2026-10-12"); // true（スポーツの日の月曜は開館）
+museum.isBusinessDay("2026-10-12"); // true (open on Monday, Sports Day)
 museum.dayInfo("2026-10-13");
 // { date: "2026-10-13", weekday: 2, businessDay: false, reason: "closed-recurring",
-//   name: "月曜休館", shiftedFrom: "2026-10-12" }
+//   name: "Closed on Mondays", shiftedFrom: "2026-10-12" }
 ```
 
-| 書き方                   | 意味                                                                            |
-| ------------------------ | ------------------------------------------------------------------------------- |
-| `{ weekday: 1 }`         | 毎週月曜日                                                                      |
-| `{ weekday: 3, nth: 3 }` | 第 3 水曜日。`nth` は 1〜5 と -1（最終）。`[2, 4]` のように配列で複数指定できる |
-| `{ day: 20 }`            | 毎月 20 日。`day` は 1〜31 と -1（末日）。配列で複数指定できる                  |
-| `months: [8, 12]`        | どの書き方にも付けられる、月の絞り込み                                          |
+| Pattern                  | Meaning                                                                               |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| `{ weekday: 1 }`         | Every Monday                                                                          |
+| `{ weekday: 3, nth: 3 }` | The 3rd Wednesday. `nth` is 1–5 or -1 (last); an array such as `[2, 4]` gives several |
+| `{ day: 20 }`            | The 20th of every month. `day` is 1–31 or -1 (last day); an array gives several       |
+| `months: [8, 12]`        | Narrows any pattern to these months                                                   |
 
-- **第 n 何曜日**は「その月で n 回目のその曜日」です（1〜7 日が第 1）。カレンダーの第 n 週の行にある曜日ではありません
-- **その月にない日**（`nth: 5` がない月、`day: 31` がない月）は当てはまりません。末日は `day: -1` で指定します
-- 繰り返しの規則どうしは配列で先に書いたものが優先で、`openRecurring` は `closedRecurring` より優先です
+- **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
+- Among recurring rules, the one written first in the array wins, and `openRecurring` wins over `closedRecurring`
 
-**祝日に当たったときの扱い**（`onHolidayRule`）は、規則ごとに選べます。
+**What happens on a holiday** (`onHolidayRule`) is chosen per rule.
 
-| 値                        | 意味                                                     | 店舗の告知での書き方                  |
-| ------------------------- | -------------------------------------------------------- | ------------------------------------- |
-| `"under-holiday"`（既定） | 祝日の下。祝日の扱い（`holidayPolicy`）に従う            | 「第 3 水曜定休（祝日の場合は営業）」 |
-| `"over-holiday"`          | 祝日の上。祝日でも当てはめる                             | 「第 3 水曜定休（祝日も休み）」       |
-| `"after-holiday"`         | 祝日の後。祝日には当てはめず、祝日でない翌日に振り替える | 「月曜休館（祝日の場合は翌平日）」    |
+| Value                       | Meaning                                                                   | How a store would announce it                           |
+| --------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------- |
+| `"under-holiday"` (default) | Under the holiday: follows the holiday handling (`holidayPolicy`)         | "Closed on the 3rd Wednesday (open if it is a holiday)" |
+| `"over-holiday"`            | Over the holiday: applies even on holidays                                | "Closed on the 3rd Wednesday (holidays included)"       |
+| `"after-holiday"`           | After the holiday: not applied on holidays, moved to the next non-holiday | "Closed on Mondays (on the next weekday if a holiday)"  |
 
-- `"under-holiday"` の規則は、`holidayPolicy: "ignore"`（祝日を判定に使わない）なら祝日にも当てはまります
-- `"after-holiday"` の振替先は「その日以降で最初の祝日でない日」です。祝日が続く場合（GW など）は連休が明けた日になります。振替先の日に臨時営業日・臨時休業日・毎年の休業日があれば、そちらが優先です。振替で決まった日の `dayInfo()` には、振替の元の日付 `shiftedFrom` が付きます
-- 振替の判断に使う「祝日」は、祝日の提供元（`jp` など）の祝日だけです（毎年の休業日などは含みません）
+- With `holidayPolicy: "ignore"` (holidays not used), `"under-holiday"` rules also apply on holidays
+- The day an `"after-holiday"` rule moves to is the first non-holiday on or after that day. After a run of holidays (such as Golden Week) it is the day after the run. Specific open or closed days and annual closures on that day take priority. `dayInfo()` for a moved day includes the original date as `shiftedFrom`
+- The "holidays" used for moving are only those of the holiday provider (such as `jp`), not annual closures
 
-スケジュールでは、同じ書き方の規則に `value` を付けて `recurring` に指定します。
+In a schedule, the same patterns with a `value` go in `recurring`.
 
 ```ts
 const hours = createSchedule<Hours>({
   holidays: jp,
   weekly: [sunday, weekday, weekday, weekday, weekday, weekday, weekday],
   recurring: [
-    { weekday: 1, value: null, name: "月曜休業", onHolidayRule: "after-holiday" },
-    { day: -1, value: { open: "10:00", close: "17:00" }, name: "月末は短縮営業" },
+    { 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" },
   ],
 });
 ```
 
-### よくある設定の例
+### Common recipes
 
-**国民の休日（祝日に挟まれた日）を営業日として扱う**：祝日の提供元を包んで、種別で除外します。
+**Treat citizens' holidays (days between two holidays) as business days**: wrap the holiday provider and filter by kind.
 
 ```ts
 import { jp } from "bizdays-toolkit/jp";
@@ -166,7 +203,7 @@ const jpWithoutCitizensHoliday = {
 const calendar = createCalendar({ holidays: jpWithoutCitizensHoliday, closedWeekdays: [0, 6] });
 ```
 
-**共通の設定から店舗ごとのカレンダーを作る**：設定は普通のオブジェクトなので、展開して足します。
+**Build per-store calendars from shared options**: options are plain objects, so spread and extend them.
 
 ```ts
 const base = {
@@ -178,9 +215,9 @@ const shibuya = createCalendar({ ...base, openDates: ["2026-12-27"] });
 const yokohama = createCalendar({ ...base, closedRecurring: [{ weekday: 3, nth: 3 }] });
 ```
 
-### 月の期日と日付の調整
+### Month-based due dates and date adjustment
 
-休業日に当たった日付を、指定した方法で営業日に調整します。月の第 n 営業日や、「毎月 n 日（休業日なら翌営業日）」のような期日も求められます。
+Dates that fall on closed days are adjusted to business days with the convention you choose. The nth business day of a month and due dates such as "the nth of every month (next business day if closed)" are also available.
 
 ```ts
 import { closingMonth, createCalendar, monthOf } from "bizdays-toolkit";
@@ -189,113 +226,113 @@ import { jp } from "bizdays-toolkit/jp";
 const calendar = createCalendar({
   holidays: jp,
   closedWeekdays: [0, 6],
-  closedAnnual: [{ from: "12-31", to: "01-03", name: "年末年始" }],
+  closedAnnual: [{ from: "12-31", to: "01-03", name: "New Year closure" }],
 });
 
-calendar.adjust("2026-10-31", { convention: "following" }); // "2026-11-02"（10/31 は土曜日）
-calendar.adjust("2026-10-31", { convention: "modified-following" }); // "2026-10-30"（月が変わるので前へ）
+calendar.adjust("2026-10-31", { convention: "following" }); // "2026-11-02" (Oct 31 is a Saturday)
+calendar.adjust("2026-10-31", { convention: "modified-following" }); // "2026-10-30" (the month would change, so backwards)
 
 calendar.firstBusinessDayOfMonth("2027-01"); // "2027-01-04"
 calendar.lastBusinessDayOfMonth("2026-12"); // "2026-12-30"
-calendar.nthBusinessDayOfMonth("2026-10", 5); // "2026-10-07"（-1 は最終、-2 は最後から 2 番目）
+calendar.nthBusinessDayOfMonth("2026-10", 5); // "2026-10-07" (-1 is the last, -2 the second to last)
 
-// 毎月 10 日払い（休業日なら翌営業日）
-calendar.dueDate("2026-10", { day: 10, convention: "following" }); // "2026-10-13"（12 日はスポーツの日）
+// Paid on the 10th of every month (next business day if closed)
+calendar.dueDate("2026-10", { day: 10, convention: "following" }); // "2026-10-13" (Oct 12 is Sports Day)
 
-// 20 日締め・翌月末払い（休業日なら前営業日）
-const billing = closingMonth("2026-10-21", 20); // "2026-11"（10/21〜11/20 が 11 月分）
+// Closing on the 20th, paid at the end of the next month (previous business day if closed)
+const billing = closingMonth("2026-10-21", 20); // "2026-11" (Oct 21 to Nov 20 belongs to November)
 calendar.dueDate(monthOf(billing, 1), { day: -1, convention: "preceding" }); // "2026-12-30"
 ```
 
-**調整の方法**（`convention`、必須）
+**Adjustment conventions** (`convention`, required)
 
-| 方法                   | 休業日のとき                           |
-| ---------------------- | -------------------------------------- |
-| `"following"`          | 翌営業日                               |
-| `"preceding"`          | 前営業日                               |
-| `"modified-following"` | 翌営業日。ただし月が変わるなら前営業日 |
-| `"modified-preceding"` | 前営業日。ただし月が変わるなら翌営業日 |
+| Convention             | On a closed day                                                      |
+| ---------------------- | -------------------------------------------------------------------- |
+| `"following"`          | The next business day                                                |
+| `"preceding"`          | The previous business day                                            |
+| `"modified-following"` | The next business day, or the previous one if the month would change |
+| `"modified-preceding"` | The previous business day, or the next one if the month would change |
 
-- 営業日ならどの方法でもその日のままです
-- 月が変わるかは、**調整する前の日付の月**と比べます。`dueDate` では、末日に読み替えた後の日付の月です（例: 2 月の 31 日払いは 2 月末日を基準にし、`"modified-following"` なら 2 月の中で調整します）
-- `modified-…` で、同じ月に反対向きの営業日もない（その月が全部休業日）ときは、月が変わっても元の向きに調整します
-- 「最も近い営業日」（nearest）はありません。前後が同じ距離のときの決め方が業種ごとに違うためです
+- On a business day, every convention returns the same day
+- Whether the month changes is judged against **the month of the date before adjustment**. For `dueDate` it is the date after mapping to the last day of the month (for example, payment on the 31st in February uses the last day of February, and `"modified-following"` adjusts within February)
+- With `modified-…`, if the month has no business day in the opposite direction either (the whole month is closed), the date is adjusted in the original direction even though the month changes
+- There is no "nearest business day" (nearest), because the tie-breaking rule for equal distances differs by industry
 
-**月の計算**（ルートの関数。営業日は考えません）
+**Month helpers** (root functions; business days are not considered)
 
-- `monthOf(dateOrMonth, offset?)`: 日付または月 `"YYYY-MM"` の、`offset` か月後（負なら前）の月
-- `closingMonth(date, closingDay)`: 締め日（1〜31、`-1` は末日）で区切ったときに日付が属する月。締め日の翌日から次の締め日までを、次の締め日の月とします。締め日がその月にない日（31 日締めの 2 月など）は末日締めです
+- `monthOf(dateOrMonth, offset?)`: the month `offset` months after (before, if negative) a date or a month `"YYYY-MM"`
+- `closingMonth(date, closingDay)`: the month a date belongs to when months are closed on `closingDay` (1–31, `-1` for the last day). The day after a closing day up to the next closing day belongs to the month of the next closing day. If the closing day does not exist in a month (closing on the 31st in February), the last day is used
 
-`dueDate` の `day` も、その月にない日（2 月 30 日など）は末日に読み替えます。繰り返しの規則（`{ day: 31 }`）はその月にない日に当てはまらないので、扱いが異なります。期日は「その月のどこか」に必ず決まる必要があるためです。
+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)
 
-`createSchedule` は、曜日・祝日・特定日の規則から、日ごとに任意の値を返します。値の型は自由なので、営業時間のほか、受付枠や配送料の区分などにも使えます。
+`createSchedule` returns any value per day from weekday, holiday and specific-date rules. The value type is up to you, so it also fits booking slots, delivery fee classes and more.
 
 ```ts
 import { createSchedule } from "bizdays-toolkit";
 import { jp } from "bizdays-toolkit/jp";
 
-type Hours = { open: string; close: string } | null; // null は休業
+type Hours = { open: string; close: string } | null; // null means closed
 const weekday = { open: "10:00", close: "21:00" };
 const sunday = { open: "10:00", close: "19:00" };
 
 const storeHours = createSchedule<Hours>({
   holidays: jp,
-  weekly: [sunday, weekday, null, weekday, weekday, weekday, weekday], // [日, 月, …, 土]。火曜定休
-  holiday: { sameAs: 0 }, // 祝日は日曜の値（"weekday": 曜日どおり / { value: … }: 指定の値）
-  annual: [{ date: "01-01", value: null, name: "元日休業" }], // 毎年の月日（期間も可）
-  dates: [{ date: "2026-12-31", value: { open: "10:00", close: "17:00" }, name: "大晦日" }],
+  weekly: [sunday, weekday, null, weekday, weekday, weekday, weekday], // [Sun, Mon, …, Sat]; closed on Tuesdays
+  holiday: { sameAs: 0 }, // Sunday hours on holidays ("weekday": by weekday / { value: … }: a fixed value)
+  annual: [{ date: "01-01", value: null, name: "Closed on New Year's Day" }], // annual dates (ranges too)
+  dates: [{ date: "2026-12-31", value: { open: "10:00", close: "17:00" }, name: "New Year's Eve" }],
 });
 
-storeHours.valueOn("2026-11-03"); // { open: "10:00", close: "19:00" }（文化の日は日曜の営業時間）
+storeHours.valueOn("2026-11-03"); // { open: "10:00", close: "19:00" } (Culture Day uses Sunday hours)
 storeHours.dayInfo("2027-01-01");
-// { date: "2027-01-01", weekday: 5, value: null, reason: "annual", name: "元日休業", holiday: {…} }
+// { date: "2027-01-01", weekday: 5, value: null, reason: "annual", name: "Closed on New Year's Day", holiday: {…} }
 ```
 
-値は `dates`（個別の日付・期間）→ `annual`（毎年の月日・期間）→ `recurring`（`"over-holiday"`）→ 祝日 → `recurring`（既定・振替先）→ `weekly`（曜日）の順に決まります。同じ種類の規則が重なる場合は、配列で先に書いたものが優先です。
+Values are decided in the order `dates` (specific dates and ranges) → `annual` (annual dates and ranges) → `recurring` (`"over-holiday"`) → holidays → `recurring` (default and moved days) → `weekly` (weekday). When rules of the same type overlap, the one written first in the array wins.
 
-「今、営業時間内か」のような時刻の範囲の判定は、業種ごとの決まり（深夜をまたぐ営業、休憩時間など）があるためライブラリでは行いません。`civilOf` でタイムゾーンでの暦日と時刻を取り出せば、アプリ側で簡単に書けます。
+Checking a time range such as "is the store open now" is left to your app, because industries differ (opening past midnight, breaks and so on). With `civilOf` you get the civil date and time in the time zone, and the check is short.
 
 ```ts
-const { date, time } = storeHours.civilOf(new Date()); // { date: "2026-10-14", time: "16:30" }（日本時間）
+const { date, time } = storeHours.civilOf(new Date()); // { date: "2026-10-14", time: "16:30" } (Japan time)
 const hours = storeHours.valueOn(date);
 const isOpen = hours !== null && time !== null && hours.open <= time && time < hours.close;
 ```
 
-`civilOf` は営業日カレンダーにもあり、`bizdays-toolkit/jp` の `toJapanDateTime`、ルートの `toDateTimeParts(input, timeZone)` でも同じ変換ができます。
+`civilOf` is also on business-day calendars, and the same conversion is available as `toJapanDateTime` in `bizdays-toolkit/jp` and `toDateTimeParts(input, timeZone)` in the root.
 
-### 日付・日時の入力
+### Date and date-time inputs
 
-すべてのメソッドは次の入力を受け付けます。戻り値の日付は常に `"YYYY-MM-DD"` 文字列です。
+Every method accepts the following inputs. Returned dates are always `"YYYY-MM-DD"` strings.
 
-| 入力                                                 | 扱い                                           |
-| ---------------------------------------------------- | ---------------------------------------------- |
-| `"2026-11-23"`                                       | 暦日                                           |
-| `"2026-11-23T10:00"`                                 | カレンダーのタイムゾーンでの日時（壁時計）     |
-| `"2026-11-22T15:30:00Z"`・`"2026-11-23T00:30+09:00"` | 瞬間。カレンダーのタイムゾーンで暦日に変換する |
-| `Date`                                               | 瞬間                                           |
-| Temporal の `PlainDate`・`PlainDateTime`             | 暦日・日時（Temporal への依存はありません）    |
-| Temporal の `Instant`・`ZonedDateTime`               | 瞬間                                           |
+| Input                                                | Treated as                                                        |
+| ---------------------------------------------------- | ----------------------------------------------------------------- |
+| `"2026-11-23"`                                       | A civil date                                                      |
+| `"2026-11-23T10:00"`                                 | A date and time in the calendar's time zone (wall clock)          |
+| `"2026-11-22T15:30:00Z"`, `"2026-11-23T00:30+09:00"` | An instant, converted to a civil date in the calendar's time zone |
+| `Date`                                               | An instant                                                        |
+| Temporal `PlainDate`, `PlainDateTime`                | A civil date or date and time (no dependency on Temporal)         |
+| Temporal `Instant`, `ZonedDateTime`                  | An instant                                                        |
 
-カレンダーのタイムゾーンは、`timeZone` オプション、祝日の提供元のタイムゾーン、`"UTC"` の順に決まります。
+The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
-### 他の国・地域の祝日
+### Holidays of other countries and regions
 
-`HolidayProvider` を実装して `holidays` に渡します。複数渡すと和集合になります（タイムゾーンが異なる場合は `timeZone` の指定が必要です）。
+Implement `HolidayProvider` and pass it as `holidays`. Several providers give their union (if their time zones differ, `timeZone` is required).
 
 ```ts
 import { createCalendar, type HolidayProvider } from "bizdays-toolkit";
 
 const myCountry: HolidayProvider = {
   id: "XX",
-  timeZone: "Europe/London",
+  timeZone: "Europe/Paris",
   supportedYears: { from: 2000, to: 2100 },
   dataVersion: "2026-10",
   holidaysInYear: (year) => [
     {
       date: `${year}-12-25`,
-      name: "Christmas Day",
+      name: "Noël",
       nameEn: "Christmas Day",
       kind: "public",
       confirmed: true,
@@ -305,12 +342,12 @@ const myCountry: HolidayProvider = {
 const calendar = createCalendar({ holidays: myCountry, closedWeekdays: [0, 6] });
 ```
 
-祝日には、ほかの言語の名称を `names` で付けられます。キーは BCP 47 の言語タグの正規の形（`"zh-Hant"`・`"ko"` など）です。同梱の日本の祝日は `names` を持ちません（公式の出典がある日本語・英語だけを同梱しています）。必要な場合は、提供元を包んで付けます。
+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
 import { jp } from "bizdays-toolkit/jp";
 
-const zhHant: Record<string, string> = { "2026-01-01": "元日" /* … 利用者が用意した訳 */ };
+const zhHant: Record<string, string> = { "2026-01-01": "元日" /* … your own translations */ };
 const jpWithNames = {
   ...jp,
   holidaysInYear: (year: number) =>
@@ -322,13 +359,13 @@ const jpWithNames = {
 createCalendar({ holidays: jpWithNames }).getHoliday("2026-01-01")?.names; // { "zh-Hant": "元日" }
 ```
 
-### 対応年の外
+### Outside the supported years
 
-祝日の提供元の対応年（日本は 1955〜2099 年）を外れた日付を判定すると `RangeError` になります。祝日がない日として扱いたい場合は `outOfRange: "ignore"` を指定してください。
+Evaluating a date outside the holiday provider's supported years (1955–2099 for Japan, 2012–2099 for the UK) throws a `RangeError`. To treat such dates as having no holidays, set `outOfRange: "ignore"`.
 
-### エラー
+### Errors
 
-設定や入力の誤りは、従来どおり `RangeError`・`TypeError` などの例外になり、`code` を持ちます。メッセージの文言は変わることがあるので、判定には `code` を使ってください。
+Invalid options and inputs throw ordinary exceptions such as `RangeError` and `TypeError`, with a `code`. Messages may change, so branch on `code`.
 
 ```ts
 import { createCalendar, isBizdaysError } from "bizdays-toolkit";
@@ -337,16 +374,16 @@ try {
   createCalendar({ closedDates: ["2026-12-32"] });
 } catch (error) {
   if (isBizdaysError(error) && error.code === "invalid-date") {
-    // 日付の誤り（メッセージには設定の中の位置 "closedDates[0].date" が入る）
+    // An invalid date (the message includes the location in the options, "closedDates[0].date")
   }
 }
 ```
 
-主なコード: `invalid-date`・`invalid-month`・`invalid-month-day`・`invalid-time`・`invalid-range`・`invalid-weekday`・`invalid-time-zone`・`invalid-option`・`out-of-range`・`invalid-provider`・`invalid-provider-data`・`no-business-day`。将来の版でコードが増えることがあります。
+Main codes: `invalid-date`, `invalid-month`, `invalid-month-day`, `invalid-time`, `invalid-range`, `invalid-weekday`, `invalid-time-zone`, `invalid-option`, `out-of-range`, `invalid-provider`, `invalid-provider-data`, `no-business-day`. Future versions may add codes.
 
-### 設定の診断
+### Option diagnostics
 
-`bizdays-toolkit/diagnose` の `diagnoseCalendar`・`diagnoseSchedule` は、設定を調べて問題を一覧で返します。例外は投げません（問題がなければ空の配列）。
+`diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` examine options and return a list of problems. They never throw (an empty array means no problems).
 
 ```ts
 import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
@@ -356,12 +393,12 @@ diagnoseCalendar({
   holidays: jp,
   closedWeekdays: [0],
   closedRecurring: [
-    { weekday: 3, nth: 3, name: "第 3 水曜定休" },
-    { weekday: 3, nth: 3, months: [8], name: "8 月の第 3 水曜" }, // 先の規則に含まれる
-    { weekday: 0, name: "日曜休み" }, // 定休日の曜日と同じ
+    { weekday: 3, nth: 3, name: "Closed on the 3rd Wednesday" },
+    { weekday: 3, nth: 3, months: [8], name: "3rd Wednesday in August" }, // covered by the previous rule
+    { weekday: 0, name: "Closed on Sundays" }, // same as the closed weekday
   ],
-  closedDates: ["2100-01-05"], // 日本の祝日の対応年（1955〜2099 年）の外
-  closeAnnual: ["12-31"], // 打ち間違い
+  closedDates: ["2100-01-05"], // outside the supported years of Japanese holidays (1955–2099)
+  closeAnnual: ["12-31"], // a typo
 });
 // [
 //   { severity: "warning", code: "unknown-option", path: "closeAnnual", message: '… (did you mean "closedAnnual"?)' },
@@ -371,25 +408,25 @@ diagnoseCalendar({
 // ]
 ```
 
-| 重さ（`severity`） | `code`                  | 内容                                                                                                                       |
-| ------------------ | ----------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| `error`            | 例外と同じコード        | `createCalendar`・`createSchedule` で例外になる誤り。作成時は最初の 1 件で止まりますが、診断ではすべて返します             |
-| `error`            | `invalid-provider-data` | 祝日の提供元が返したデータの誤り。作成時は使った年だけを調べますが、診断では対応年のすべての年を調べます                   |
-| `warning`          | `unknown-option`        | 知らないキー（作成時は無視されます）。近い既知のキーがあれば `message` に候補を挙げます                                    |
-| `warning`          | `shadowed`              | 同じ種類の先の規則（`relatedPath`）に完全に含まれ、決して使われない規則                                                    |
-| `warning`          | `never-matches`         | 当てはまる日がない繰り返しの規則（`{ day: 30, months: [2] }` など）                                                        |
-| `warning`          | `out-of-range`          | 個別の日付が祝日の提供元（`relatedPath`）の対応年の外                                                                      |
-| `warning`          | `no-business-day`       | 営業日が 1 日もない設定（営業日カレンダーのみ。営業日を探すと例外になります）                                              |
-| `info`             | `redundant`             | 取り除いても結果が変わらない規則（先の規則の組み合わせに覆われる、定休日の曜日と同じ、スケジュールで曜日の値と同じ値など） |
-
-- 判定には `code` を使ってください。`message` は英語で、文言は変わることがあります。`code` は将来の版で増えることがあります
-- `error` があるときは、規則どうしの診断（`shadowed`・`redundant` など）は行いません
-- `shadowed` は同じ種類の規則どうし（個別の日付どうし、毎年の月日どうし、繰り返しの規則どうし）だけを調べます。判定の順番は固定なので、種類をまたいで使われない規則は `redundant` として見つかります。臨時営業日（`openDates`）と臨時休業日（`closedDates`）は同じ種類で、先の臨時営業日に含まれる臨時休業日は `shadowed` です
-- 繰り返しの規則の `shadowed` は、祝日の扱い（`onHolidayRule`）も見ます。たとえば `"under-holiday"` の規則は、同じ日に当たる `"over-holiday"` の規則を覆いません（祝日には後の規則が当たるため）
-- `redundant` は、規則を取り除いた結果と 1 日ずつ比べます。個別の日付はその期間を、毎年の月日と繰り返しの規則は個別の日付を除いた設定で、祝日の提供元の対応年（日本は 1955〜2099 年）を、提供元がなければ 2001〜2028 年（曜日と月日の組み合わせが一巡する 28 年）を調べます。スケジュールの値は、配列と普通のオブジェクトなら中身で、それ以外（`Date` など）は同じものかで比べます
-- 日本の祝日を使う設定では、全日を調べるため数百ミリ秒かかります。リクエストごとではなく、テストや起動時の確認で使ってください。開発・テスト用の道具なので、アプリの本体のバンドルに入らないようサブパスに分けています
-
-テストで設定を守る例:
+| `severity` | `code`                       | Meaning                                                                                                                                                            |
+| ---------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `error`    | The same codes as exceptions | Errors that make `createCalendar` or `createSchedule` throw. Creation stops at the first one; diagnostics return them all                                          |
+| `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                     |
+| `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                             |
+| `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                            |
+| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`)                                                                                          |
+| `warning`  | `out-of-range`               | A specific date outside the supported years of the holiday provider (`relatedPath`)                                                                                |
+| `warning`  | `no-business-day`            | No business day at all (calendars only; searching for a business day throws)                                                                                       |
+| `info`     | `redundant`                  | A rule whose removal changes nothing (covered by a combination of earlier rules, same as a closed weekday, the same value as the weekday in a schedule, and so on) |
+
+- Branch on `code`. `message` is in English and its wording may change. Future versions may add codes
+- When there is an `error`, the rule relation checks (`shadowed`, `redundant` and so on) are skipped
+- `shadowed` compares only rules of the same type (specific dates, annual dates, recurring rules). The order of evaluation is fixed, so rules unused across types are found as `redundant`. Specific open days (`openDates`) and specific closed days (`closedDates`) are of the same type, and a closed day covered by an earlier open day is `shadowed`
+- `shadowed` for recurring rules also considers `onHolidayRule`. For example, an `"under-holiday"` rule does not cover an `"over-holiday"` rule on the same days (the later rule applies on holidays)
+- `redundant` compares the results with and without the rule day by day. Specific dates are checked over their range; annual dates and recurring rules are checked, with specific dates removed, over the holiday provider's supported years (1955–2099 for Japan), or 2001–2028 without a provider (28 years cover every combination of weekday and date). Schedule values are compared by content for arrays and plain objects, and by identity otherwise (such as `Date`)
+- With Japanese holidays, checking every day takes a few hundred milliseconds. Use it in tests or at startup, not per request. As a development and test tool, it lives in a subpath so it stays out of your app's main bundle
+
+Keeping options safe with a test:
 
 ```ts
 import assert from "node:assert/strict";
@@ -397,54 +434,29 @@ import { test } from "node:test";
 import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
 import { shippingOptions } from "../src/calendar.ts";
 
-test("出荷カレンダーの設定に問題がない", () => {
+test("the shipping calendar options have no problems", () => {
   assert.deepEqual(diagnoseCalendar(shippingOptions), []);
 });
 ```
 
-## バージョン番号とデータの更新
+## Versioning and data updates
 
-[Semantic Versioning](https://semver.org/lang/ja/) に従います。詳しくは [RELEASING.md](./RELEASING.md) を参照してください。
+Versioning follows [Semantic Versioning](https://semver.org/). See [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md) (Japanese) for details.
 
-- 法改正・官報公表の反映（祝日の新設・移動、春分・秋分の日の確定）は**マイナー版**です。`^` で指定していれば自動で届きます
-- 祝日の判定結果を固定したい場合は、版を完全一致で指定してください（例: `"bizdays-toolkit": "0.1.0"`）
-- 反映済みのデータは `dataVersion`（日本は反映済みの官報の年月）と `confirmedThrough` で確認できます
-- 1.0.0 までは、マイナー版で破壊的変更を行うことがあります
-- 判定の理由（`reason`）・祝日の種別（`kind`）・エラーコード・診断のコードは、将来の版で値が増えることがあります。値を列挙して分岐するときは「その他」も扱ってください（[RELEASING.md](./RELEASING.md) の「互換性の約束」）
+- Official data updates (new, moved and one-off holidays by law, Official Gazette or proclamation, fixed equinox days in Japan, newly published years on GOV.UK) are released as **patch** versions, so they reach you with either `^` or `~`
+- To freeze the holiday results, pin an exact version (for example `"bizdays-toolkit": "0.8.0"`)
+- The reflected data is shown by `dataVersion` (for Japan, the year and month of the Official Gazette reflected; for the UK, the year and month of the GOV.UK data reflected) and `confirmedThrough`
+- Before 1.0.0, minor versions may contain breaking changes
+- Decision reasons (`reason`), holiday kinds (`kind`), error codes and diagnostic codes may gain values in future versions. When you branch on their values, handle "anything else" too (see "互換性の約束", the compatibility promise, in [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md))
 
-## 出典
+## Data sources
 
-日本の祝日の検証には、内閣府ホームページで公開されている「国民の祝日」の CSV（<https://www8.cao.go.jp/chosei/shukujitsu/syukujitsu.csv>） を利用しています（テスト用フィクスチャのみ。パッケージには含みません）。
+Japanese holidays are verified with the "National Holidays" CSV published on the Cabinet Office website (<https://www8.cao.go.jp/chosei/shukujitsu/syukujitsu.csv>) (as a test fixture only; not included in the package).
 
-## ライセンス
+UK bank holidays are verified with the GOV.UK bank holidays data (<https://www.gov.uk/bank-holidays.json>, and for earlier years the history of the official GOV.UK repositories [alphagov/calendars](https://github.com/alphagov/calendars) and [alphagov/frontend](https://github.com/alphagov/frontend)), and the Welsh names of the Wales holidays with the Welsh version of GOV.UK (the verification data is a test fixture only; not included in the package).
 
-MIT
-
----
+Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).
 
-## English
-
-A business-day calendar that combines public holidays with company or store closures.
+## License
 
-- **Japanese holidays verified day by day** against the Cabinet Office CSV, from 1955 through the latest year officially announced (substitute holidays, citizens' holidays, imperial ceremonies, and the Olympic moves included)
-- **Day-by-day schedules**: `createSchedule` returns any value per day (e.g. store hours) from weekly values, a holiday rule (`"weekday"`, `{ sameAs: 0 }`, or `{ value }`), annual dates and specific dates
-- **Recurring rules**: weekly, nth-weekday-of-month (`{ weekday: 3, nth: 3 }`) and day-of-month (`{ day: -1 }`) rules, with per-rule holiday handling (`onHolidayRule`: `"under-holiday"`, `"over-holiday"`, or `"after-holiday"` to move the rule to the next non-holiday, e.g. "closed on Mondays; if Monday is a holiday, closed on the next weekday")
-- **Option diagnostics**: `diagnoseCalendar` / `diagnoseSchedule` from `bizdays-toolkit/diagnose` return a list of problems without throwing: rules that can never apply (`shadowed`, `never-matches`), rules whose removal changes nothing (`redundant`), typos in option keys with a suggestion (`unknown-option`), dates outside the holiday provider's years (`out-of-range`), and calendars with no business day. Use `code` to branch; `message` is for humans
-- **Month-based due dates**: `adjust` with `following` / `preceding` / `modified-following` / `modified-preceding`, the nth / first / last business day of a month, `dueDate(month, { day, convention })`, and the calendar helpers `closingMonth` and `monthOf`
-- **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed/open dates, holiday policy, `addBusinessDays`, cut-off times, and more
-- **Time-zone safe**: instants (`Date`, ISO strings with offsets, Temporal) are converted to a civil date in the calendar's time zone before evaluation
-- **Lightweight, zero dependencies**: about 7.4 KB min+gzip (about 8.5 KB with Japanese holidays), ESM, bundled types, `sideEffects: false`
-- **Extensible** through the `HolidayProvider` interface (only Japan is bundled for now). Holidays can carry names in other languages via the optional `names` field (keys are canonical BCP 47 language tags); the bundled Japanese data includes only the officially sourced Japanese and English names
-
-```ts
-import { createCalendar } from "bizdays-toolkit";
-import { jp, isHoliday } from "bizdays-toolkit/jp";
-
-isHoliday("2026-11-23"); // true
-
-const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
-office.addBusinessDays("2026-09-18", 1); // "2026-09-24"
-office.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
-```
-
-Versioning follows SemVer. Updates that reflect law amendments or official announcements are released as **minor** versions; pin an exact version if you need frozen results. Before 1.0.0, minor versions may contain breaking changes. See [RELEASING.md](./RELEASING.md) (Japanese) for details.
+MIT

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー（createCalendar）と、
  * 曜日・祝日・特定日で変わる値（営業時間など）のスケジュール（createSchedule）。
  *
- * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"）。
+ * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"・"bizdays-toolkit/uk"）。
  *
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。

package/dist/index.js

@@ -2,7 +2,7 @@
  * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー（createCalendar）と、
  * 曜日・祝日・特定日で変わる値（営業時間など）のスケジュール（createSchedule）。
  *
- * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"）。
+ * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"・"bizdays-toolkit/uk"）。
  *
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。

package/dist/uk/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 英国の bank holidays（England・Wales・Scotland・Northern Ireland）。
+ *
+ * 地域ごとに提供元が分かれている。GOV.UK では England と Wales が 1 つの区分（England and Wales）だが、
+ * このライブラリでは別の提供元にしている（日付は現在同じ。将来分かれても利用者のコードを変えずに済むように）。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { scotland } from "bizdays-toolkit/uk";
+ * const calendar = createCalendar({ holidays: scotland, closedWeekdays: [0, 6] });
+ */
+import type { Holiday, HolidayProvider } from "../core/types.ts";
+import { type UkHolidayKind } from "./rules.ts";
+export type { KnownUkHolidayKind, UkHolidayKind } from "./rules.ts";
+/**
+ * 英国の祝日。
+ * @public
+ */
+export type UkHoliday = Holiday<UkHolidayKind>;
+/**
+ * England の bank holidays の提供元（GOV.UK の England and Wales）。
+ * @public
+ */
+export declare const england: HolidayProvider<UkHolidayKind>;
+/**
+ * Wales の bank holidays の提供元（GOV.UK の England and Wales）。名称にウェールズ語（names.cy）が付く。
+ * @public
+ */
+export declare const wales: HolidayProvider<UkHolidayKind>;
+/**
+ * Scotland の bank holidays の提供元。
+ * @public
+ */
+export declare const scotland: HolidayProvider<UkHolidayKind>;
+/**
+ * Northern Ireland の bank holidays の提供元。
+ * @public
+ */
+export declare const northernIreland: HolidayProvider<UkHolidayKind>;
+/**
+ * 反映済みの GOV.UK のデータの年月。
+ * @public
+ */
+export declare const dataVersion: string;
+/**
+ * GOV.UK が日付を公表している最後の年（それより後は規則による予測で confirmed: false）。
+ * @public
+ */
+export declare const confirmedThrough: number;

package/dist/uk/index.js

@@ -0,0 +1,83 @@
+/**
+ * 英国の bank holidays（England・Wales・Scotland・Northern Ireland）。
+ *
+ * 地域ごとに提供元が分かれている。GOV.UK では England と Wales が 1 つの区分（England and Wales）だが、
+ * このライブラリでは別の提供元にしている（日付は現在同じ。将来分かれても利用者のコードを変えずに済むように）。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { scotland } from "bizdays-toolkit/uk";
+ * const calendar = createCalendar({ holidays: scotland, closedWeekdays: [0, 6] });
+ */
+import { CONFIRMED_THROUGH, DATA_VERSION, SUPPORTED_YEARS, computeUkHolidays, } from "./rules.js";
+/** Wales の祝日のウェールズ語の名称（GOV.UK のウェールズ語版の表記） */
+const WELSH_NAMES = {
+    "New Year’s Day": "Dydd Calan",
+    "Good Friday": "Gwener y Groglith",
+    "Easter Monday": "Llun y Pasg",
+    "Early May bank holiday": "Gŵyl banc dechrau Mai",
+    "Early May bank holiday (VE day)": "Gŵyl banc dechrau Mai (diwrnod VE)",
+    "Spring bank holiday": "Gŵyl banc y gwanwyn",
+    "Summer bank holiday": "Gŵyl banc yr haf",
+    "Christmas Day": "Dydd Nadolig",
+    "Boxing Day": "Dydd San Steffan",
+    "Queen’s Diamond Jubilee": "Jiwbilî Ddiemwnt y Frenhines",
+    "Platinum Jubilee bank holiday": "Gŵyl banc Jiwbilî Blatinwm",
+    "Bank Holiday for the State Funeral of Queen Elizabeth II": "Gŵyl y Banc ar gyfer Angladd Gwladol y Frenhines Elizabeth II",
+    "Bank holiday for the coronation of King Charles III": "Gŵyl y banc ar gyfer coroni Brenin Siarl III",
+};
+function withWelsh(list) {
+    return list.map((h) => {
+        const cy = WELSH_NAMES[h.name];
+        return Object.freeze(cy === undefined ? h : { ...h, names: Object.freeze({ cy }) });
+    });
+}
+function provider(id, division, transform) {
+    const cache = new Map();
+    return Object.freeze({
+        id,
+        timeZone: "Europe/London",
+        supportedYears: SUPPORTED_YEARS,
+        dataVersion: DATA_VERSION,
+        confirmedThrough: CONFIRMED_THROUGH,
+        holidaysInYear(year) {
+            let list = cache.get(year);
+            if (!list) {
+                const computed = computeUkHolidays(division, year);
+                list = Object.freeze(transform ? transform(computed) : computed);
+                cache.set(year, list);
+            }
+            return list;
+        },
+    });
+}
+/**
+ * England の bank holidays の提供元（GOV.UK の England and Wales）。
+ * @public
+ */
+export const england = provider("GB-ENG", "england-and-wales");
+/**
+ * Wales の bank holidays の提供元（GOV.UK の England and Wales）。名称にウェールズ語（names.cy）が付く。
+ * @public
+ */
+export const wales = provider("GB-WLS", "england-and-wales", withWelsh);
+/**
+ * Scotland の bank holidays の提供元。
+ * @public
+ */
+export const scotland = provider("GB-SCT", "scotland");
+/**
+ * Northern Ireland の bank holidays の提供元。
+ * @public
+ */
+export const northernIreland = provider("GB-NIR", "northern-ireland");
+/**
+ * 反映済みの GOV.UK のデータの年月。
+ * @public
+ */
+export const dataVersion = DATA_VERSION;
+/**
+ * GOV.UK が日付を公表している最後の年（それより後は規則による予測で confirmed: false）。
+ * @public
+ */
+export const confirmedThrough = CONFIRMED_THROUGH;

package/dist/uk/rules.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 英国の bank holidays（GOV.UK の区分: England and Wales・Scotland・Northern Ireland）の計算。
+ *
+ * - 毎年の祝日: 1971 年の Banking and Financial Dealings Act の附則と、毎年の布告で定まる日を規則で計算する
+ *   （England and Wales・Northern Ireland の Good Friday と Christmas Day は慣習法上の休日だが、GOV.UK の一覧と同じく含める）
+ * - 振替: 土曜日・日曜日に当たる固定日の祝日は、その後で最も近い、祝日でない平日に振り替える（日付順に割り当てる）
+ * - 臨時の祝日・移動: 布告ごとの日付をテーブルで持つ
+ *
+ * 対応年のすべての日付と名称が GOV.UK のデータと一致することを、テスト用フィクスチャ
+ * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
+ * 規則による予測（confirmed: false）。
+ */
+import { type DateString } from "../core/date.ts";
+import type { Holiday } from "../core/types.ts";
+/**
+ * 英国の祝日の種別（既知の値）。
+ * @public
+ */
+export type KnownUkHolidayKind = 
+/** 毎年の祝日（布告で日付が移動した年を含む） */
+"regular"
+/** 土曜日・日曜日に当たった祝日の振替 */
+ | "substitute"
+/** 布告による臨時の祝日（記念式典・国葬など） */
+ | "special";
+/**
+ * 英国の祝日の種別。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
+ * すべての値を網羅したことを型で確かめたい場合は KnownUkHolidayKind を使う。
+ * @public
+ */
+export type UkHolidayKind = KnownUkHolidayKind | (string & {});
+/** @internal GOV.UK の区分 */
+export type UkDivision = "england-and-wales" | "scotland" | "northern-ireland";
+/** @internal 対応年 */
+export declare const SUPPORTED_YEARS: Readonly<{
+    from: 2012;
+    to: 2099;
+}>;
+/** @internal GOV.UK が日付を公表している最後の年 */
+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

@@ -0,0 +1,165 @@
+/**
+ * 英国の bank holidays（GOV.UK の区分: England and Wales・Scotland・Northern Ireland）の計算。
+ *
+ * - 毎年の祝日: 1971 年の Banking and Financial Dealings Act の附則と、毎年の布告で定まる日を規則で計算する
+ *   （England and Wales・Northern Ireland の Good Friday と Christmas Day は慣習法上の休日だが、GOV.UK の一覧と同じく含める）
+ * - 振替: 土曜日・日曜日に当たる固定日の祝日は、その後で最も近い、祝日でない平日に振り替える（日付順に割り当てる）
+ * - 臨時の祝日・移動: 布告ごとの日付をテーブルで持つ
+ *
+ * 対応年のすべての日付と名称が GOV.UK のデータと一致することを、テスト用フィクスチャ
+ * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
+ * 規則による予測（confirmed: false）。
+ */
+import { addDays, daysInMonth, formatDate, nthWeekdayOfMonth, weekdayOf, } from "../core/date.js";
+import { rangeError } from "../core/errors.js";
+/** @internal 対応年 */
+export const SUPPORTED_YEARS = Object.freeze({ from: 2012, to: 2099 });
+/** @internal GOV.UK が日付を公表している最後の年 */
+export const CONFIRMED_THROUGH = 2028;
+/** @internal 反映済みの GOV.UK のデータの年月（2026 年の Scotland の World Cup bank holiday の追加） */
+export const DATA_VERSION = "2026-02";
+const NEW_YEAR = "New Year’s Day";
+const SECOND_JANUARY = "2nd January";
+const ST_PATRICK = "St Patrick’s Day";
+const GOOD_FRIDAY = "Good Friday";
+const EASTER_MONDAY = "Easter Monday";
+const EARLY_MAY = "Early May bank holiday";
+const SPRING = "Spring bank holiday";
+const BOYNE = "Battle of the Boyne (Orangemen’s Day)";
+const SUMMER = "Summer bank holiday";
+const ST_ANDREW = "St Andrew’s Day";
+const CHRISTMAS = "Christmas Day";
+const BOXING = "Boxing Day";
+const ALL = ["england-and-wales", "scotland", "northern-ireland"];
+/** 布告で毎年の祝日の日付を移した年（名称が変わる場合は name） */
+const MOVED = [
+    { year: 2012, from: SPRING, date: "2012-06-04" },
+    { year: 2020, from: EARLY_MAY, date: "2020-05-08", name: "Early May bank holiday (VE day)" },
+    { year: 2022, from: SPRING, date: "2022-06-02" },
+];
+/** 布告による臨時の祝日 */
+const SPECIAL_DAYS = [
+    { date: "2012-06-05", name: "Queen’s Diamond Jubilee", divisions: ALL },
+    { date: "2022-06-03", name: "Platinum Jubilee bank holiday", divisions: ALL },
+    {
+        date: "2022-09-19",
+        name: "Bank Holiday for the State Funeral of Queen Elizabeth II",
+        divisions: ALL,
+    },
+    {
+        date: "2023-05-08",
+        name: "Bank holiday for the coronation of King Charles III",
+        divisions: ALL,
+    },
+    { date: "2026-06-15", name: "World Cup bank holiday", divisions: ["scotland"] },
+];
+/**
+ * 振替の日付は規則どおりで、どちらの祝日の振替かの割り当てだけが規則と異なる年。
+ * 2023 年の Scotland（1 月 1 日が日曜日）は、GOV.UK では 1/2 が New Year’s Day の振替、1/3 が 2nd January の振替。
+ * 同じ曜日の並びの 2012・2017 年は、附則どおり 1/2 が 2nd January、1/3 が New Year’s Day の振替
+ */
+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));
+}
+function isWeekend(date) {
+    const w = weekdayOf(date);
+    return w === 0 || w === 6;
+}
+/** @internal その年・区分の祝日（日付順） */
+export function computeUkHolidays(division, year) {
+    if (!Number.isInteger(year) || year < SUPPORTED_YEARS.from || year > SUPPORTED_YEARS.to) {
+        throw rangeError("out-of-range", `UK bank holidays are supported for ${SUPPORTED_YEARS.from}-${SUPPORTED_YEARS.to}; requested ${year}`);
+    }
+    const scotland = division === "scotland";
+    const ni = division === "northern-ireland";
+    const fixed = [{ month: 1, day: 1, name: NEW_YEAR }];
+    if (scotland)
+        fixed.push({ month: 1, day: 2, name: SECOND_JANUARY });
+    if (ni)
+        fixed.push({ month: 3, day: 17, name: ST_PATRICK });
+    if (ni)
+        fixed.push({ month: 7, day: 12, name: BOYNE });
+    if (scotland)
+        fixed.push({ month: 11, day: 30, name: ST_ANDREW });
+    fixed.push({ month: 12, day: 25, name: CHRISTMAS }, { month: 12, day: 26, name: BOXING });
+    const easter = easterSunday(year);
+    const movable = [
+        { date: addDays(easter, -2), name: GOOD_FRIDAY, kind: "regular" },
+        { date: nthWeekdayOfMonth(year, 5, 1, 1), name: EARLY_MAY, kind: "regular" },
+        { date: lastMonday(year, 5), name: SPRING, kind: "regular" },
+        {
+            date: scotland ? nthWeekdayOfMonth(year, 8, 1, 1) : lastMonday(year, 8),
+            name: SUMMER,
+            kind: "regular",
+        },
+    ];
+    if (!scotland)
+        movable.push({ date: addDays(easter, 1), name: EASTER_MONDAY, kind: "regular" });
+    const entries = [];
+    for (const e of movable) {
+        const moved = MOVED.find((m) => m.year === year && m.from === e.name);
+        entries.push(moved ? { date: moved.date, name: moved.name ?? e.name, kind: e.kind } : e);
+    }
+    for (const s of SPECIAL_DAYS) {
+        if (s.date.startsWith(`${year}-`) && s.divisions.includes(division)) {
+            entries.push({ date: s.date, name: s.name, kind: "special" });
+        }
+    }
+    // 平日に当たる固定日の祝日を先に置き、土曜日・日曜日に当たるものを日付順に振り替える
+    const taken = new Set(entries.map((e) => e.date));
+    const fixedDates = fixed.map((f) => ({ date: formatDate(year, f.month, f.day), name: f.name }));
+    for (const f of fixedDates) {
+        if (!isWeekend(f.date)) {
+            entries.push({ date: f.date, name: f.name, kind: "regular" });
+            taken.add(f.date);
+        }
+    }
+    for (const f of fixedDates) {
+        if (!isWeekend(f.date))
+            continue;
+        let day = addDays(f.date, 1);
+        while (isWeekend(day) || taken.has(day))
+            day = addDays(day, 1);
+        entries.push({ date: day, name: f.name, kind: "substitute" });
+        taken.add(day);
+    }
+    for (const r of RENAMED) {
+        if (r.division !== division || !r.date.startsWith(`${year}-`))
+            continue;
+        const i = entries.findIndex((e) => e.date === r.date);
+        if (i >= 0)
+            entries[i] = { date: r.date, name: r.name, kind: r.kind };
+    }
+    return entries
+        .sort((a, b) => (a.date < b.date ? -1 : 1))
+        .map((e) => Object.freeze({
+        date: e.date,
+        name: e.name,
+        nameEn: e.name,
+        kind: e.kind,
+        confirmed: year <= CONFIRMED_THROUGH,
+    }));
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.7.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. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府データで全日照合）",
+  "version": "0.8.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",
     "bizdays",
     "business-day",
     "business-days",
@@ -10,6 +11,7 @@
     "holiday",
     "holidays",
     "japan",
+    "uk",
     "workday",
     "営業日",
     "祝日"
@@ -40,6 +42,10 @@
       "types": "./dist/jp/index.d.ts",
       "default": "./dist/jp/index.js"
     },
+    "./uk": {
+      "types": "./dist/uk/index.d.ts",
+      "default": "./dist/uk/index.js"
+    },
     "./diagnose": {
       "types": "./dist/diagnose/index.d.ts",
       "default": "./dist/diagnose/index.js"
@@ -57,6 +63,7 @@
     "fmt:check": "oxfmt --check",
     "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tz && pnpm build && pnpm fmt:check && node scripts/check-package.ts && node scripts/check-size.ts && node scripts/api-report.ts",
     "verify:cao": "node scripts/verify-cao.ts",
+    "verify:govuk": "node scripts/verify-govuk.ts",
     "prepublishOnly": "pnpm check",
     "release-notes": "node scripts/release-notes.ts",
     "api:update": "pnpm build && node scripts/api-report.ts --update"