bizdays-toolkit 0.11.1 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,58 @@
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-10-20
+
+### 移行
+
+動作は変わりません（スケジュールから営業日カレンダーを作る関数と、判定の理由の新しい値の追加。CI の改善）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- スケジュールから営業日カレンダーを作る `createCalendarFromSchedule(schedule, isOpen, { maxSearchDays? })` を追加した。`isOpen` が true を返す値の日を営業日とする通常のカレンダーを返し、営業時間表のようなスケジュールが唯一の設定になる。`isOpen` は値だけを受け取る純粋な関数（日付は渡さない。営業日の探索で繰り返し呼ぶため）。`dayInfo` の `reason` はスケジュールの `reason` と営業・休業の組み合わせで、`name`・`holiday`・`shiftedFrom`・`rulePath` はスケジュールの結果を引き継ぐ。祝日・タイムゾーン・`outOfRange` はスケジュールのもの。`createSchedule` が作ったスケジュール以外は `invalid-argument`
+- 判定の理由（`DayReason`）に `"open-annual"`（スケジュールの `annual` の値で営業になる日）を追加した。`createCalendar` の結果には現れない（`closedAnnual` は休業だけ）
+
+### Changed
+
+- README: 「スケジュールから営業日カレンダーを作る」の節を足した。型定義の確認の範囲を、CI で確かめる TypeScript の版（5.0・5.5・5.8・6.0・7.0）に改めた。サイズの値を測り直した（ルート約 9.0KB・日本の祝日込み約 10.8KB・英国の祝日込み約 10.7KB。0.13.0 で測定）
+- `docs/decisions.md`: 38 番（スケジュールからのカレンダー・`"open-annual"`・利用者の TypeScript の版の確認）を追加した
+
+### 開発
+
+- CI に `consumer-types` ジョブを追加した。公開する型定義を、利用者が使う TypeScript 5.0.4・5.5.4・5.8.3・7.0.2（ネイティブ版）のそれぞれで、`moduleResolution` の `node16`・`nodenext`・`bundler` で型チェックする。各版は依存にせず、版と SHA-256 を固定した tgz から一時ディレクトリに入れる（7.0 はランナー向けの実行形式 `@typescript/typescript-linux-x64` も固定）。`pnpm check` は従来どおり開発用の 6.0.3 で確かめる
+- `scripts/check-consumer-types.ts` に `--tsc <path>` を足し、わざと型エラーを含む `test/consumer/consumer-error.mts` が各版で失敗として報告されること（検査が機能していること）も確かめるようにした。リポジトリの `@types` を読まないよう `--typeRoots` を空にした（古い TypeScript では `@types/node` の新しい構文を読めないため）。`--ignoreConfig` は 6.0 以降でだけ渡す
+- `createCalendar` の `dayInfo` の変換を `createCalendarFromSchedule` と共用の内部関数に切り出した。結果は変わらない
+
+## [0.12.0] - 2026-10-20
+
+### 移行
+
+動作は変わりません（繰り返しの規則の新しい形・`dayInfo` の新しい項目の追加と、診断・CI の改善）。`bizdays-toolkit/jp`・`bizdays-toolkit/uk` の定数 `dataVersion`・`confirmedThrough` が非推奨になったので、使っていれば提供元の項目（`jp.dataVersion`・`england.confirmedThrough` など）に書き換える。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 繰り返しの規則に、祝日の形 `{ holiday: true, kinds?, months? }`（型 `HolidayPattern`）を追加した。祝日の既定の扱い（`holidayPolicy`・スケジュールの `holiday`）の例外を、「2027 年 4 月から祝日も営業」（`openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]`）、「振替休日と国民の休日は営業」（`kinds: ["substitute", "citizens"]`）、「5 月の祝日は特別営業時間」（スケジュールの `recurring`）のように書ける。`kinds` は `months` と同じ絞り込みの配列（省略時はすべての祝日）。判定は「祝日の上」の段階（`"over-holiday"` の規則と同じ）で、`holidayPolicy: "ignore"` でも当てはまる。当てはまる日は祝日なので `onHolidayRule` は指定できない（`invalid-option`）。`kinds` は `holiday` の規則でだけ使える
+- `DayInfo`・`ScheduleDay` に `rulePath`（値を決めた規則の設定の中の位置。規則の診断の `path` と同じ形。例: `"closedRecurring[0]"`）を追加した。`dates`・`annual`・`recurring`（振替先を含む）で決まった日にだけ付き、祝日・曜日で決まった日には付かない。合成したカレンダーは決めたカレンダーの `rulePath` を引き継ぐ
+
+### Deprecated
+
+- `bizdays-toolkit/jp`・`bizdays-toolkit/uk` の定数 `dataVersion`・`confirmedThrough` を非推奨にした（`@deprecated`）。提供元の項目（`jp.dataVersion`・`jp.confirmedThrough`、英国は `england.dataVersion` など 4 つの提供元で同じ値）と同じ値で、経路を 1 つにするため。1.0.0 で削除する
+
+### Changed
+
+- 規則の診断で、祝日の規則を扱えるようにした。提供元のない設定、または `kinds`・`months`・有効期間に当てはまる祝日がない規則は `never-matches`。`shadowed` は祝日の規則どうし（`kinds`・`months`・有効期間の包含）でだけ調べ、既定の扱いと同じ向きの規則は `redundant` で見つける
+- 規則の診断の `unknown-option` の候補（did you mean）で、既知のキーの先頭部分（`onHoliday` → `onHolidayRule`）を、短い別のキー（`holiday`）との編集距離より優先するようにした
+- 繰り返しの規則の形の誤りのメッセージを、`"weekday"`・`"day"`・`"dayAfterHoliday"`・`"holiday"` のうち 1 つだけを持つ、に改めた（code は `invalid-option` のまま）
+- README: 繰り返しの規則の節に祝日の規則を、`rulePath` の説明を、合成の節に祝日の提供元の和集合の意味（同じ提供元は 1 つ、包んだ提供元は別物、同じ日付は先のカレンダーの提供元）を足した。`dataVersion`・`confirmedThrough` の案内を提供元の項目に改めた。サイズの値を測り直した（ルート約 8.8KB・日本の祝日込み約 10.6KB・英国の祝日込み約 10.5KB。0.12.0 で測定）
+- `docs/decisions.md`: 4 番に「知っているキーの無効な組み合わせは例外にする」境界を、34 番に和集合の意味を足した。35 番（祝日の規則）・36 番（`rulePath`）・37 番（定数の一本化と性能の検証）を追加した
+
+### 開発
+
+- CI に `bench` ジョブを追加した。公開済みの前の版（npm の `latest`）と今回の `dist` を同じランナーで `scripts/bench.ts` にかけ、`scripts/bench-compare.ts` で比率を比べる。どれかの計測が 2 倍より遅ければ失敗し、絶対値は Job Summary に残す（`pnpm check` には含めない）。`scripts/bench.ts` に `--package <dir>`・`--json <file>` を足した
+- サイズの上限（`size-limits.json`）を上げた。ルート 19,500 → 20,500、`./jp` 22,500 → 23,500、`./diagnose` 26,000 → 27,000（gzip）。祝日の規則の検証・判定と `rulePath`（ルートで約 0.5KB）、診断の祝日の規則への対応と候補の改善（約 0.7KB）のため
+- 性質のテストに祝日の規則を加えた。規則を取り除いた結果との比較では、位置がずれる `rulePath` を除いて比べる
+- ライブラリ内のテストとスクリプトで、非推奨にした定数 `confirmedThrough` の代わりに提供元の項目を使うようにした
+
 ## [0.11.1] - 2026-10-19
 
 ライブラリのコードは 0.11.0 と同じ。
@@ -300,7 +352,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.1...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...HEAD
+[0.13.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...v0.13.0
+[0.12.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.1...v0.12.0
 [0.11.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.9.1...v0.10.0

package/README.md

@@ -25,9 +25,10 @@ A business-day calendar that combines public holidays with company or store clos
 - **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
+- **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 8.6 KB min+gzip (about 10.3 KB with Japanese holidays, about 10.2 KB with UK bank holidays; measured for 0.11.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.0 KB min+gzip (about 10.8 KB with Japanese holidays, about 10.7 KB with UK bank holidays; measured for 0.13.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
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -38,7 +39,7 @@ 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.
 
-Types are bundled. CI type-checks a consumer project against the published type definitions with `moduleResolution` set to `node16`, `nodenext` and `bundler` (TypeScript 6); TypeScript 5.0, 5.5 and 5.8 were also checked by hand for 0.9.0.
+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.
 
 ## Usage
 
@@ -114,7 +115,7 @@ shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // business days from
 shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
 
 shipping.dayInfo("2027-01-01");
-// { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "New Year closure", holiday: {…} }
+// { 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]
 ```
 
@@ -127,7 +128,7 @@ Each day is decided in this order of priority (top first).
 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)
+4. `openRecurring` and `closedRecurring` rules with `onHolidayRule: "over-holiday"` (applied even on holidays), and holiday rules (`{ holiday: true }`)
 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)
@@ -135,9 +136,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, day after a holiday)
+### Recurring rules (weekly, every other week, nth weekday, day of month, holidays, day after 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)" 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" or "closed on the day after a holiday" go in `closedRecurring` and `openRecurring`.
 
 ```ts
 const museum = createCalendar({
@@ -159,7 +160,7 @@ const museum = createCalendar({
 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: "Closed on Mondays", shiftedFrom: "2026-10-12" }
+//   name: "Closed on Mondays", shiftedFrom: "2026-10-12", rulePath: "closedRecurring[0]" }
 museum.dayInfo("2026-02-12").name; // "Closed on the day after a holiday" (National Foundation Day is February 11)
 museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of holidays)
 ```
@@ -170,6 +171,7 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 | `{ weekday: 3, nth: 3 }`                            | The 3rd Wednesday. `nth` is 1–5 or -1 (last); an array such as `[2, 4]` gives several                                |
 | `{ weekday: 3, interval: 2, anchor: "2026-01-07" }` | Every other Wednesday: the Wednesdays an even number of weeks from `anchor` (2 or more weeks; see below)             |
 | `{ 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)  |
 | `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) |
@@ -177,6 +179,7 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 - **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
 - 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
 
@@ -214,6 +217,7 @@ shop.isBusinessDay("2027-08-13"); // true (the summer closure ended in 2026)
 - 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
+- `dayInfo()` for a day decided by `openDates`, `closedDates`, `closedAnnual`, `openRecurring` or `closedRecurring` (including the day a rule moved to) includes `rulePath`, the position of that rule in the options in the same form as the diagnostics' `path` (such as `"closedRecurring[0]"`), so rules with the same `name` can be told apart. Days decided by holidays or `closedWeekdays` have no `rulePath`
 
 In a schedule, the same patterns with a `value` go in `recurring`.
 
@@ -251,15 +255,15 @@ 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", decidedBy: 0 }
+// { date: "2026-12-29", weekday: 2, businessDay: false, reason: "closed-annual", name: "New Year closure", rulePath: "closedAnnual[0]", decidedBy: 0 }
 
 // Any of several stores is open
 const anyStore = combineCalendars([company, bank], { businessDay: "any" });
 anyStore.isBusinessDay("2026-12-29"); // true
 ```
 
-- `dayInfo` reports `reason`, `name` and `shiftedFrom` from the first calendar whose result equals the combined result, and the index of that calendar in `decidedBy`. 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
-- `holiday`, `isHoliday`, `holidaysInYear` and so on use the union of the calendars' holiday providers. `outOfRange` is `"throw"` if any calendar throws outside its supported years
+- `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
+- `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
 
@@ -418,7 +422,7 @@ const storeHours = createSchedule<Hours>({
 
 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: "Closed on New Year's Day", holiday: {…} }
+// { date: "2027-01-01", weekday: 5, value: null, reason: "annual", name: "Closed on New Year's Day", holiday: {…}, rulePath: "annual[0]" }
 
 // Holidays in a period with their hours: filter daysBetween by holiday
 storeHours
@@ -433,7 +437,7 @@ storeHours
   .map((d) => d.date); // ["2027-01-11"]
 ```
 
-`reason` is the rule that decided the value. With `holiday: "weekday"` (holidays follow the weekday rule), a holiday has `reason: "weekday"`, so check `holiday` to know whether a day is a holiday. Filtering by `holiday` alone also keeps holidays whose value is set by `dates` or `annual` (such as special hours on New Year's Day). To list only holidays that follow the holiday handling, also exclude `reason` `"date"` and `"annual"`, as in the last example: `holiday` tells whether the day is a holiday, and `reason` tells which rule decided the value.
+`reason` is the rule that decided the value, and `rulePath` (for `dates`, `annual` and `recurring`) its position in the options. With `holiday: "weekday"` (holidays follow the weekday rule), a holiday has `reason: "weekday"`, so check `holiday` to know whether a day is a holiday. Filtering by `holiday` alone also keeps holidays whose value is set by `dates` or `annual` (such as special hours on New Year's Day). To list only holidays that follow the holiday handling, also exclude `reason` `"date"` and `"annual"`, as in the last example: `holiday` tells whether the day is a holiday, and `reason` tells which rule decided the value.
 
 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.
 
@@ -447,6 +451,33 @@ const isOpen = hours !== null && hours.open <= time && time < hours.close;
 
 For inputs that always carry a time (a `Date`, Temporal `Instant`, `ZonedDateTime` or `PlainDateTime`, or a `"YYYY-MM-DDTHH:mm"` string), `time` is typed as `string`, so no `null` check is needed. `civilOf` is also on business-day calendars, and the same conversion is available as `toDateTimeParts(input, timeZone)` in the root. (`toJapanDate` and `toJapanDateTime` in `bizdays-toolkit/jp` are deprecated since 0.10.0: use `toDateString(input, "Asia/Tokyo")`, `toDateTimeParts(input, "Asia/Tokyo")` or `dateOf`/`civilOf` on a calendar instead. They will be removed in 1.0.0.)
 
+### A business-day calendar from a schedule
+
+When the schedule (store hours, say) is the real configuration, `createCalendarFromSchedule(schedule, isOpen)` makes a business-day calendar from it, so you do not write a second set of rules to keep in sync. `isOpen` decides from the value alone whether the day is a business day; the result is an ordinary calendar with business-day arithmetic, `adjust`, `dueDate` and the rest.
+
+```ts
+import { createCalendarFromSchedule } from "bizdays-toolkit";
+
+const hours = createSchedule<Hours>({
+  holidays: jp,
+  weekly: [null, weekday, weekday, weekday, weekday, weekday, { open: "10:00", close: "17:00" }],
+  holiday: { sameAs: 0 },
+  annual: [
+    { from: "12-31", to: "01-03", value: null, name: "New Year closure" },
+    { date: "01-04", value: { open: "11:00", close: "15:00" }, name: "First day of the year" },
+  ],
+});
+const calendar = createCalendarFromSchedule(hours, (v) => v !== null);
+calendar.addBusinessDays("2026-12-29", 2); // "2027-01-04"
+calendar.dayInfo("2027-01-04");
+// { date: "2027-01-04", weekday: 1, businessDay: true, reason: "open-annual", name: "First day of the year", rulePath: "annual[1]" }
+```
+
+- `isOpen` must be a pure function of the value: it receives only the value (not the date), and the calendar calls it repeatedly while searching for business days, so a function that looks at the date, the time or outside state would make the result change from call to call. Conditions that depend on the date belong in the schedule's rules (`dates`, `recurring`)
+- `dayInfo` maps the schedule's `reason` to the calendar's: `date` → `"open-date"`/`"closed-date"`, `annual` → `"open-annual"`/`"closed-annual"`, `recurring` → `"open-recurring"`/`"closed-recurring"`, `holiday` → `"holiday"` (whether or not the holiday is open, as with `holidayPolicy: "open"`), `weekday` → `"regular"`/`"closed-weekday"`. `"open-annual"` exists only for calendars made this way, since `closedAnnual` of `createCalendar` only closes. `name`, `holiday`, `shiftedFrom` and `rulePath` are the schedule's
+- Holidays, the time zone and `outOfRange` are the schedule's. Diagnose the schedule's options with `diagnoseSchedule`; the calendar itself is not diagnosed. `maxSearchDays` (default 3660) can be given in the options
+- Use `createCalendar` when you only need open or closed; use this when you have a schedule anyway
+
 ### Date and date-time inputs
 
 Every method accepts the following inputs. Returned dates are always `"YYYY-MM-DD"` strings.
@@ -594,7 +625,7 @@ Versioning follows [Semantic Versioning](https://semver.org/). See [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`
+- The reflected data is shown by the provider's `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` (`jp.dataVersion`, `england.confirmedThrough` and so on). The module-level constants `dataVersion` and `confirmedThrough` in `bizdays-toolkit/jp` and `bizdays-toolkit/uk` are deprecated since 0.12.0 and will be removed in 1.0.0
 - Before 1.0.0, minor versions may contain breaking changes. What you need to change when moving between minor versions is listed in the [migration guide](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/migration.md) (Japanese) and in the "移行" (migration) part of each version in the CHANGELOG
 - 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))
 

package/dist/core/calendar.d.ts

@@ -22,7 +22,7 @@ import { type DateString, type Weekday } from "./date.ts";
 import { IssueCollector } from "./errors.ts";
 import { type DateInput } from "./input.ts";
 import { type MonthString } from "./month.ts";
-import { type CompiledSchedule, type DayOfMonth, type EffectivePeriod, type RecurringRule, type HolidayLookup, type HolidaySourceOptions } from "./schedule.ts";
+import { type CompiledSchedule, type DayOfMonth, type EffectivePeriod, type RecurringRule, type HolidayLookup, type HolidaySourceOptions, type Schedule } from "./schedule.ts";
 import type { Holiday } from "./types.ts";
 /**
  * 祝日の扱い。
@@ -93,7 +93,7 @@ export interface CalendarOptions<Kind extends string = string> extends HolidaySo
  * 営業・休業を決めた規則（既知の値）。
  * @public
  */
-export type KnownDayReason = "open-date" | "closed-date" | "closed-annual" | "open-recurring" | "closed-recurring" | "holiday" | "closed-weekday" | "regular";
+export type KnownDayReason = "open-date" | "closed-date" | "open-annual" | "closed-annual" | "open-recurring" | "closed-recurring" | "holiday" | "closed-weekday" | "regular";
 /**
  * 営業・休業を決めた規則。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
  * すべての値を網羅したことを型で確かめたい場合は KnownDayReason を使う。
@@ -116,9 +116,14 @@ export interface DayInfo<Kind extends string = string> {
     readonly holiday?: Holiday<Kind>;
     /** 祝日から振り替えられた繰り返しの規則で決まった場合、振替の元の日付（onHolidayRule: "after-holiday"） */
     readonly shiftedFrom?: DateString;
+    /**
+     * 判定を決めた規則の設定の中の位置（規則の診断の path と同じ形。例: "closedRecurring[0]"）。
+     * 個別の日付・毎年の休業日・繰り返しの規則（振替先を含む）で決まった日にだけ付き、祝日・定休日の曜日で決まった日には付かない
+     */
+    readonly rulePath?: string;
     /**
      * 合成したカレンダー（combineCalendars）で、判定を決めたカレンダーの番号（渡した配列の位置）。
-     * reason・name・shiftedFrom はそのカレンダーの結果。合成していないカレンダーでは付かない
+     * reason・name・shiftedFrom・rulePath はそのカレンダーの結果。合成していないカレンダーでは付かない
      */
     readonly decidedBy?: number;
 }
@@ -241,7 +246,7 @@ export declare function createCalendar<Kind extends string = string>(options?: C
  * 作成済みの営業日カレンダーを合成する。"all" はすべてのカレンダーが営業している日、"any" はいずれかが
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
- * - dayInfo の reason・name・shiftedFrom は、合成結果と同じ判定をした最初のカレンダーの結果で、
+ * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
  *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
@@ -250,4 +255,21 @@ export declare function createCalendar<Kind extends string = string>(options?: C
  * @public
  */
 export declare function combineCalendars<Kind extends string = string>(calendars: readonly Calendar<Kind>[], options: CombineOptions): Calendar<Kind>;
+/**
+ * スケジュール（createSchedule）から営業日カレンダーを作る。isOpen が true を返す値の日を営業日とする。
+ * 営業時間表のような日ごとの値が設定の正本で、営業日の計算（加減算・調整・期日など）も同じ設定から行いたいときに使う
+ * （営業日カレンダーを別に書いて同期を取る必要がなくなる）。
+ *
+ * - isOpen は値だけで決まる純粋な関数であること（日付・時刻・外部の状態を見ない）。営業日の探索は isOpen を繰り返し呼ぶので、
+ *   結果が変わる関数を渡すと探索の結果が呼ぶたびに変わる。日付で変えたい条件は、スケジュールの規則（dates・recurring）に書く
+ * - dayInfo の reason は、スケジュールの reason と営業・休業の組み合わせ（date → "open-date"/"closed-date"、annual → "open-annual"/
+ *   "closed-annual"、recurring → "open-recurring"/"closed-recurring"、holiday → "holiday"、weekday → "regular"/"closed-weekday"）。
+ *   name・holiday・shiftedFrom・rulePath はスケジュールの結果をそのまま引き継ぐ
+ * - 祝日の判定（holiday・isHoliday など）・タイムゾーン・outOfRange はスケジュールのもの。規則の診断（diagnoseSchedule）は
+ *   スケジュールの設定に対して行う
+ * @public
+ */
+export declare function createCalendarFromSchedule<T, Kind extends string = string>(schedule: Schedule<T, Kind>, isOpen: (value: T) => boolean, options?: {
+    readonly maxSearchDays?: number;
+}): Calendar<Kind>;
 export {};

package/dist/core/calendar.js

@@ -22,7 +22,7 @@ import { addDays, daysInMonth, formatDate, fromDayNumber, toDayNumber, } from ".
 import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
 import { parseTimeOfDay, toCivil } from "./input.js";
 import { dayOfMonth, isDayOfMonthValue, parseMonth } from "./month.js";
-import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
+import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, infoOfSchedule, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
     "timeZone",
@@ -100,52 +100,62 @@ export function createCalendar(options = {}) {
     c.throwFirstError();
     const { maxSearchDays } = compiled;
     const schedule = buildSchedule(compiled.schedule);
-    function info(date) {
+    const info = (date) => {
         const day = schedule.dayInfo(date);
-        let reason;
-        // 内部では閉じた型（KnownScheduleReason）で分岐し、値が増えたときの対応漏れを型で検出する
-        const known = day.reason;
-        switch (known) {
-            case "date":
-                reason = day.value ? "open-date" : "closed-date";
-                break;
-            case "annual":
-                reason = "closed-annual";
-                break;
-            case "recurring":
-                reason = day.value ? "open-recurring" : "closed-recurring";
-                break;
-            case "holiday":
-                reason = "holiday";
-                break;
-            case "weekday":
-                reason = day.value ? "regular" : "closed-weekday";
-                break;
-            default: {
-                const unreachable = known;
-                throw plainError("invalid-option", `Unexpected schedule reason: ${String(unreachable)}`);
-            }
+        return dayInfoFromScheduleDay(day, day.value);
+    };
+    return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
+}
+/**
+ * @internal スケジュールの 1 日分の結果（値は営業日か）を、営業日カレンダーの結果に変換する。
+ * reason はスケジュールの reason と営業・休業の組み合わせで決まる。createCalendar の closedAnnual は休業だけなので
+ * "open-annual" にはならないが、createCalendarFromSchedule では annual の値で営業になる日がある
+ */
+function dayInfoFromScheduleDay(day, open) {
+    let reason;
+    // 内部では閉じた型（KnownScheduleReason）で分岐し、値が増えたときの対応漏れを型で検出する
+    const known = day.reason;
+    switch (known) {
+        case "date":
+            reason = open ? "open-date" : "closed-date";
+            break;
+        case "annual":
+            reason = open ? "open-annual" : "closed-annual";
+            break;
+        case "recurring":
+            reason = open ? "open-recurring" : "closed-recurring";
+            break;
+        case "holiday":
+            reason = "holiday";
+            break;
+        case "weekday":
+            reason = open ? "regular" : "closed-weekday";
+            break;
+        default: {
+            const unreachable = known;
+            throw plainError("invalid-option", `Unexpected schedule reason: ${String(unreachable)}`);
         }
-        const result = {
-            date: day.date,
-            weekday: day.weekday,
-            businessDay: day.value,
-            reason,
-        };
-        // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
-        if (day.name !== undefined && day.reason !== "weekday")
-            result.name = day.name;
-        if (day.holiday !== undefined)
-            result.holiday = day.holiday;
-        if (day.shiftedFrom !== undefined)
-            result.shiftedFrom = day.shiftedFrom;
-        return Object.freeze(result);
     }
-    return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
+    const result = {
+        date: day.date,
+        weekday: day.weekday,
+        businessDay: open,
+        reason,
+    };
+    // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
+    if (day.name !== undefined && day.reason !== "weekday")
+        result.name = day.name;
+    if (day.holiday !== undefined)
+        result.holiday = day.holiday;
+    if (day.shiftedFrom !== undefined)
+        result.shiftedFrom = day.shiftedFrom;
+    if (day.rulePath !== undefined)
+        result.rulePath = day.rulePath;
+    return Object.freeze(result);
 }
 /**
  * @internal 祝日を調べる機能と 1 日分の判定から、営業日カレンダーの機能（探索・調整・月の営業日・期日）を組み立てる。
- * createCalendar と combineCalendars で共用する
+ * createCalendar・combineCalendars・createCalendarFromSchedule で共用する
  */
 function buildCalendar(lookup, isOpen, info, maxSearchDays) {
     const dateOf = lookup.dateOf;
@@ -314,7 +324,7 @@ const isCalendarLike = (v) => typeof v === "object" &&
  * 作成済みの営業日カレンダーを合成する。"all" はすべてのカレンダーが営業している日、"any" はいずれかが
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
- * - dayInfo の reason・name・shiftedFrom は、合成結果と同じ判定をした最初のカレンダーの結果で、
+ * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
  *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
@@ -377,8 +387,43 @@ export function combineCalendars(calendars, options) {
             result.holiday = holiday;
         if (base.shiftedFrom !== undefined)
             result.shiftedFrom = base.shiftedFrom;
+        if (base.rulePath !== undefined)
+            result.rulePath = base.rulePath;
         result.decidedBy = decidedBy;
         return Object.freeze(result);
     }
     return buildCalendar(lookup, isOpen, info, maxSearchDays);
 }
+/**
+ * スケジュール（createSchedule）から営業日カレンダーを作る。isOpen が true を返す値の日を営業日とする。
+ * 営業時間表のような日ごとの値が設定の正本で、営業日の計算（加減算・調整・期日など）も同じ設定から行いたいときに使う
+ * （営業日カレンダーを別に書いて同期を取る必要がなくなる）。
+ *
+ * - isOpen は値だけで決まる純粋な関数であること（日付・時刻・外部の状態を見ない）。営業日の探索は isOpen を繰り返し呼ぶので、
+ *   結果が変わる関数を渡すと探索の結果が呼ぶたびに変わる。日付で変えたい条件は、スケジュールの規則（dates・recurring）に書く
+ * - dayInfo の reason は、スケジュールの reason と営業・休業の組み合わせ（date → "open-date"/"closed-date"、annual → "open-annual"/
+ *   "closed-annual"、recurring → "open-recurring"/"closed-recurring"、holiday → "holiday"、weekday → "regular"/"closed-weekday"）。
+ *   name・holiday・shiftedFrom・rulePath はスケジュールの結果をそのまま引き継ぐ
+ * - 祝日の判定（holiday・isHoliday など）・タイムゾーン・outOfRange はスケジュールのもの。規則の診断（diagnoseSchedule）は
+ *   スケジュールの設定に対して行う
+ * @public
+ */
+export function createCalendarFromSchedule(schedule, isOpen, options) {
+    const info = infoOfSchedule(schedule);
+    if (info === undefined) {
+        throw rangeError("invalid-argument", "schedule must be a schedule created by createSchedule");
+    }
+    if (typeof isOpen !== "function") {
+        throw rangeError("invalid-argument", "isOpen must be a function (value) => boolean");
+    }
+    const maxSearchDays = options?.maxSearchDays ?? 3660;
+    if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
+        throw rangeError("invalid-option", "maxSearchDays must be a positive integer");
+    }
+    const open = (date) => isOpen(info(date).value) === true;
+    return buildCalendar(schedule, open, (date) => {
+        const day = info(date);
+        // 変換は value を読まない（営業・休業は open で渡す）ので、boolean の値として扱ってよい
+        return dayInfoFromScheduleDay(day, isOpen(day.value) === true);
+    }, maxSearchDays);
+}

package/dist/core/diagnose.js

@@ -51,6 +51,12 @@ function closestKey(key, known) {
     const sameCase = known.find((k) => k.toLowerCase() === lower);
     if (sameCase !== undefined)
         return sameCase;
+    // 既知のキーの先頭部分（"onHoliday" → "onHolidayRule"）は、短い別のキー（"holiday"）との編集距離より優先する
+    if (key.length >= 4) {
+        const prefixOf = known.find((k) => k.toLowerCase().startsWith(lower));
+        if (prefixOf !== undefined)
+            return prefixOf;
+    }
     const limit = Math.max(1, Math.floor(key.length / 4));
     let best;
     let bestDistance = limit + 1;
@@ -61,11 +67,7 @@ function closestKey(key, known) {
             bestDistance = distance;
         }
     }
-    if (best !== undefined)
-        return best;
-    if (key.length >= 4)
-        return known.find((k) => k.toLowerCase().startsWith(lower));
-    return undefined;
+    return best;
 }
 // ------------------------------------------------------------
 // 調べる期間
@@ -358,48 +360,54 @@ function analyze(c, compiled, isCalendar) {
     });
     // --- 繰り返しの規則: 当てはまる日がない・覆われている ---
     const recurringBits = recurring.map(patternBits);
-    /** 祝日の翌日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
-    const isHolidaySafe = (date) => {
+    /** 祝日・祝日の翌日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
+    const holidayOfSafe = (date) => {
         try {
-            return lookup.holidayOn(date) !== undefined;
+            return lookup.holidayOn(date);
         }
         catch {
-            return false;
+            return undefined;
         }
     };
-    /** 祝日の翌日の規則が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
-    const dayAfterHolidayMatches = (rule) => {
+    /** 祝日に従属する規則（祝日・祝日の翌日）が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
+    const holidayRuleMatches = (rule) => {
         if (source.providers.length === 0 || !window)
             return false;
         let found = false;
-        eachDay(window, (n) => (found = inPeriod(rule, n) && matchPattern(rule, fromDayNumber(n), isHolidaySafe)));
+        eachDay(window, (n) => (found = inPeriod(rule, n) && matchPattern(rule, fromDayNumber(n), holidayOfSafe)));
         return found;
     };
+    /** 集合 a（null はすべて）が集合 b（null はすべて）を含むか */
+    const setCovers = (a, b) => a === null || (b !== null && [...b].every((v) => a.has(v)));
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
-        const matches = rule.dayAfterHoliday
-            ? dayAfterHolidayMatches(rule)
-            : matchesAnyDay(rule, cycle);
+        const holidayBased = rule.holiday || rule.dayAfterHoliday;
+        const matches = holidayBased ? holidayRuleMatches(rule) : matchesAnyDay(rule, cycle);
         if (!matches) {
             unused.add(rule);
-            c.warning("never-matches", rule.path, rule.dayAfterHoliday
+            c.warning("never-matches", rule.path, holidayBased
                 ? source.providers.length === 0
                     ? "This rule matches no day: there are no holidays without a holiday provider"
-                    : "This rule matches no day: no day after a holiday within its effective period"
+                    : 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"
                 : 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.dayAfterHoliday
-                ? r.dayAfterHoliday &&
-                    (r.months === null ||
-                        (rule.months !== null && [...rule.months].every((m) => r.months.has(m))))
-                : !r.dayAfterHoliday && intervalCovers(r, rule) && isSubset(bits, recurringBits[i])));
+            (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 &&
+                        !r.dayAfterHoliday &&
+                        intervalCovers(r, rule) &&
+                        isSubset(bits, recurringBits[i])));
         if (k < 0)
             return;
         unused.add(rule);

package/dist/core/schedule.d.ts

@@ -12,7 +12,8 @@
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
- * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）
+ * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -89,6 +90,7 @@ export interface WeekdayPattern {
     readonly months?: readonly Month[];
     readonly day?: never;
     readonly dayAfterHoliday?: never;
+    readonly holiday?: never;
 }
 /**
  * 毎月の日の繰り返し（例: 毎月 20 日、毎月末日）。その月にない日（2 月 30 日など）は当てはまらない。
@@ -104,6 +106,7 @@ export interface DayOfMonthPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly dayAfterHoliday?: never;
+    readonly holiday?: never;
 }
 /**
  * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
@@ -119,12 +122,33 @@ export interface DayAfterHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly holiday?: never;
+}
+/**
+ * 祝日（提供元の祝日である日）。kinds で祝日の種別を絞れる（省略時はすべての祝日）。
+ * 「祝日の上」の段階（holidayPolicy・スケジュールの holiday より先）で判定し、祝日の既定の扱いの例外を書く
+ * （例: 「2027 年 4 月から祝日も営業」「振替休日は診療」「5 月の祝日は特別営業時間」）。
+ * 当てはまる日は祝日なので、onHolidayRule は指定できない（指定すると invalid-option）。
+ * @public
+ */
+export interface HolidayPattern {
+    readonly holiday: true;
+    /** 当てはめる祝日の種別（Holiday.kind。省略時はすべて） */
+    readonly kinds?: readonly string[];
+    /** 当てはめる月（省略時はすべての月） */
+    readonly months?: readonly Month[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly day?: never;
+    readonly dayAfterHoliday?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern;
+export type RecurringPattern = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | HolidayPattern;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
@@ -237,6 +261,11 @@ export interface ScheduleDay<T, Kind extends string = string> {
     readonly holiday?: Holiday<Kind>;
     /** 祝日から振り替えられた規則で値が決まった場合、振替の元の日付（onHolidayRule: "after-holiday"） */
     readonly shiftedFrom?: DateString;
+    /**
+     * 値を決めた規則の設定の中の位置（規則の診断の path と同じ形。例: "recurring[0]"）。
+     * dates・annual・recurring（振替先を含む）で決まった日にだけ付き、祝日・曜日で決まった日には付かない
+     */
+    readonly rulePath?: string;
 }
 /**
  * 祝日を調べる機能（スケジュールと営業日カレンダーで共通）。
@@ -332,6 +361,10 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly days: ReadonlySet<number> | null;
     /** 祝日の翌日の規則か */
     readonly dayAfterHoliday: boolean;
+    /** 祝日の規則か */
+    readonly holiday: boolean;
+    /** 祝日の規則で絞る種別（null はすべての祝日） */
+    readonly kinds: ReadonlySet<string> | null;
     /** 月の集合（null はすべての月） */
     readonly months: ReadonlySet<number> | null;
     readonly onHolidayRule: OnHolidayRule;
@@ -340,16 +373,16 @@ 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 祝日かを返す関数（祝日の翌日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
-export type IsHoliday = (date: DateString) => boolean;
+/** @internal その日の祝日を返す関数（祝日・祝日の翌日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
+export type HolidayOf = (date: DateString) => Holiday<string> | undefined;
 /**
  * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
  * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
  */
-export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, isHoliday?: IsHoliday): boolean;
+export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf): boolean;
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, isHoliday: IsHoliday): boolean;
+export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf: HolidayOf): boolean;
 /** @internal 祝日の提供元とタイムゾーンの設定を検証した結果 */
 export interface HolidaySource<Kind extends string> {
     readonly providers: readonly HolidayProvider<Kind>[];
@@ -396,7 +429,8 @@ type HolidayLookupInternal<Kind extends string> = ReturnType<typeof createHolida
 export declare function createResolver<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>, lookup: HolidayLookupInternal<Kind>): (date: DateString) => Resolution<T, Kind>;
 /** @internal 期間（両端を含む）の日ごとに fn を呼んだ結果。from が to より後ならエラー */
 export declare function mapDays<R>(from: DateString, to: DateString, fn: (date: DateString) => R): readonly R[];
-/** @internal 検証済みの規則からスケジュールを作る */
+/** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
+export declare function infoOfSchedule<T, Kind extends string>(schedule: Schedule<T, Kind>): ((date: DateString) => ScheduleDay<T, Kind>) | undefined;
 export declare function buildSchedule<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>): Schedule<T, Kind>;
 /**
  * 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る。

package/dist/core/schedule.js

@@ -12,7 +12,8 @@
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
- * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）
+ * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -210,10 +211,12 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const hasWeekday = "weekday" in entry;
         const hasDay = "day" in entry;
         const hasAfter = "dayAfterHoliday" in entry;
-        if (Number(hasWeekday) + Number(hasDay) + Number(hasAfter) !== 1) {
-            c.error("invalid-option", p, 'must have exactly one of "weekday", "day" or "dayAfterHoliday"');
+        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"');
             return;
         }
+        let kinds = null;
         let ok = true;
         let weekday = null;
         let nth = null;
@@ -278,16 +281,34 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                     ok = false;
             }
             else {
-                if (entry["dayAfterHoliday"] !== true) {
-                    c.error("invalid-option", `${p}.dayAfterHoliday`, "must be true");
+                const key = hasAfter ? "dayAfterHoliday" : "holiday";
+                if (entry[key] !== true) {
+                    c.error("invalid-option", `${p}.${key}`, "must be true");
                     ok = false;
                 }
                 if ("onHolidayRule" in entry) {
-                    c.error("invalid-option", `${p}.onHolidayRule`, 'cannot be used with "dayAfterHoliday" (the day after a holiday is never a holiday)');
+                    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)');
                     ok = false;
                 }
+                if (hasHoliday && entry["kinds"] !== undefined && !Array.isArray(entry["kinds"])) {
+                    c.error("invalid-option", `${p}.kinds`, "must be a non-empty array of holiday kinds (Holiday.kind)");
+                    ok = false;
+                }
+                else if (hasHoliday && entry["kinds"] !== undefined) {
+                    const set = checkSet(c, `${p}.kinds`, entry["kinds"], (v) => typeof v === "string" && v.length > 0, "a non-empty string (Holiday.kind)");
+                    if (set)
+                        kinds = set;
+                    else
+                        ok = false;
+                }
             }
         }
+        if (!hasHoliday && "kinds" in entry) {
+            c.error("invalid-option", `${p}.kinds`, '"kinds" can be used only with "holiday"');
+            ok = false;
+        }
         let months = null;
         if (entry["months"] !== undefined) {
             if (!Array.isArray(entry["months"])) {
@@ -302,7 +323,8 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                     ok = false;
             }
         }
-        const onHoliday = entry["onHolidayRule"] ?? "under-holiday";
+        // 祝日の規則は「祝日の上」の段階で判定する（当てはまる日は祝日なので、祝日の下・振替は意味を持たない）
+        const onHoliday = entry["onHolidayRule"] ?? (hasHoliday ? "over-holiday" : "under-holiday");
         if (!ON_HOLIDAY_RULES.includes(onHoliday)) {
             c.error("invalid-option", `${p}.onHolidayRule`, `must be one of ${ON_HOLIDAY_RULES.map((v) => `"${v}"`).join(", ")}`);
             ok = false;
@@ -317,6 +339,8 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 anchor,
                 days,
                 dayAfterHoliday: hasAfter,
+                holiday: hasHoliday,
+                kinds,
                 months,
                 onHolidayRule: onHoliday,
                 value,
@@ -332,12 +356,18 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
  * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
  */
-export function matchPattern(rule, date, isHoliday) {
+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 isHoliday !== undefined && !isHoliday(date) && isHoliday(addDays(date, -1));
+        return (holidayOf !== undefined &&
+            holidayOf(date) === undefined &&
+            holidayOf(addDays(date, -1)) !== undefined);
     }
     const dim = daysInMonth(year, month);
     if (rule.weekday !== null) {
@@ -352,8 +382,8 @@ export function matchPattern(rule, date, isHoliday) {
     return rule.days.has(day) || (rule.days.has(-1) && day === dim);
 }
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export function matchRecurring(rule, date, isHoliday) {
-    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, isHoliday);
+export function matchRecurring(rule, date, holidayOf) {
+    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, holidayOf);
 }
 /** 規則の value を取り出す（value が必須の規則用） */
 function requiredValue(c) {
@@ -586,6 +616,8 @@ export const RECURRING_RULE_KEYS = [
     "anchor",
     "day",
     "dayAfterHoliday",
+    "holiday",
+    "kinds",
     "months",
     "name",
     "onHolidayRule",
@@ -648,15 +680,16 @@ export function matchAnnual(rule, date) {
 export function createResolver(compiled, lookup) {
     const { weekly, holiday: holidayRule, annual, dates, recurring } = compiled;
     const hasShift = recurring.some((r) => r.onHolidayRule === "after-holiday");
-    /** 振替の判断に使う「祝日」か。提供元の対応年の外は祝日でないとみなす（振替元をさかのぼる途中で範囲を出る場合のため） */
-    function isHolidaySafe(date) {
+    /** 振替・祝日の規則の判断に使う祝日。提供元の対応年の外は祝日でないとみなす（振替元をさかのぼる途中で範囲を出る場合のため） */
+    function holidayOfSafe(date) {
         try {
-            return lookup.holidayOn(date) !== undefined;
+            return lookup.holidayOn(date);
         }
         catch {
-            return false;
+            return undefined;
         }
     }
+    const isHolidaySafe = (date) => holidayOfSafe(date) !== undefined;
     /**
      * "after-holiday" の規則が、date（祝日でない日）に振り替えられてきたか。
      * date の前日からさかのぼって祝日が続く間に、規則に当たる日があれば、その日付を返す
@@ -666,7 +699,7 @@ export function createResolver(compiled, lookup) {
             const prev = addDays(date, -k);
             if (!isHolidaySafe(prev))
                 return undefined;
-            if (matchRecurring(rule, prev, isHolidaySafe))
+            if (matchRecurring(rule, prev, holidayOfSafe))
                 return prev;
         }
         return undefined;
@@ -688,6 +721,8 @@ export function createResolver(compiled, lookup) {
                 result.holiday = holiday;
             if (shiftedFrom !== undefined)
                 result.shiftedFrom = shiftedFrom;
+            if (rule !== null)
+                result.rulePath = rule.path;
             return { day: Object.freeze(result), rule };
         };
         // 1. 個別の日付  2. 毎年の月日
@@ -698,8 +733,8 @@ export function createResolver(compiled, lookup) {
         if (byAnnual)
             return make(byAnnual.value, "annual", byAnnual, byAnnual.name);
         if (holiday) {
-            // 3. 祝日の上（"over-holiday"）
-            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, isHolidaySafe));
+            // 3. 祝日の上（"over-holiday"。祝日の規則 { holiday: true } もここ）
+            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, holidayOfSafe));
             if (over)
                 return make(over.value, "recurring", over, over.name);
             // 4. 祝日
@@ -709,14 +744,14 @@ export function createResolver(compiled, lookup) {
             }
             // 祝日の扱いが「曜日どおり」なら、祝日の下（"under-holiday"）の規則も当てはまる。
             // "after-holiday" の規則は祝日には当てはめない（振り替える）
-            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, isHolidaySafe));
+            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, holidayOfSafe));
             if (under)
                 return make(under.value, "recurring", under, under.name);
             return make(weekly[weekday], "weekday", null, undefined);
         }
         // 5. 繰り返しの規則（祝日でない日。配列で先に書いたものが優先）。振替先も同じ段階で判定する
         for (const rule of recurring) {
-            if (matchRecurring(rule, date, isHolidaySafe))
+            if (matchRecurring(rule, date, holidayOfSafe))
                 return make(rule.value, "recurring", rule, rule.name);
             if (hasShift && rule.onHolidayRule === "after-holiday") {
                 const origin = shiftedOrigin(rule, date);
@@ -739,6 +774,15 @@ export function mapDays(from, to, fn) {
     return Object.freeze(result);
 }
 /** @internal 検証済みの規則からスケジュールを作る */
+/**
+ * @internal スケジュールの内部の判定（暦日の文字列を直接受け取る）。createCalendarFromSchedule が、公開メソッド
+ * （入力の解析を通る）を経由せずに 1 日分の結果を得るために使う。スケジュールごとに作成時に登録する
+ */
+const internalInfo = new WeakMap();
+/** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
+export function infoOfSchedule(schedule) {
+    return internalInfo.get(schedule);
+}
 export function buildSchedule(compiled) {
     const lookup = createHolidayLookup(compiled.source);
     const resolve = createResolver(compiled, lookup);
@@ -758,7 +802,9 @@ export function buildSchedule(compiled) {
         dayInfo: (input) => info(lookup.dateOf(input)),
         daysBetween: (from, to) => mapDays(lookup.dateOf(from), lookup.dateOf(to), info),
     };
-    return Object.freeze(schedule);
+    Object.freeze(schedule);
+    internalInfo.set(schedule, info);
+    return schedule;
 }
 /**
  * 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る。

package/dist/index.d.ts

@@ -7,8 +7,8 @@
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
-export { combineCalendars, createCalendar, 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 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 { 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 { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
 export { closingMonth, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";

package/dist/index.js

@@ -7,7 +7,7 @@
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
-export { combineCalendars, createCalendar, } from "./core/calendar.js";
+export { combineCalendars, createCalendar, createCalendarFromSchedule, } from "./core/calendar.js";
 export { createSchedule, } from "./core/schedule.js";
 export { addDays, diffDays, isValidDate, weekdayOf, } from "./core/date.js";
 export { closingMonth, monthOf } from "./core/month.js";

package/dist/jp/index.d.ts

@@ -67,11 +67,13 @@ export declare function toJapanDateTime(input: DateTimeInput): CivilDateTimePart
 export declare function toJapanDateTime(input: DateInput): CivilDateTimeParts;
 /**
  * 反映済みの官報の年月。
+ * @deprecated 0.12.0 で非推奨。提供元の項目 jp.dataVersion（同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare const dataVersion: string;
 /**
  * 春分・秋分の日が官報で確定している最後の年。
+ * @deprecated 0.12.0 で非推奨。提供元の項目 jp.confirmedThrough（同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare const confirmedThrough: number;

package/dist/jp/index.js

@@ -76,11 +76,13 @@ export function toJapanDateTime(input) {
 }
 /**
  * 反映済みの官報の年月。
+ * @deprecated 0.12.0 で非推奨。提供元の項目 jp.dataVersion（同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export const dataVersion = DATA_VERSION;
 /**
  * 春分・秋分の日が官報で確定している最後の年。
+ * @deprecated 0.12.0 で非推奨。提供元の項目 jp.confirmedThrough（同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export const confirmedThrough = CONFIRMED_THROUGH;

package/dist/uk/index.d.ts

@@ -39,11 +39,13 @@ export declare const scotland: HolidayProvider<UkHolidayKind>;
 export declare const northernIreland: HolidayProvider<UkHolidayKind>;
 /**
  * 反映済みの GOV.UK のデータの年月。
+ * @deprecated 0.12.0 で非推奨。提供元の項目（england.dataVersion など。4 つの提供元で同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare const dataVersion: string;
 /**
  * GOV.UK が日付を公表している最後の年（それより後は規則による予測で confirmed: false）。
+ * @deprecated 0.12.0 で非推奨。提供元の項目（england.confirmedThrough など。4 つの提供元で同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare const confirmedThrough: number;

package/dist/uk/index.js

@@ -73,11 +73,13 @@ export const scotland = provider("GB-SCT", "scotland");
 export const northernIreland = provider("GB-NIR", "northern-ireland");
 /**
  * 反映済みの GOV.UK のデータの年月。
+ * @deprecated 0.12.0 で非推奨。提供元の項目（england.dataVersion など。4 つの提供元で同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export const dataVersion = DATA_VERSION;
 /**
  * GOV.UK が日付を公表している最後の年（それより後は規則による予測で confirmed: false）。
+ * @deprecated 0.12.0 で非推奨。提供元の項目（england.confirmedThrough など。4 つの提供元で同じ値）に移行する（docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export const confirmedThrough = CONFIRMED_THROUGH;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.11.1",
+  "version": "0.13.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",