bizdays-toolkit 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,31 @@
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-10-19
+
+### 移行
+
+作業は要りません（繰り返しの規則の新しい形と、カレンダーを合成する関数の追加）。
+
+### Added
+
+- 繰り返しの規則（`closedRecurring`・`openRecurring`・スケジュールの `recurring`）に、祝日の翌日の形 `{ dayAfterHoliday: true }` を追加した。前日が祝日でその日自身は祝日でない日（連休なら連休が明けた日）に当てはまる。「祝日」は提供元の祝日だけで、休業日の設定は含めない。当てはまる日は祝日でないので `onHolidayRule` は指定できない（`invalid-option`）。`months`・`name`・有効期間と組み合わせられる。型 `DayAfterHolidayPattern` を追加した
+- 作成済みの営業日カレンダーを合成する `combineCalendars(calendars, { businessDay: "all" | "any", maxSearchDays? })` を追加した。すべてが営業している日（`"all"`）、またはいずれかが営業している日（`"any"`）を営業日とする通常のカレンダーを返し、営業日の加減算・調整・期日などが合成結果で動く。`dayInfo` の `reason`・`name`・`shiftedFrom` は合成結果と同じ判定をした最初のカレンダーの結果で、その番号を新しい項目 `decidedBy` で返す。祝日は各カレンダーの提供元の和集合で判定する。タイムゾーンが違えば `time-zone-conflict`、2 つ未満・同じカレンダーの重複は `invalid-argument`。型 `CombineOptions` を追加した
+- `DayInfo` に省略可能な `decidedBy`（合成したカレンダーで判定を決めたカレンダーの番号）を追加した。合成していないカレンダーでは付かない
+- `HolidayLookup`（営業日カレンダー・スケジュール）に `outOfRange`（設定の値）を追加した。合成するときに引き継ぐため
+
+### Changed
+
+- 規則の診断で、祝日の翌日の規則を扱えるようにした。提供元のない設定では `never-matches`。`shadowed` は祝日の翌日の規則どうし（`months` と有効期間）でだけ調べ、曜日の規則との重なりは `redundant` で見つける
+- 繰り返しの規則の形の誤りのメッセージを、`"weekday"`・`"day"`・`"dayAfterHoliday"` のうち 1 つだけを持つ、に改めた（code は `invalid-option` のまま）
+- README: 繰り返しの規則の節に祝日の翌日を、新しい節「カレンダーの合成」を足した。サイズの値を測り直した（ルート約 8.6KB・日本の祝日込み約 10.3KB・英国の祝日込み約 10.2KB。0.11.0 で測定）
+
+### 開発
+
+- サイズの上限（`size-limits.json`）を上げた。ルート 17,500 → 19,500、`./jp` 20,500 → 22,500、`./diagnose` 24,000 → 26,000（gzip）。祝日の翌日の規則と `combineCalendars`（ルートで約 1.7KB）と、診断の祝日の翌日への対応（約 1.9KB）のため
+- `createCalendar` の営業日の探索・調整・月の営業日の実装を、祝日を調べる機能と 1 日分の判定を引数に取る内部関数（`buildCalendar`）に切り出し、`combineCalendars` と共用した。公開 API と結果は変わらない
+- 性質のテストに祝日の翌日の規則を加えた
+
 ## [0.10.0] - 2026-10-19
 
 ### 移行
@@ -266,7 +291,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.10.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.0...HEAD
+[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
 [0.9.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.1...v0.9.0

package/README.md

@@ -20,13 +20,14 @@ A business-day calendar that combines public holidays with company or store clos
 
 - **Japanese holidays verified day by day against the Cabinet Office data**: from 1955 through the latest year announced in the Official Gazette, every date in the Cabinet Office "National Holidays" CSV is checked in the tests (substitute holidays, citizens' holidays, holidays for imperial ceremonies and the Olympic moves included)
 - **UK bank holidays verified day by day against GOV.UK**: choose England, Wales, Scotland or Northern Ireland. From 2012 through the last year GOV.UK has published, every date and name is checked against the GOV.UK data in the tests, and differences are watched daily
-- **Recurring rules**: rules such as "closed on the 3rd Wednesday", "closed every other Wednesday", "stocktaking on the last day of the month" or "closed on Mondays (on the next weekday if Monday is a holiday)", together with what happens when they fall on a holiday (follow the holiday, apply anyway, or move to the next day). Rules can have an effective period, so "closed on Tuesdays instead of Mondays from April 2027" is one calendar
+- **Recurring rules**: rules such as "closed on the 3rd Wednesday", "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", together with what happens when they fall on a holiday (follow the holiday, apply anyway, or move to the next day). Rules can have an effective period, so "closed on Tuesdays instead of Mondays from April 2027" is one calendar
 - **Day-by-day values (e.g. store hours)**: values that change by weekday, holiday and specific date, such as "closed on Tuesdays, Sunday hours on holidays, closed on New Year's Day, short hours on New Year's Eve", are looked up with the same rules
 - **Option diagnostics**: `diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` list rules that can never apply, rules whose removal changes nothing, typos in option keys, calendars with no business day and more, without throwing. One line in your tests keeps a change of settings from silently killing a rule
 - **Month-based due dates**: due dates such as "closing on the 20th, paid on the 10th of the next month (next business day if closed)" or "the last business day of the month", with the four adjustment conventions used in finance (following, preceding, modified-following, modified-preceding)
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
+- **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 7.9 KB min+gzip (about 9.8 KB with Japanese holidays, about 9.6 KB with UK bank holidays; measured for 0.10.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.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
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -134,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)
+### Recurring rules (weekly, every other week, nth weekday, day of month, 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" or "closed on Mondays (on the next weekday if Monday is 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)" or "closed on the day after a holiday" go in `closedRecurring` and `openRecurring`.
 
 ```ts
 const museum = createCalendar({
@@ -151,6 +152,7 @@ const museum = createCalendar({
       name: "Closed on the 3rd Wednesday in February and August",
     },
     { day: -1, name: "Stocktaking", onHolidayRule: "over-holiday" }, // closed even on holidays
+    { dayAfterHoliday: true, name: "Closed on the day after a holiday" },
   ],
 });
 
@@ -158,6 +160,8 @@ 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" }
+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)
 ```
 
 | Pattern                                             | Meaning                                                                                                              |
@@ -166,13 +170,15 @@ museum.dayInfo("2026-10-13");
 | `{ 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                                      |
+| `{ 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) |
 
 - **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`
-- Among recurring rules, the one written first in the array wins, and `openRecurring` wins over `closedRecurring`
+- **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
 
 **Effective periods** (`effectiveFrom`, `effectiveTo`) let one calendar represent a change of rules and still reproduce past dates. They go on recurring rules and on annual closures (`closedAnnual` in object form).
 
@@ -222,6 +228,43 @@ const hours = createSchedule<Hours>({
 });
 ```
 
+### Combining calendars
+
+`combineCalendars` makes one calendar out of several: the days on which **all** of them are open (`businessDay: "all"`), or on which **any** of them is open (`"any"`). The result is an ordinary calendar, so business-day arithmetic, `adjust`, `dueDate` and the rest work on the combination.
+
+```ts
+import { combineCalendars, createCalendar } from "bizdays-toolkit";
+import { jp } from "bizdays-toolkit/jp";
+
+const company = createCalendar({
+  holidays: jp,
+  closedWeekdays: [0, 6],
+  closedAnnual: [{ from: "12-29", to: "01-03", name: "New Year closure" }],
+});
+const bank = createCalendar({
+  holidays: jp,
+  closedWeekdays: [0, 6],
+  closedAnnual: [{ from: "12-31", to: "01-03", name: "Bank holiday period" }],
+});
+
+// A remittance is processed only on days when both the company and the bank are open
+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 }
+
+// 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
+- 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
+
+Combining options instead would not work: a specific open day (`openDates`) in one set of options would override closures in the other, and wrapping one calendar as a holiday provider of the other would turn its closures into "holidays" (`isHoliday` would be true, and `holidayPolicy: "open"` would open on them).
+
 ### Common recipes
 
 **Treat citizens' holidays (days between two holidays) as business days**: wrap the holiday provider and filter by kind.
@@ -474,21 +517,22 @@ diagnoseCalendar({
 // ]
 ```
 
-| `severity` | `code`                       | Meaning                                                                                                                                                            |
-| ---------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `error`    | The same codes as exceptions | Errors that make `createCalendar` or `createSchedule` throw. Creation stops at the first one; diagnostics return them all                                          |
-| `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                     |
-| `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                             |
-| `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                            |
-| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`, or a 5th Wednesday with an effective period that has none)                               |
-| `warning`  | `out-of-range`               | A specific date, or the effective period of a rule, outside the supported years of the holiday provider (`relatedPath`)                                            |
-| `warning`  | `no-business-day`            | No business day at all (calendars only; searching for a business day throws)                                                                                       |
-| `info`     | `redundant`                  | A rule whose removal changes nothing (covered by a combination of earlier rules, same as a closed weekday, the same value as the weekday in a schedule, and so on) |
+| `severity` | `code`                       | Meaning                                                                                                                                                                            |
+| ---------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `error`    | The same codes as exceptions | Errors that make `createCalendar` or `createSchedule` throw. Creation stops at the first one; diagnostics return them all                                                          |
+| `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                                     |
+| `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                                             |
+| `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                                            |
+| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`, a 5th Wednesday with an effective period that has none, or `dayAfterHoliday` without a holiday provider) |
+| `warning`  | `out-of-range`               | A specific date, or the effective period of a rule, outside the supported years of the holiday provider (`relatedPath`)                                                            |
+| `warning`  | `no-business-day`            | No business day at all (calendars only; searching for a business day throws)                                                                                                       |
+| `info`     | `redundant`                  | A rule whose removal changes nothing (covered by a combination of earlier rules, same as a closed weekday, the same value as the weekday in a schedule, and so on)                 |
 
 - Branch on `code`. `message` is in English and its wording may change. Future versions may add codes
 - When there is an `error`, the rule relation checks (`shadowed`, `redundant` and so on) are skipped
 - `shadowed` compares only rules of the same type (specific dates, annual dates, recurring rules). The order of evaluation is fixed, so rules unused across types are found as `redundant`. Specific open days (`openDates`) and specific closed days (`closedDates`) are of the same type, and a closed day covered by an earlier open day is `shadowed`
 - `shadowed` for recurring rules also considers `onHolidayRule`. For example, an `"under-holiday"` rule does not cover an `"over-holiday"` rule on the same days (the later rule applies on holidays)
+- `shadowed` for `dayAfterHoliday` rules is checked only against other `dayAfterHoliday` rules (by `months` and period), because which days they match depend on the holidays of each year; overlap with weekday rules is found as `redundant`
 - `shadowed` for rules with effective periods also requires the earlier rule's period to contain the later rule's period, and for `interval` rules the earlier rule's cycle to contain the later one (a weekly rule covers an every-other-week rule; two every-other-week rules with opposite phases do not cover each other)
 - `redundant` compares the results with and without the rule day by day. Specific dates are checked over their range; annual dates and recurring rules are checked, with specific dates removed, over the holiday provider's supported years (1955–2099 for Japan), or 2001–2028 without a provider (28 years cover every combination of weekday and date; with `interval` rules the range is extended to the length of their cycle, such as 56 years for every other week). Effective periods outside that range are checked as well (with `outOfRange: "throw"`, only within the supported years). `message` names the years checked. Schedule values are compared by content for arrays and plain objects, and by identity otherwise (such as `Date`)
 - With Japanese holidays, checking every day takes a few hundred milliseconds. Use it in tests or at startup, not per request. As a development and test tool, it lives in a subpath so it stays out of your app's main bundle

package/dist/core/calendar.d.ts

@@ -15,6 +15,8 @@
  * 祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）
  *
  * 内部では、営業日かどうか（真偽値）を返すスケジュール（createSchedule）として作っている。
+ * 営業日の探索・調整・月の営業日などの機能は buildCalendar に切り出し、作成済みのカレンダーを
+ * 合成する combineCalendars（両方が営業している日・どちらかが営業している日）でも同じ実装を使う。
  */
 import { type DateString, type Weekday } from "./date.ts";
 import { IssueCollector } from "./errors.ts";
@@ -114,6 +116,24 @@ export interface DayInfo<Kind extends string = string> {
     readonly holiday?: Holiday<Kind>;
     /** 祝日から振り替えられた繰り返しの規則で決まった場合、振替の元の日付（onHolidayRule: "after-holiday"） */
     readonly shiftedFrom?: DateString;
+    /**
+     * 合成したカレンダー（combineCalendars）で、判定を決めたカレンダーの番号（渡した配列の位置）。
+     * reason・name・shiftedFrom はそのカレンダーの結果。合成していないカレンダーでは付かない
+     */
+    readonly decidedBy?: number;
+}
+/**
+ * カレンダーの合成のオプション。
+ * @public
+ */
+export interface CombineOptions {
+    /**
+     * 営業日とする条件。"all": すべてのカレンダーが営業日（例: 自社と銀行の両方が営業している日）/
+     * "any": いずれかのカレンダーが営業日（例: 複数の店舗のどこかが開いている日）
+     */
+    readonly businessDay: "all" | "any";
+    /** 営業日を探すときに調べる最大日数（既定: 3660）。超えたら Error */
+    readonly maxSearchDays?: number;
 }
 /**
  * 営業日を探すときのオプション。
@@ -217,4 +237,17 @@ export declare function compileCalendarOptions<Kind extends string>(c: IssueColl
  * @public
  */
 export declare function createCalendar<Kind extends string = string>(options?: CalendarOptions<Kind>): Calendar<Kind>;
+/**
+ * 作成済みの営業日カレンダーを合成する。"all" はすべてのカレンダーが営業している日、"any" はいずれかが
+ * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
+ *
+ * - dayInfo の reason・name・shiftedFrom は、合成結果と同じ判定をした最初のカレンダーの結果で、
+ *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
+ *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
+ * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、
+ *   元のカレンダーの設定をそれぞれ診断する
+ * @public
+ */
+export declare function combineCalendars<Kind extends string = string>(calendars: readonly Calendar<Kind>[], options: CombineOptions): Calendar<Kind>;
 export {};

package/dist/core/calendar.js

@@ -15,12 +15,14 @@
  * 祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）
  *
  * 内部では、営業日かどうか（真偽値）を返すスケジュール（createSchedule）として作っている。
+ * 営業日の探索・調整・月の営業日などの機能は buildCalendar に切り出し、作成済みのカレンダーを
+ * 合成する combineCalendars（両方が営業している日・どちらかが営業している日）でも同じ実装を使う。
  */
 import { addDays, daysInMonth, formatDate, fromDayNumber, toDayNumber, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
 import { parseTimeOfDay, toCivil } from "./input.js";
 import { dayOfMonth, isDayOfMonthValue, parseMonth } from "./month.js";
-import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
+import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
     "timeZone",
@@ -139,8 +141,14 @@ export function createCalendar(options = {}) {
             result.shiftedFrom = day.shiftedFrom;
         return Object.freeze(result);
     }
-    const isOpen = (date) => schedule.valueOn(date);
-    const dateOf = schedule.dateOf;
+    return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
+}
+/**
+ * @internal 祝日を調べる機能と 1 日分の判定から、営業日カレンダーの機能（探索・調整・月の営業日・期日）を組み立てる。
+ * createCalendar と combineCalendars で共用する
+ */
+function buildCalendar(lookup, isOpen, info, maxSearchDays) {
+    const dateOf = lookup.dateOf;
     function search(start, step) {
         let n = toDayNumber(start);
         for (let i = 0; i < maxSearchDays; i++, n += step) {
@@ -226,22 +234,23 @@ export function createCalendar(options = {}) {
         return found;
     }
     const calendar = {
-        timeZone: schedule.timeZone,
-        providers: schedule.providers,
+        timeZone: lookup.timeZone,
+        providers: lookup.providers,
+        outOfRange: lookup.outOfRange,
         dateOf,
-        civilOf: schedule.civilOf,
-        today: schedule.today,
-        isHoliday: schedule.isHoliday,
-        getHoliday: schedule.getHoliday,
-        holidaysInYear: schedule.holidaysInYear,
-        holidaysBetween: schedule.holidaysBetween,
+        civilOf: lookup.civilOf,
+        today: lookup.today,
+        isHoliday: lookup.isHoliday,
+        getHoliday: lookup.getHoliday,
+        holidaysInYear: lookup.holidaysInYear,
+        holidaysBetween: lookup.holidaysBetween,
         dayInfo: (input) => info(dateOf(input)),
         daysBetween: (from, to) => mapDays(dateOf(from), dateOf(to), info),
         isBusinessDay: (input) => isOpen(dateOf(input)),
         nextBusinessDay: (input) => search(addDays(dateOf(input), 1), 1),
         previousBusinessDay: (input) => search(addDays(dateOf(input), -1), -1),
         businessDayOnOrAfter(input, opts = {}) {
-            const civil = toCivil(input, schedule.timeZone);
+            const civil = toCivil(input, lookup.timeZone);
             let start = civil.date;
             if (opts.cutoff !== undefined) {
                 const cutoff = parseTimeOfDay(opts.cutoff);
@@ -295,3 +304,81 @@ export function createCalendar(options = {}) {
     };
     return Object.freeze(calendar);
 }
+const isCalendarLike = (v) => typeof v === "object" &&
+    v !== null &&
+    typeof v.dayInfo === "function" &&
+    typeof v.isBusinessDay === "function" &&
+    typeof v.timeZone === "string" &&
+    Array.isArray(v.providers);
+/**
+ * 作成済みの営業日カレンダーを合成する。"all" はすべてのカレンダーが営業している日、"any" はいずれかが
+ * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
+ *
+ * - dayInfo の reason・name・shiftedFrom は、合成結果と同じ判定をした最初のカレンダーの結果で、
+ *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
+ *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
+ * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、
+ *   元のカレンダーの設定をそれぞれ診断する
+ * @public
+ */
+export function combineCalendars(calendars, options) {
+    if (!Array.isArray(calendars) || calendars.length < 2) {
+        throw rangeError("invalid-argument", "calendars must be an array of two or more calendars");
+    }
+    calendars.forEach((c, i) => {
+        if (!isCalendarLike(c))
+            throw rangeError("invalid-argument", `calendars[${i}] is not a calendar`);
+        if (calendars.indexOf(c) !== i) {
+            throw rangeError("invalid-argument", `calendars[${i}] is the same calendar as calendars[${calendars.indexOf(c)}]`);
+        }
+    });
+    const mode = options?.businessDay;
+    if (mode !== "all" && mode !== "any") {
+        throw rangeError("invalid-option", 'businessDay must be "all" or "any"');
+    }
+    const maxSearchDays = options.maxSearchDays ?? 3660;
+    if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
+        throw rangeError("invalid-option", "maxSearchDays must be a positive integer");
+    }
+    const zones = [...new Set(calendars.map((c) => c.timeZone))];
+    if (zones.length > 1) {
+        throw rangeError("time-zone-conflict", `Calendars use different time zones (${zones.join(", ")}); combine calendars with the same time zone`);
+    }
+    const providers = [];
+    for (const c of calendars)
+        for (const p of c.providers)
+            if (!providers.includes(p))
+                providers.push(p);
+    const lookup = createHolidayLookup({
+        providers: Object.freeze(providers),
+        timeZone: zones[0],
+        outOfRange: calendars.every((c) => c.outOfRange === "ignore") ? "ignore" : "throw",
+    });
+    const isOpen = (date) => mode === "all"
+        ? calendars.every((c) => c.isBusinessDay(date))
+        : calendars.some((c) => c.isBusinessDay(date));
+    function info(date) {
+        const results = calendars.map((c) => c.dayInfo(date));
+        const open = mode === "all" ? results.every((r) => r.businessDay) : results.some((r) => r.businessDay);
+        // 合成結果と同じ判定をした最初のカレンダー（"all" で休業なら最初に休みのもの、営業ならすべて営業なので 0 番）
+        const decidedBy = results.findIndex((r) => r.businessDay === open);
+        const base = results[decidedBy];
+        const result = {
+            date,
+            weekday: base.weekday,
+            businessDay: open,
+            reason: base.reason,
+        };
+        if (base.name !== undefined)
+            result.name = base.name;
+        const holiday = lookup.holidayOn(date);
+        if (holiday !== undefined)
+            result.holiday = holiday;
+        if (base.shiftedFrom !== undefined)
+            result.shiftedFrom = base.shiftedFrom;
+        result.decidedBy = decidedBy;
+        return Object.freeze(result);
+    }
+    return buildCalendar(lookup, isOpen, info, maxSearchDays);
+}

package/dist/core/diagnose.d.ts

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

package/dist/core/diagnose.js

@@ -8,7 +8,7 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、など）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則
@@ -22,7 +22,7 @@
 import { daysInMonth, fromDayNumber, parseDate, toDayNumber } from "./date.js";
 import { compileCalendarOptions } from "./calendar.js";
 import { IssueCollector } from "./errors.js";
-import { compileScheduleOptions, createHolidayLookup, createResolver, matchMonthDay, matchPattern, } from "./schedule.js";
+import { compileScheduleOptions, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
 // ------------------------------------------------------------
 // 知らないキーの候補
 // ------------------------------------------------------------
@@ -358,20 +358,48 @@ function analyze(c, compiled, isCalendar) {
     });
     // --- 繰り返しの規則: 当てはまる日がない・覆われている ---
     const recurringBits = recurring.map(patternBits);
+    /** 祝日の翌日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
+    const isHolidaySafe = (date) => {
+        try {
+            return lookup.holidayOn(date) !== undefined;
+        }
+        catch {
+            return false;
+        }
+    };
+    /** 祝日の翌日の規則が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
+    const dayAfterHolidayMatches = (rule) => {
+        if (source.providers.length === 0 || !window)
+            return false;
+        let found = false;
+        eachDay(window, (n) => (found = inPeriod(rule, n) && matchPattern(rule, fromDayNumber(n), isHolidaySafe)));
+        return found;
+    };
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
-        if (!matchesAnyDay(rule, cycle)) {
+        const matches = rule.dayAfterHoliday
+            ? dayAfterHolidayMatches(rule)
+            : matchesAnyDay(rule, cycle);
+        if (!matches) {
             unused.add(rule);
-            c.warning("never-matches", rule.path, 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");
+            c.warning("never-matches", rule.path, rule.dayAfterHoliday
+                ? 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.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) &&
-            intervalCovers(r, rule) &&
-            isSubset(bits, recurringBits[i]));
+            (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])));
         if (k < 0)
             return;
         unused.add(rule);

package/dist/core/schedule.d.ts

@@ -11,7 +11,8 @@
  *
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
- * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ
+ * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
+ * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -87,6 +88,7 @@ export interface WeekdayPattern {
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly day?: never;
+    readonly dayAfterHoliday?: never;
 }
 /**
  * 毎月の日の繰り返し（例: 毎月 20 日、毎月末日）。その月にない日（2 月 30 日など）は当てはまらない。
@@ -101,12 +103,28 @@ export interface DayOfMonthPattern {
     readonly nth?: never;
     readonly interval?: never;
     readonly anchor?: never;
+    readonly dayAfterHoliday?: never;
+}
+/**
+ * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
+ * 当てはまる日は祝日でないので、onHolidayRule は指定できない（指定すると invalid-option）。
+ * @public
+ */
+export interface DayAfterHolidayPattern {
+    readonly dayAfterHoliday: true;
+    /** 当てはめる月（翌日の月。省略時はすべての月） */
+    readonly months?: readonly Month[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly day?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern = WeekdayPattern | DayOfMonthPattern;
+export type RecurringPattern = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
@@ -229,6 +247,8 @@ export interface HolidayLookup<Kind extends string = string> {
     readonly timeZone: string;
     /** 祝日の提供元 */
     readonly providers: readonly HolidayProvider<Kind>[];
+    /** 祝日の提供元の対応年を外れた日付の扱い（設定の outOfRange） */
+    readonly outOfRange: "throw" | "ignore";
     /** 入力をタイムゾーンでの暦日に変換する */
     dateOf(input: DateInput): DateString;
     /** 入力をタイムゾーンでの暦日と時刻に変換する */
@@ -310,6 +330,8 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly anchor: number | null;
     /** 日の集合（曜日の規則では null） */
     readonly days: ReadonlySet<number> | null;
+    /** 祝日の翌日の規則か */
+    readonly dayAfterHoliday: boolean;
     /** 月の集合（null はすべての月） */
     readonly months: ReadonlySet<number> | null;
     readonly onHolidayRule: OnHolidayRule;
@@ -318,13 +340,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 繰り返しの規則の形（曜日・第 n 回目・周期・日・月）がその日に当てはまるか。
- * 有効期間と祝日かどうかは考えない（規則の診断で、形どうしの包含を調べるために分けている）
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
+ * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
  */
-export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString): boolean;
-/** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む。祝日かどうかは考えない） */
-export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString): boolean;
+export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, isHoliday?: IsHoliday): boolean;
+/** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
+export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, isHoliday: IsHoliday): boolean;
 /** @internal 祝日の提供元とタイムゾーンの設定を検証した結果 */
 export interface HolidaySource<Kind extends string> {
     readonly providers: readonly HolidayProvider<Kind>[];

package/dist/core/schedule.js

@@ -11,7 +11,8 @@
  *
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
- * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ
+ * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
+ * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -208,8 +209,9 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const name = checkName(c, p, entry["name"]);
         const hasWeekday = "weekday" in entry;
         const hasDay = "day" in entry;
-        if (hasWeekday === hasDay) {
-            c.error("invalid-option", p, 'must have either "weekday" or "day" (not both)');
+        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"');
             return;
         }
         let ok = true;
@@ -268,11 +270,23 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                     ok = false;
                 }
             }
-            const set = checkSet(c, `${p}.day`, entry["day"], isDayOfMonth, "1-31 or -1 (last day)");
-            if (set)
-                days = set;
-            else
-                ok = false;
+            if (hasDay) {
+                const set = checkSet(c, `${p}.day`, entry["day"], isDayOfMonth, "1-31 or -1 (last day)");
+                if (set)
+                    days = set;
+                else
+                    ok = false;
+            }
+            else {
+                if (entry["dayAfterHoliday"] !== true) {
+                    c.error("invalid-option", `${p}.dayAfterHoliday`, "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)');
+                    ok = false;
+                }
+            }
         }
         let months = null;
         if (entry["months"] !== undefined) {
@@ -302,6 +316,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 interval,
                 anchor,
                 days,
+                dayAfterHoliday: hasAfter,
                 months,
                 onHolidayRule: onHoliday,
                 value,
@@ -313,13 +328,17 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
     return rules;
 }
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・月）がその日に当てはまるか。
- * 有効期間と祝日かどうかは考えない（規則の診断で、形どうしの包含を調べるために分けている）
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
+ * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
  */
-export function matchPattern(rule, date) {
+export function matchPattern(rule, date, isHoliday) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
+    if (rule.dayAfterHoliday) {
+        return isHoliday !== undefined && !isHoliday(date) && isHoliday(addDays(date, -1));
+    }
     const dim = daysInMonth(year, month);
     if (rule.weekday !== null) {
         if (weekdayOf(date) !== rule.weekday)
@@ -332,9 +351,9 @@ export function matchPattern(rule, date) {
     }
     return rule.days.has(day) || (rule.days.has(-1) && day === dim);
 }
-/** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む。祝日かどうかは考えない） */
-export function matchRecurring(rule, date) {
-    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date);
+/** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
+export function matchRecurring(rule, date, isHoliday) {
+    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, isHoliday);
 }
 /** 規則の value を取り出す（value が必須の規則用） */
 function requiredValue(c) {
@@ -524,6 +543,7 @@ export function createHolidayLookup(source) {
     return {
         timeZone,
         providers,
+        outOfRange,
         holidayOn,
         dateOf,
         civilOf: ((input) => toDateTimeParts(input, timeZone)),
@@ -565,6 +585,7 @@ export const RECURRING_RULE_KEYS = [
     "interval",
     "anchor",
     "day",
+    "dayAfterHoliday",
     "months",
     "name",
     "onHolidayRule",
@@ -645,7 +666,7 @@ export function createResolver(compiled, lookup) {
             const prev = addDays(date, -k);
             if (!isHolidaySafe(prev))
                 return undefined;
-            if (matchRecurring(rule, prev))
+            if (matchRecurring(rule, prev, isHolidaySafe))
                 return prev;
         }
         return undefined;
@@ -678,7 +699,7 @@ export function createResolver(compiled, lookup) {
             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));
+            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, isHolidaySafe));
             if (over)
                 return make(over.value, "recurring", over, over.name);
             // 4. 祝日
@@ -688,14 +709,14 @@ export function createResolver(compiled, lookup) {
             }
             // 祝日の扱いが「曜日どおり」なら、祝日の下（"under-holiday"）の規則も当てはまる。
             // "after-holiday" の規則は祝日には当てはめない（振り替える）
-            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date));
+            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, isHolidaySafe));
             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))
+            if (matchRecurring(rule, date, isHolidaySafe))
                 return make(rule.value, "recurring", rule, rule.name);
             if (hasShift && rule.onHolidayRule === "after-holiday") {
                 const origin = shiftedOrigin(rule, date);
@@ -725,6 +746,7 @@ export function buildSchedule(compiled) {
     const schedule = {
         timeZone: lookup.timeZone,
         providers: lookup.providers,
+        outOfRange: lookup.outOfRange,
         dateOf: lookup.dateOf,
         civilOf: lookup.civilOf,
         today: lookup.today,

package/dist/index.d.ts

@@ -7,8 +7,8 @@
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
-export { createCalendar, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, 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 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, 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 { 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 { createCalendar, } from "./core/calendar.js";
+export { combineCalendars, createCalendar, } 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/package.json

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