bizdays-toolkit 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -4,6 +4,36 @@
 
 ## [Unreleased]
 
+## [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 +330,8 @@
 
 - 日本: 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.12.0...HEAD
+[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

@@ -27,7 +27,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **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
 - **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 8.8 KB min+gzip (about 10.6 KB with Japanese holidays, about 10.5 KB with UK bank holidays; measured for 0.12.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
@@ -114,7 +114,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 +127,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 +135,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 +159,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 +170,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 +178,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 +216,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 +254,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 +421,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 +436,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.
 
@@ -594,7 +597,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

@@ -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

package/dist/core/calendar.js

@@ -139,6 +139,8 @@ export function createCalendar(options = {}) {
             result.holiday = day.holiday;
         if (day.shiftedFrom !== undefined)
             result.shiftedFrom = day.shiftedFrom;
+        if (day.rulePath !== undefined)
+            result.rulePath = day.rulePath;
         return Object.freeze(result);
     }
     return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
@@ -314,7 +316,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,6 +379,8 @@ 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);
     }

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>[];

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);

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は 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 { 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/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.12.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",