bizdays-toolkit 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-19
+
+### 移行
+
+動作は変わりません（繰り返しの規則・毎年の月日の規則への省略可能な項目の追加と、診断の改善）。`bizdays-toolkit/jp` の `toJapanDate`・`toJapanDateTime` が非推奨になったので、使っていれば `toDateString(input, "Asia/Tokyo")`・`toDateTimeParts(input, "Asia/Tokyo")`（または営業日カレンダー・スケジュールの `dateOf`・`civilOf`）に書き換える。書き換え方は [docs/migration.md](./docs/migration.md)。
+
+### Added
+
+- 繰り返しの規則（`closedRecurring`・`openRecurring`・スケジュールの `recurring`）と毎年の月日の規則（`closedAnnual` のオブジェクトの形・スケジュールの `annual`）に、有効期間 `effectiveFrom`・`effectiveTo`（両端を含む `"YYYY-MM-DD"`。一方だけなら、もう一方は期限なし）を付けられるようにした。期間の外では、その規則は書かれていないのと同じに扱う（判定の順番は変わらない）。「2027 年 4 月から定休日を月曜から火曜に変える」「夏季休業を今年限りでやめる」を 1 つのカレンダーで表せ、切り替え日をまたぐ営業日の計算（`addBusinessDays` など）も正しくなる。`"after-holiday"` の振替は振替元の日で期間を判定する。型 `EffectivePeriod` を追加した。`effectiveFrom` が `effectiveTo` より後なら `invalid-range`
+- 曜日の規則に周期 `interval`（週数。2 以上の整数）と起点 `anchor`（`weekday` と同じ曜日の日付）を付けて、「隔週水曜定休」のような規則を書けるようにした。`anchor` と同じ曜日で、`anchor` との日数の差が 7 × `interval` の倍数の日（起点より前の日も）に当てはまる。`nth` とは併用できず、`months`・`onHolidayRule`・有効期間とは組み合わせられる。「第 1・第 3 水曜」（`nth: [1, 3]`）は水曜が 5 回ある月で隔週からずれるため、別の書き方にした。`interval` と `anchor` の片方だけ、`anchor` の曜日違い、`day` の規則への指定は `invalid-option`
+
+### Deprecated
+
+- `bizdays-toolkit/jp` の `toJapanDate`・`toJapanDateTime` を非推奨にした（`@deprecated`）。同じ変換がルートの `toDateString(input, "Asia/Tokyo")`・`toDateTimeParts(input, "Asia/Tokyo")` と、営業日カレンダー・スケジュールの `dateOf`・`civilOf` にあり、国ごとの関数は日本だけの特別扱い（英国には対応物がない）だったため。少なくとも 1 つのマイナー版は残し、1.0.0 で削除する。`etc/api.md` に `@deprecated` を記録するようにした
+
+### Changed
+
+- 規則の診断（`bizdays-toolkit/diagnose`）を、有効期間と周期に対応させた。`shadowed` は先の規則の期間が後の規則の期間を含み、周期も含む（毎週は隔週を覆う。位相の違う隔週どうしは覆わない）ときだけ出す。有効期間の中に当てはまる日がない規則は `never-matches`。規則の有効期間が祝日の提供元の対応年の外にあれば `out-of-range`（新しい code は足していない）
+- `redundant`・`no-business-day` の走査の範囲を見直した。周期のある規則があれば、提供元がない設定の 2001〜2028 年を周期がそろう長さ（隔週なら 56 年。上限 200 年）に広げ、規則の有効期間が範囲の外にあれば、その期間も調べる（`outOfRange: "throw"` では対応年の中だけ）。これまでは固定の範囲の外にある期間の規則を「使われない」と誤診した。調べた年は `message` に書く
+- README: 繰り返しの規則の節に、有効期間と隔週の書き方・例を足した。`businessDaysBetween` だけが `to` を含まない理由（区間を足し合わせられ、`addBusinessDays` の逆算になる）を書いた
+- README のサイズの値を測り直した（ルート約 7.9KB・日本の祝日込み約 9.8KB・英国の祝日込み約 9.6KB。0.10.0 で測定）
+- `docs/decisions.md`: 有効期間と周期の設計（30 番）と `businessDaysBetween` の範囲（31 番）を足し、6 番（契約の項目に `names` を追記）・13 番と 16 番（その月にない日の扱いが `dueDate`・`closingMonth` と繰り返しの規則で違うことの相互参照）・14 番（土曜日を避ける方法は個別の日付での上書き、振替と有効期間）・15 番（走査の範囲）の記述を直した
+
+### 開発
+
+- サイズの上限（`size-limits.json`）を上げた。ルート 16,500 → 17,500、`./jp` 19,500 → 20,500、`./diagnose` 22,000 → 24,000（gzip）。有効期間と周期の検証・判定（ルートで約 0.8KB）と、診断の走査範囲・包含判定の見直し（約 2.3KB）のため
+- 性質のテスト（`test/diagnose-properties.test.ts`）で、有効期間と周期のある規則も作るようにした。固定の走査範囲（2001〜2028 年）の外や、28 年の周期をまたぐ年の日付も比べる
+
+## [0.9.1] - 2026-10-18
+
+ライブラリのコードは 0.9.0 と同じ。
+
+### Changed
+
+- README: スケジュールの `daysBetween` を `holiday` だけで絞ると、`dates`・`annual` で値を決めた祝日（特別営業日など）も含まれることと、それを除く絞り込み（`reason` が `"date"`・`"annual"` の日を除く）の例を足した
+
+### 開発
+
+- ブラウザーでの確認の Edge の起動オプションに、`--disable-dev-shm-usage` と `--disable-gpu` を足した。CI のランナーで Edge のページの読み込みが止まり、やり直し（`RETRY`）がほぼ毎回起きていたため
+
 ## [0.9.0] - 2026-10-18
 
 ### 移行
@@ -226,7 +266,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.9.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.10.0...HEAD
+[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
 [0.8.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.7.0...v0.8.0

package/README.md

@@ -20,13 +20,13 @@ 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", "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)
+- **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
 - **Day-by-day values (e.g. store hours)**: values that change by weekday, holiday and specific date, such as "closed on Tuesdays, Sunday hours on holidays, closed on New Year's Day, short hours on New Year's Eve", are looked up with the same rules
 - **Option diagnostics**: `diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` list rules that can never apply, rules whose removal changes nothing, typos in option keys, calendars with no business day and more, without throwing. One line in your tests keeps a change of settings from silently killing a rule
 - **Month-based due dates**: due dates such as "closing on the 20th, paid on the 10th of the next month (next business day if closed)" or "the last business day of the month", with the four adjustment conventions used in finance (following, preceding, modified-following, modified-preceding)
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 7.5 KB min+gzip (about 9.0 KB with Japanese holidays, about 9.1 KB with UK bank holidays; measured for 0.9.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 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
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -117,7 +117,7 @@ shipping.dayInfo("2027-01-01");
 shipping.daysBetween("2026-12-30", "2027-01-04").map((d) => d.businessDay); // [true, false, false, false, false, true]
 ```
 
-`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included).
+`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included). `listBusinessDays` and `holidaysBetween` include both ends too; only `businessDaysBetween(from, to)` counts from `from` (inclusive) to `to` (exclusive), so that `businessDaysBetween(a, b) + businessDaysBetween(b, c)` equals `businessDaysBetween(a, c)` and it is the inverse of `addBusinessDays`.
 
 `createCalendar` and `createSchedule` validate the options when they are created, so the usual pattern is to create them once and reuse them. Creating is also cheap (about 0.02 ms for a calendar and 0.04 ms for a schedule with Japanese holidays on a development machine), so creating one per request is not a problem in practice.
 
@@ -134,9 +134,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, nth weekday, day of month)
+### Recurring rules (weekly, every other week, nth weekday, day of month)
 
-Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "stocktaking on the last day of the month" or "closed on Mondays (on the next weekday if Monday is a holiday)" go in `closedRecurring` and `openRecurring`.
+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`.
 
 ```ts
 const museum = createCalendar({
@@ -160,17 +160,43 @@ museum.dayInfo("2026-10-13");
 //   name: "Closed on Mondays", shiftedFrom: "2026-10-12" }
 ```
 
-| Pattern                  | Meaning                                                                               |
-| ------------------------ | ------------------------------------------------------------------------------------- |
-| `{ weekday: 1 }`         | Every Monday                                                                          |
-| `{ weekday: 3, nth: 3 }` | The 3rd Wednesday. `nth` is 1–5 or -1 (last); an array such as `[2, 4]` gives several |
-| `{ day: 20 }`            | The 20th of every month. `day` is 1–31 or -1 (last day); an array gives several       |
-| `months: [8, 12]`        | Narrows any pattern to these months                                                   |
+| Pattern                                             | Meaning                                                                                                              |
+| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `{ weekday: 1 }`                                    | Every Monday                                                                                                         |
+| `{ weekday: 3, nth: 3 }`                            | The 3rd Wednesday. `nth` is 1–5 or -1 (last); an array such as `[2, 4]` gives several                                |
+| `{ 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                                      |
+| `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`
 
+**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).
+
+```ts
+const shop = createCalendar({
+  holidays: jp,
+  closedRecurring: [
+    { weekday: 1, name: "Closed on Mondays", effectiveTo: "2027-03-31" },
+    { weekday: 2, name: "Closed on Tuesdays", effectiveFrom: "2027-04-01" },
+    { weekday: 3, interval: 2, anchor: "2026-01-07", name: "Closed every other Wednesday" },
+  ],
+  closedAnnual: [{ from: "08-13", to: "08-16", name: "Summer closure", effectiveTo: "2026-12-31" }],
+});
+
+shop.isBusinessDay("2027-03-29"); // false (Monday, before the change)
+shop.isBusinessDay("2027-04-06"); // false (Tuesday, after the change)
+shop.addBusinessDays("2027-03-30", 3); // "2027-04-03" (counts across the change; March 31 is an every-other-week Wednesday)
+shop.isBusinessDay("2027-08-13"); // true (the summer closure ended in 2026)
+```
+
+- Outside its period a rule is simply not applied; the order of priority does not change. A rule with only `effectiveFrom` or only `effectiveTo` is open-ended on the other side
+- An `"after-holiday"` rule is judged by the date it would originally apply to: if that date is within the period, the rule is moved to the next non-holiday even when that day is outside the period
+- Changing the closed weekday is written as two weekly rules with periods, as above, rather than with `closedWeekdays` (which has no period)
+
 **What happens on a holiday** (`onHolidayRule`) is chosen per rule.
 
 | Value                       | Meaning                                                                   | How a store would announce it                           |
@@ -318,9 +344,15 @@ storeHours
   .daysBetween("2026-11-01", "2026-11-30")
   .filter((d) => d.holiday)
   .map((d) => d.date); // ["2026-11-03", "2026-11-23"]
+
+// Holidays not overridden by specific or annual dates (New Year's Day is closed by the annual rule)
+storeHours
+  .daysBetween("2026-12-28", "2027-01-11")
+  .filter((d) => d.holiday && d.reason !== "date" && d.reason !== "annual")
+  .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.
+`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.
 
 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.
 
@@ -332,7 +364,7 @@ const hours = storeHours.valueOn(date);
 const isOpen = hours !== null && hours.open <= time && time < hours.close;
 ```
 
-For inputs that always carry a time (a `Date`, Temporal `Instant`, `ZonedDateTime` or `PlainDateTime`, or a `"YYYY-MM-DDTHH:mm"` string), `time` is typed as `string`, so no `null` check is needed. `civilOf` is also on business-day calendars, and the same conversion is available as `toJapanDateTime` in `bizdays-toolkit/jp` and `toDateTimeParts(input, timeZone)` in the root.
+For inputs that always carry a time (a `Date`, Temporal `Instant`, `ZonedDateTime` or `PlainDateTime`, or a `"YYYY-MM-DDTHH:mm"` string), `time` is typed as `string`, so no `null` check is needed. `civilOf` is also on business-day calendars, and the same conversion is available as `toDateTimeParts(input, timeZone)` in the root. (`toJapanDate` and `toJapanDateTime` in `bizdays-toolkit/jp` are deprecated since 0.10.0: use `toDateString(input, "Asia/Tokyo")`, `toDateTimeParts(input, "Asia/Tokyo")` or `dateOf`/`civilOf` on a calendar instead. They will be removed in 1.0.0.)
 
 ### Date and date-time inputs
 
@@ -448,8 +480,8 @@ diagnoseCalendar({
 | `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                     |
 | `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                             |
 | `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                            |
-| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`)                                                                                          |
-| `warning`  | `out-of-range`               | A specific date outside the supported years of the holiday provider (`relatedPath`)                                                                                |
+| `warning`  | `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) |
 
@@ -457,7 +489,8 @@ diagnoseCalendar({
 - When there is an `error`, the rule relation checks (`shadowed`, `redundant` and so on) are skipped
 - `shadowed` compares only rules of the same type (specific dates, annual dates, recurring rules). The order of evaluation is fixed, so rules unused across types are found as `redundant`. Specific open days (`openDates`) and specific closed days (`closedDates`) are of the same type, and a closed day covered by an earlier open day is `shadowed`
 - `shadowed` for recurring rules also considers `onHolidayRule`. For example, an `"under-holiday"` rule does not cover an `"over-holiday"` rule on the same days (the later rule applies on holidays)
-- `redundant` compares the results with and without the rule day by day. Specific dates are checked over their range; annual dates and recurring rules are checked, with specific dates removed, over the holiday provider's supported years (1955–2099 for Japan), or 2001–2028 without a provider (28 years cover every combination of weekday and date). Schedule values are compared by content for arrays and plain objects, and by identity otherwise (such as `Date`)
+- `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
 
 Keeping options safe with a test:

package/dist/core/calendar.d.ts

@@ -20,7 +20,7 @@ import { type DateString, type Weekday } from "./date.ts";
 import { IssueCollector } from "./errors.ts";
 import { type DateInput } from "./input.ts";
 import { type MonthString } from "./month.ts";
-import { type CompiledSchedule, type DayOfMonth, type RecurringRule, type HolidayLookup, type HolidaySourceOptions } from "./schedule.ts";
+import { type CompiledSchedule, type DayOfMonth, type EffectivePeriod, type RecurringRule, type HolidayLookup, type HolidaySourceOptions } from "./schedule.ts";
 import type { Holiday } from "./types.ts";
 /**
  * 祝日の扱い。
@@ -28,18 +28,18 @@ import type { Holiday } from "./types.ts";
  */
 export type HolidayPolicy = "closed" | "open" | "ignore";
 /**
- * 毎年の月日 "MM-DD"（名前付きも可）。
+ * 毎年の月日 "MM-DD"（名前付き・有効期間付きも可）。
  * @public
  */
-export type AnnualDate = string | {
+export type AnnualDate = string | ({
     readonly date: string;
     readonly name?: string;
-};
+} & EffectivePeriod);
 /**
  * 毎年の月日の期間（from > to なら年をまたぐ。例: 12-31 〜 01-03）。
  * @public
  */
-export interface AnnualRange {
+export interface AnnualRange extends EffectivePeriod {
     readonly from: string;
     readonly to: string;
     readonly name?: string;
@@ -68,15 +68,16 @@ export interface DateRange {
 export interface CalendarOptions<Kind extends string = string> extends HolidaySourceOptions<Kind> {
     /** 定休日の曜日（0 = 日曜日） */
     readonly closedWeekdays?: readonly Weekday[];
-    /** 毎年の休業日 */
+    /** 毎年の休業日（有効期間 effectiveFrom・effectiveTo を付けられる） */
     readonly closedAnnual?: readonly (AnnualDate | AnnualRange)[];
     /** 臨時休業日 */
     readonly closedDates?: readonly (SpecificDate | DateRange)[];
     /** 臨時営業日（ほかのすべての規則より優先） */
     readonly openDates?: readonly (SpecificDate | DateRange)[];
     /**
-     * 繰り返しの休業日（毎週・毎月の第 n 曜日・毎月の日）。
-     * 祝日に当たったときの扱いは規則ごとに onHolidayRule で指定する（既定: "under-holiday"）
+     * 繰り返しの休業日（毎週・隔週などの周期・毎月の第 n 曜日・毎月の日）。
+     * 祝日に当たったときの扱いは規則ごとに onHolidayRule で指定する（既定: "under-holiday"）。
+     * 有効期間（effectiveFrom・effectiveTo）を付けると、期間の外では書かれていないのと同じに扱う
      */
     readonly closedRecurring?: readonly RecurringRule[];
     /** 繰り返しの営業日。closedRecurring と同じ日に当たる場合はこちらが優先 */

package/dist/core/diagnose.d.ts

@@ -8,14 +8,16 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日など）
- *     out-of-range   … 個別の日付が祝日の提供元の対応年の外にある（relatedPath に提供元）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、など）
+ *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則
  *
  * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
  * 固定なので、shadowed は同じ種類の規則どうしに限って調べる。種類をまたいで使われない規則は
  * redundant（取り除いても結果が変わらない）として見つかる。
+ * 有効期間（effectiveFrom・effectiveTo）のある規則は期間の包含も、周期（interval）のある規則は周期の包含も
+ * shadowed の条件にする。redundant の走査の範囲は、周期がそろう長さと、範囲の外にある有効期間まで広げる
  */
 import { type CalendarOptions } from "./calendar.ts";
 import { type KnownErrorCode } from "./errors.ts";

package/dist/core/diagnose.js

@@ -8,19 +8,21 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日など）
- *     out-of-range   … 個別の日付が祝日の提供元の対応年の外にある（relatedPath に提供元）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、など）
+ *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則
  *
  * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
  * 固定なので、shadowed は同じ種類の規則どうしに限って調べる。種類をまたいで使われない規則は
  * redundant（取り除いても結果が変わらない）として見つかる。
+ * 有効期間（effectiveFrom・effectiveTo）のある規則は期間の包含も、周期（interval）のある規則は周期の包含も
+ * shadowed の条件にする。redundant の走査の範囲は、周期がそろう長さと、範囲の外にある有効期間まで広げる
  */
 import { daysInMonth, fromDayNumber, parseDate, toDayNumber } from "./date.js";
 import { compileCalendarOptions } from "./calendar.js";
 import { IssueCollector } from "./errors.js";
-import { compileScheduleOptions, createHolidayLookup, createResolver, matchAnnual, matchRecurring, } from "./schedule.js";
+import { compileScheduleOptions, createHolidayLookup, createResolver, matchMonthDay, matchPattern, } from "./schedule.js";
 // ------------------------------------------------------------
 // 知らないキーの候補
 // ------------------------------------------------------------
@@ -68,13 +70,29 @@ function closestKey(key, known) {
 // ------------------------------------------------------------
 // 調べる期間
 // ------------------------------------------------------------
-/** 繰り返しの規則の当てはまり方は、年の種類（1 月 1 日の曜日 × うるう年か）の 14 通りで決まる。28 年でそろう */
+/**
+ * 繰り返しの規則の当てはまり方は、年の種類（1 月 1 日の曜日 × うるう年か）の 14 通りで決まり、28 年でそろう。
+ * 周期（interval）のある規則は、28 年（10,227 日）が 7 × interval 日の倍数とは限らないので、別に周期を求める（patternCycle）
+ */
 const PATTERN_FROM = toDayNumber("2001-01-01");
-const PATTERN_TO = toDayNumber("2028-12-31");
-/** 祝日の提供元があるときに調べる年の上限（長すぎる対応年は 1900〜2099 年に絞る） */
+const PATTERN_DAYS = toDayNumber("2028-12-31") - PATTERN_FROM + 1;
+/** 祝日の提供元があるときに調べる年の上限（長すぎる対応年は 1900〜2099 年に絞る）。周期・有効期間で広げる長さの上限でもある */
 const MAX_WINDOW_YEARS = 200;
 /** 個別の日付の期間で、取り除いた結果と比べる最大日数 */
 const MAX_DATE_RULE_DAYS = 366 * MAX_WINDOW_YEARS;
+const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
+const lcm = (a, b) => (a / gcd(a, b)) * b;
+/**
+ * 繰り返しの規則の当てはまり方がそろう日数（最大 MAX_WINDOW_YEARS 年）。
+ * 周期 k 週の規則は、28 年と 7k 日の最小公倍数でそろう（隔週なら 56 年）
+ */
+function patternCycle(rules) {
+    let weeks = 1;
+    for (const rule of rules)
+        if (rule.interval !== null)
+            weeks = lcm(weeks, rule.interval);
+    return Math.min(lcm(PATTERN_DAYS, 7 * weeks), 366 * MAX_WINDOW_YEARS);
+}
 /** 長すぎる年の範囲を 1900〜2099 年（重ならなければ先頭の 200 年）に絞る */
 function clipYears(from, to) {
     if (to - from + 1 <= MAX_WINDOW_YEARS)
@@ -83,43 +101,93 @@ function clipYears(from, to) {
     const b = Math.min(to, 2099);
     return a <= b ? [a, b] : [from, from + MAX_WINDOW_YEARS - 1];
 }
-/** 毎年の月日・繰り返しの規則を調べる期間（祝日が年ごとに変わるので、提供元の対応年を使う） */
-function scanWindow(source) {
+const dayOfYear = (year, last) => toDayNumber(`${String(year).padStart(4, "0")}-${last ? "12-31" : "01-01"}`);
+/**
+ * 毎年の月日・繰り返しの規則を調べる期間。祝日が年ごとに変わるので、提供元の対応年を使う。
+ * 提供元がなければ、繰り返しの規則がそろう周期（2001 年から 28 年、周期のある規則があれば長く）。
+ * 規則の有効期間が基準の範囲の外にあれば、その期間（期限のない側は周期の長さ）も加える
+ * （対応年の外で例外になる設定では加えない）
+ */
+function scanWindow(source, rules, cycle) {
+    const ranges = [];
+    let extend = true;
     if (source.providers.length === 0) {
-        return { from: PATTERN_FROM, to: PATTERN_TO, label: "2001-2028" };
-    }
-    const ranges = source.providers.map((p) => p.supportedYears);
-    let from;
-    let to;
-    if (source.outOfRange === "ignore") {
-        from = Math.min(...ranges.map((r) => r.from));
-        to = Math.max(...ranges.map((r) => r.to));
+        ranges.push({ from: PATTERN_FROM, to: PATTERN_FROM + cycle - 1 });
     }
     else {
-        from = Math.max(...ranges.map((r) => r.from));
-        to = Math.min(...ranges.map((r) => r.to));
+        const years = source.providers.map((p) => p.supportedYears);
+        let from;
+        let to;
+        if (source.outOfRange === "ignore") {
+            from = Math.min(...years.map((r) => r.from));
+            to = Math.max(...years.map((r) => r.to));
+        }
+        else {
+            from = Math.max(...years.map((r) => r.from));
+            to = Math.min(...years.map((r) => r.to));
+            extend = false;
+        }
+        if (from > to)
+            return undefined;
+        [from, to] = clipYears(from, to);
+        ranges.push({ from: dayOfYear(from, false), to: dayOfYear(to, true) });
+    }
+    if (extend) {
+        for (const rule of rules) {
+            if (rule.effectiveFrom === null && rule.effectiveTo === null)
+                continue;
+            const from = rule.effectiveFrom ?? rule.effectiveTo - cycle + 1;
+            const to = Math.min(rule.effectiveTo ?? from + cycle - 1, from + 366 * MAX_WINDOW_YEARS - 1);
+            ranges.push({ from, to });
+        }
+    }
+    ranges.sort((a, b) => a.from - b.from);
+    const merged = [];
+    for (const r of ranges) {
+        const last = merged[merged.length - 1];
+        if (last && r.from <= last.to + 1)
+            merged[merged.length - 1] = { from: last.from, to: Math.max(last.to, r.to) };
+        else
+            merged.push(r);
+    }
+    const yearOf = (n) => parseDate(fromDayNumber(n)).year;
+    const label = merged.map((r) => `${yearOf(r.from)}-${yearOf(r.to)}`).join(", ");
+    return { ranges: merged, label };
+}
+/** 期間の日ごとに fn を呼ぶ（true を返したら止める） */
+function eachDay(window, fn) {
+    for (const { from, to } of window.ranges) {
+        for (let n = from; n <= to; n++)
+            if (fn(n) === true)
+                return;
     }
-    if (from > to)
-        return undefined;
-    [from, to] = clipYears(from, to);
-    return {
-        from: toDayNumber(`${String(from).padStart(4, "0")}-01-01`),
-        to: toDayNumber(`${String(to).padStart(4, "0")}-12-31`),
-        label: `${from}-${to}`,
-    };
 }
 // ------------------------------------------------------------
 // 規則の当てはまる日（覆われているかの判定用）
 // ------------------------------------------------------------
-/** 繰り返しの規則が当てはまる日（代表の 28 年間）。祝日・振替は考えない */
-function recurringMatches(rule) {
-    const bits = new Uint8Array(PATTERN_TO - PATTERN_FROM + 1);
-    for (let n = PATTERN_FROM; n <= PATTERN_TO; n++) {
-        if (matchRecurring(rule, fromDayNumber(n)))
-            bits[n - PATTERN_FROM] = 1;
+/** 繰り返しの規則の形（有効期間・周期の位相は除く）が当てはまる日（代表の 28 年間）。祝日・振替は考えない */
+function patternBits(rule) {
+    const bits = new Uint8Array(PATTERN_DAYS);
+    // 周期のある規則は、位相を除いた形（毎週）で調べ、周期と位相は intervalCovers で比べる
+    const weekly = rule.interval === null ? rule : { ...rule, interval: null, anchor: null };
+    for (let i = 0; i < PATTERN_DAYS; i++) {
+        if (matchPattern(weekly, fromDayNumber(PATTERN_FROM + i)))
+            bits[i] = 1;
     }
     return bits;
 }
+/**
+ * 繰り返しの規則が当てはまる日が 1 日でもあるか。
+ * 有効期間があればその期間（期限のない側は、当てはまり方がそろう周期の長さ）を、なければ周期の長さを 1 日ずつ調べる
+ */
+function matchesAnyDay(rule, cycle) {
+    const from = rule.effectiveFrom ?? (rule.effectiveTo === null ? PATTERN_FROM : rule.effectiveTo - cycle + 1);
+    const to = Math.min(rule.effectiveTo ?? Infinity, from + cycle - 1);
+    for (let n = from; n <= to; n++)
+        if (matchPattern(rule, fromDayNumber(n)))
+            return true;
+    return false;
+}
 /** 毎年の月日の規則が当てはまる月日（うるう年の 366 日） */
 const LEAP_MONTH_DAYS = (() => {
     const list = [];
@@ -130,12 +198,28 @@ const LEAP_MONTH_DAYS = (() => {
     }
     return list;
 })();
-function annualMatches(rule) {
-    return Uint8Array.from(LEAP_MONTH_DAYS, (md) => (matchAnnual(rule, md) ? 1 : 0));
+function annualBits(rule) {
+    return Uint8Array.from(LEAP_MONTH_DAYS, (md) => (matchMonthDay(rule, md) ? 1 : 0));
 }
-const isEmpty = (bits) => bits.every((b) => b === 0);
 /** a が当てはまる日に、b もすべて当てはまるか（a ⊆ b） */
 const isSubset = (a, b) => a.every((v, i) => v === 0 || b[i] === 1);
+/** 先の規則の有効期間が、後の規則の有効期間を含むか */
+const periodCovers = (earlier, later) => (earlier.effectiveFrom === null ||
+    (later.effectiveFrom !== null && earlier.effectiveFrom <= later.effectiveFrom)) &&
+    (earlier.effectiveTo === null ||
+        (later.effectiveTo !== null && earlier.effectiveTo >= later.effectiveTo));
+/**
+ * 周期の点で、先の規則が後の規則を覆えるか（形の包含は patternBits で別に調べる）。
+ * 周期のある先の規則は、後の規則の周期がその倍数で、位相も同じ（起点の差が先の周期の倍数）ときだけ覆う
+ */
+function intervalCovers(earlier, later) {
+    if (earlier.interval === null)
+        return true;
+    if (later.interval === null)
+        return false;
+    return (later.interval % earlier.interval === 0 &&
+        (later.anchor - earlier.anchor) % (7 * earlier.interval) === 0);
+}
 /**
  * 先の繰り返しの規則 earlier が、後の規則 later を完全に覆えるか（祝日の扱いの組み合わせ）。
  * - "over-holiday" の規則は、祝日でも先に当てはめる "over-holiday" の規則にしか覆われない
@@ -221,7 +305,8 @@ function analyze(c, compiled, isCalendar) {
     if (!checkProviderData(c, source))
         return;
     const lookup = createHolidayLookup(source);
-    const window = scanWindow(source);
+    const cycle = patternCycle(recurring);
+    const window = scanWindow(source, [...annual, ...recurring], cycle);
     /** 使われないことが分かった規則（redundant を重ねて出さない） */
     const unused = new Set();
     // --- 個別の日付: 対応年の外・覆われている ---
@@ -244,25 +329,49 @@ function analyze(c, compiled, isCalendar) {
             c.warning("shadowed", rule.path, `This rule is never used: the earlier rule ${cover.path} covers all of its days`, cover.path);
         }
     });
-    // --- 毎年の月日: 覆われている ---
-    const annualBits = annual.map(annualMatches);
+    // --- 有効期間が提供元の対応年の外にある（対応年の外で例外になる設定では、その規則は決して使われない） ---
+    for (const rule of [...annual, ...recurring]) {
+        if (rule.effectiveFrom === null && rule.effectiveTo === null)
+            continue;
+        source.providers.forEach((p, i) => {
+            const { from, to } = p.supportedYears;
+            const after = rule.effectiveFrom !== null && yearOf(rule.effectiveFrom) > to;
+            const before = rule.effectiveTo !== null && yearOf(rule.effectiveTo) < from;
+            if (!after && !before)
+                return;
+            if (source.outOfRange === "throw")
+                unused.add(rule);
+            c.warning("out-of-range", rule.path, `The effective period is outside the years supported by holiday provider ${p.id} (${from}-${to}); ` +
+                (source.outOfRange === "throw"
+                    ? "looking up these dates throws, so this rule is never used"
+                    : "holidays are not considered for these dates"), source.providers.length === 1 ? "holidays" : `holidays[${i}]`);
+        });
+    }
+    // --- 毎年の月日: 覆われている（月日と有効期間の両方で） ---
+    const annualMatches = annual.map(annualBits);
     annual.forEach((rule, j) => {
-        const k = annualBits.findIndex((bits, i) => i < j && isSubset(annualBits[j], bits));
+        const k = annualMatches.findIndex((bits, i) => i < j && periodCovers(annual[i], rule) && isSubset(annualMatches[j], bits));
         if (k < 0)
             return;
         unused.add(rule);
         c.warning("shadowed", rule.path, `This rule is never used: the earlier rule ${annual[k].path} covers all of its days`, annual[k].path);
     });
     // --- 繰り返しの規則: 当てはまる日がない・覆われている ---
-    const recurringBits = recurring.map(recurringMatches);
+    const recurringBits = recurring.map(patternBits);
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
-        if (isEmpty(bits)) {
+        if (!matchesAnyDay(rule, cycle)) {
             unused.add(rule);
-            c.warning("never-matches", rule.path, "This rule matches no day (for example, a day that does not exist in the selected months)");
+            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");
             return;
         }
-        const k = recurring.findIndex((r, i) => i < j && canCover(r, rule) && isSubset(bits, recurringBits[i]));
+        const k = recurring.findIndex((r, i) => i < j &&
+            canCover(r, rule) &&
+            periodCovers(r, rule) &&
+            intervalCovers(r, rule) &&
+            isSubset(bits, recurringBits[i]));
         if (k < 0)
             return;
         unused.add(rule);
@@ -273,10 +382,7 @@ function analyze(c, compiled, isCalendar) {
     if (isCalendar && window && !dates.some((r) => r.value === true)) {
         const resolve = createResolver(without(compiled, null, true), lookup);
         let found = false;
-        for (let n = window.from; n <= window.to && !found; n++) {
-            if (resolve(fromDayNumber(n)).day.value === true)
-                found = true;
-        }
+        eachDay(window, (n) => (found = resolve(fromDayNumber(n)).day.value === true));
         if (!found) {
             c.warning("no-business-day", "", `No day is a business day with these options (checked ${window.label}); ` +
                 "searching for a business day throws");
@@ -322,11 +428,11 @@ function analyze(c, compiled, isCalendar) {
     const base = without(compiled, null, true);
     const resolveBase = createResolver(base, lookup);
     const decided = new Map(candidates.map((r) => [r, []]));
-    for (let n = window.from; n <= window.to; n++) {
+    eachDay(window, (n) => {
         const rule = resolveBase(fromDayNumber(n)).rule;
         if (rule)
             decided.get(rule)?.push(n);
-    }
+    });
     for (const rule of candidates) {
         const days = decided.get(rule);
         if (!redundant(rule, base, days))

package/dist/core/input.d.ts

@@ -43,7 +43,7 @@ export interface TemporalDateTimeLike extends TemporalDateLike {
 }
 /**
  * 時刻を必ず持つ入力（瞬間、Temporal.PlainDateTime、"YYYY-MM-DDTHH:mm…" の文字列）。
- * これを渡すと、civilOf・toDateTimeParts・toJapanDateTime の time の型が string になる。
+ * これを渡すと、civilOf・toDateTimeParts の time の型が string になる。
  * @public
  */
 export type DateTimeInput = Date | TemporalInstantLike | TemporalDateTimeLike | `${number}-${number}-${number}T${string}`;

package/dist/core/schedule.d.ts

@@ -10,7 +10,8 @@
  *   6. weekly  … 曜日ごとの値
  *
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
- * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）
+ * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
+ * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -57,14 +58,32 @@ export type Month = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
  * @public
  */
 export type OnHolidayRule = "under-holiday" | "over-holiday" | "after-holiday";
+/**
+ * 規則の有効期間（両端を含む "YYYY-MM-DD"）。期間の外では、その規則は書かれていないのと同じに扱う。
+ * @public
+ */
+export interface EffectivePeriod {
+    /** この日から有効（省略時は期限なし） */
+    readonly effectiveFrom?: DateString;
+    /** この日まで有効（省略時は期限なし） */
+    readonly effectiveTo?: DateString;
+}
 /**
  * 曜日の繰り返し。nth を省略すると毎週、指定すると月の第 n 回目（例: 第 3 水曜日）。
+ * interval と anchor を指定すると、anchor と同じ曜日で、anchor から interval 週おきの日（例: 隔週水曜日）。
  * @public
  */
 export interface WeekdayPattern {
     readonly weekday: Weekday;
-    /** 月の第 n 回目（その月で n 回目のその曜日。1〜7 日が第 1）。配列で複数指定できる */
+    /** 月の第 n 回目（その月で n 回目のその曜日。1〜7 日が第 1）。配列で複数指定できる。interval とは併用できない */
     readonly nth?: Nth | readonly Nth[];
+    /** 周期（週）。2 以上の整数。anchor と一緒に指定する（例: 2 で隔週） */
+    readonly interval?: number;
+    /**
+     * 周期の起点の日付 "YYYY-MM-DD"（weekday と同じ曜日）。この日の前後に interval 週おきに当てはまる。
+     * 起点より前の日にも当てはまるので、起点から始めるには effectiveFrom を併せて指定する
+     */
+    readonly anchor?: DateString;
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly day?: never;
@@ -80,6 +99,8 @@ export interface DayOfMonthPattern {
     readonly months?: readonly Month[];
     readonly weekday?: never;
     readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
 }
 /**
  * 繰り返しのパターン。
@@ -90,7 +111,7 @@ export type RecurringPattern = WeekdayPattern | DayOfMonthPattern;
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
  */
-export type RecurringRule = RecurringPattern & {
+export type RecurringRule = RecurringPattern & EffectivePeriod & {
     readonly name?: string;
     /** 祝日に当たったときの扱い（既定: "under-holiday"） */
     readonly onHolidayRule?: OnHolidayRule;
@@ -106,7 +127,7 @@ export type RecurringValue<T> = RecurringRule & {
  * 毎年の月日 "MM-DD" の値。
  * @public
  */
-export interface AnnualValue<T> {
+export interface AnnualValue<T> extends EffectivePeriod {
     readonly date: string;
     readonly value: T;
     readonly name?: string;
@@ -115,7 +136,7 @@ export interface AnnualValue<T> {
  * 毎年の月日の期間の値（from > to なら年をまたぐ。例: 12-31 〜 01-03）。
  * @public
  */
-export interface AnnualRangeValue<T> {
+export interface AnnualRangeValue<T> extends EffectivePeriod {
     readonly from: string;
     readonly to: string;
     readonly value: T;
@@ -252,8 +273,13 @@ export interface DateRule<T> {
     readonly value: T;
     readonly name: string | undefined;
 }
+/** @internal 有効期間（日数。省略した側は null） */
+export interface CompiledPeriod {
+    readonly effectiveFrom: number | null;
+    readonly effectiveTo: number | null;
+}
 /** @internal 毎年の月日の規則 */
-export interface AnnualRule<T> {
+export interface AnnualRule<T> extends CompiledPeriod {
     /** 設定の中の位置（例: "closedAnnual[0]"） */
     readonly path: string;
     readonly from: string;
@@ -261,6 +287,8 @@ export interface AnnualRule<T> {
     readonly value: T;
     readonly name: string | undefined;
 }
+/** @internal 日数 n が有効期間の中か */
+export declare const inPeriod: (rule: CompiledPeriod, n: number) => boolean;
 /**
  * @internal 個別の日付の規則を検証して取り込む。
  * entry は "YYYY-MM-DD"・{ date }・{ from, to } のいずれか。値は valueOf で決める
@@ -269,13 +297,17 @@ export declare function compileDateRules<T>(c: IssueCollector, path: string, ent
 /** @internal 毎年の月日の規則を検証して取り込む（entry は "MM-DD"・{ date }・{ from, to }） */
 export declare function compileAnnualRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, allowString: boolean): AnnualRule<T>[];
 /** @internal 繰り返しの規則（検証済み） */
-export interface RecurringRuleCompiled<T> {
+export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     /** 設定の中の位置（例: "closedRecurring[0]"） */
     readonly path: string;
     /** 曜日の規則なら曜日、日の規則なら null */
     readonly weekday: Weekday | null;
     /** 第 n 回目の集合（null は毎週） */
     readonly nth: ReadonlySet<number> | null;
+    /** 周期（週）。null は毎週・第 n 回目・日の規則 */
+    readonly interval: number | null;
+    /** 周期の起点（日数）。interval が null なら null */
+    readonly anchor: number | null;
     /** 日の集合（曜日の規則では null） */
     readonly days: ReadonlySet<number> | null;
     /** 月の集合（null はすべての月） */
@@ -286,7 +318,12 @@ export interface RecurringRuleCompiled<T> {
 }
 /** @internal 繰り返しの規則を検証して取り込む */
 export declare function compileRecurringRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, keys: readonly string[]): RecurringRuleCompiled<T>[];
-/** @internal 繰り返しの規則がその日に当てはまるか（祝日かどうかは考えない） */
+/**
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・月）がその日に当てはまるか。
+ * 有効期間と祝日かどうかは考えない（規則の診断で、形どうしの包含を調べるために分けている）
+ */
+export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString): boolean;
+/** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む。祝日かどうかは考えない） */
 export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString): boolean;
 /** @internal 祝日の提供元とタイムゾーンの設定を検証した結果 */
 export interface HolidaySource<Kind extends string> {
@@ -310,11 +347,15 @@ export interface CompiledSchedule<T, Kind extends string> {
     readonly recurring: readonly RecurringRuleCompiled<T>[];
 }
 /** @internal 繰り返しの規則の項目 */
+/** @internal 有効期間の項目 */
+export declare const PERIOD_KEYS: string[];
 export declare const RECURRING_RULE_KEYS: string[];
 /** @internal スケジュールの設定を検証して取り込む（誤りは c に集める） */
 export declare function compileScheduleOptions<T, Kind extends string>(c: IssueCollector, options: unknown): CompiledSchedule<T, Kind> | undefined;
-/** @internal 毎年の月日の規則がその月日 "MM-DD" に当てはまるか */
-export declare function matchAnnual(rule: AnnualRule<unknown>, monthDay: string): boolean;
+/** @internal 毎年の月日の規則の形がその月日 "MM-DD" に当てはまるか（有効期間は考えない） */
+export declare function matchMonthDay(rule: AnnualRule<unknown>, monthDay: string): boolean;
+/** @internal 毎年の月日の規則がその日に当てはまるか（有効期間を含む） */
+export declare function matchAnnual(rule: AnnualRule<unknown>, date: DateString): boolean;
 /** @internal 値を決めた規則（祝日・曜日で決まった場合は null） */
 export type DecidingRule<T> = DateRule<T> | AnnualRule<T> | RecurringRuleCompiled<T>;
 /** @internal 1 日分の結果と、値を決めた規則 */

package/dist/core/schedule.js

@@ -10,7 +10,8 @@
  *   6. weekly  … 曜日ごとの値
  *
  * "under-holiday" の規則は、祝日の扱いが "weekday"（曜日どおり）なら祝日にも当てはまる。
- * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）
+ * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
+ * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
@@ -36,6 +37,31 @@ export function isValidMonthDay(value) {
 }
 /** @internal 曜日の番号として正しいか */
 export const isWeekday = (value) => Number.isInteger(value) && value >= 0 && value <= 6;
+/** @internal 日数 n が有効期間の中か */
+export const inPeriod = (rule, n) => (rule.effectiveFrom === null || n >= rule.effectiveFrom) &&
+    (rule.effectiveTo === null || n <= rule.effectiveTo);
+/** 有効期間（effectiveFrom・effectiveTo）を検証して日数にする（誤りは c に記録して undefined） */
+function checkPeriod(c, path, entry) {
+    let ok = true;
+    const read = (key) => {
+        const raw = entry[key];
+        if (raw === undefined)
+            return null;
+        const n = checkDate(c, `${path}.${key}`, raw);
+        if (n === undefined)
+            ok = false;
+        return n ?? null;
+    };
+    const effectiveFrom = read("effectiveFrom");
+    const effectiveTo = read("effectiveTo");
+    if (!ok)
+        return undefined;
+    if (effectiveFrom !== null && effectiveTo !== null && effectiveFrom > effectiveTo) {
+        c.error("invalid-range", path, `"effectiveFrom" must not be after "effectiveTo" (${String(entry["effectiveFrom"])} > ${String(entry["effectiveTo"])})`);
+        return undefined;
+    }
+    return { effectiveFrom, effectiveTo };
+}
 function checkName(c, path, name) {
     if (name === undefined)
         return undefined;
@@ -123,11 +149,12 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
         }
         const value = valueOf(entry, p);
         const name = checkName(c, p, entry["name"]);
+        const period = checkPeriod(c, p, entry);
         if ("date" in entry) {
-            checkUnknownKeys(c, p, entry, ["date", "name", "value"]);
+            checkUnknownKeys(c, p, entry, ["date", "name", "value", ...PERIOD_KEYS]);
             const md = checkMonthDay(c, `${p}.date`, entry["date"]);
-            if (md !== undefined && value !== undefined) {
-                rules.push({ path: p, from: md, to: md, value, name });
+            if (md !== undefined && value !== undefined && period) {
+                rules.push({ path: p, from: md, to: md, value, name, ...period });
             }
             return;
         }
@@ -135,11 +162,11 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
             c.error("invalid-option", p, 'must have "date" or both "from" and "to"');
             return;
         }
-        checkUnknownKeys(c, p, entry, ["from", "to", "name", "value"]);
+        checkUnknownKeys(c, p, entry, ["from", "to", "name", "value", ...PERIOD_KEYS]);
         const from = checkMonthDay(c, `${p}.from`, entry["from"]);
         const to = checkMonthDay(c, `${p}.to`, entry["to"]);
-        if (from !== undefined && to !== undefined && value !== undefined) {
-            rules.push({ path: p, from, to, value, name });
+        if (from !== undefined && to !== undefined && value !== undefined && period) {
+            rules.push({ path: p, from, to, value, name, ...period });
         }
     });
     return rules;
@@ -189,6 +216,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         let weekday = null;
         let nth = null;
         let days = null;
+        let interval = null;
+        let anchor = null;
+        const hasInterval = "interval" in entry;
+        const hasAnchor = "anchor" in entry;
         if (hasWeekday) {
             if (isWeekday(entry["weekday"]))
                 weekday = entry["weekday"];
@@ -203,11 +234,39 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 else
                     ok = false;
             }
+            if (hasInterval !== hasAnchor) {
+                c.error("invalid-option", p, '"interval" and "anchor" must be specified together');
+                ok = false;
+            }
+            else if (hasInterval) {
+                if ("nth" in entry) {
+                    c.error("invalid-option", `${p}.interval`, '"interval" cannot be used with "nth"');
+                    ok = false;
+                }
+                const i = entry["interval"];
+                if (!Number.isInteger(i) || i < 2) {
+                    c.error("invalid-option", `${p}.interval`, "must be an integer of 2 or more (weeks)");
+                    ok = false;
+                }
+                else
+                    interval = i;
+                const a = checkDate(c, `${p}.anchor`, entry["anchor"]);
+                if (a === undefined)
+                    ok = false;
+                else if (weekday !== null && weekdayOf(entry["anchor"]) !== weekday) {
+                    c.error("invalid-option", `${p}.anchor`, `must be on the same weekday as "weekday" (${String(entry["anchor"])} is weekday ${weekdayOf(entry["anchor"])})`);
+                    ok = false;
+                }
+                else
+                    anchor = a;
+            }
         }
         else {
-            if ("nth" in entry) {
-                c.error("invalid-option", `${p}.nth`, '"nth" can be used only with "weekday"');
-                ok = false;
+            for (const key of ["nth", "interval", "anchor"]) {
+                if (key in entry) {
+                    c.error("invalid-option", `${p}.${key}`, `"${key}" can be used only with "weekday"`);
+                    ok = false;
+                }
             }
             const set = checkSet(c, `${p}.day`, entry["day"], isDayOfMonth, "1-31 or -1 (last day)");
             if (set)
@@ -234,23 +293,30 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
             c.error("invalid-option", `${p}.onHolidayRule`, `must be one of ${ON_HOLIDAY_RULES.map((v) => `"${v}"`).join(", ")}`);
             ok = false;
         }
-        if (ok && value !== undefined) {
+        const period = checkPeriod(c, p, entry);
+        if (ok && period && value !== undefined) {
             rules.push(Object.freeze({
                 path: p,
                 weekday,
                 nth,
+                interval,
+                anchor,
                 days,
                 months,
                 onHolidayRule: onHoliday,
                 value,
                 name,
+                ...period,
             }));
         }
     });
     return rules;
 }
-/** @internal 繰り返しの規則がその日に当てはまるか（祝日かどうかは考えない） */
-export function matchRecurring(rule, date) {
+/**
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・月）がその日に当てはまるか。
+ * 有効期間と祝日かどうかは考えない（規則の診断で、形どうしの包含を調べるために分けている）
+ */
+export function matchPattern(rule, date) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
@@ -258,12 +324,18 @@ export function matchRecurring(rule, date) {
     if (rule.weekday !== null) {
         if (weekdayOf(date) !== rule.weekday)
             return false;
+        if (rule.interval !== null)
+            return (toDayNumber(date) - rule.anchor) % (7 * rule.interval) === 0;
         if (rule.nth === null)
             return true;
         return rule.nth.has(Math.ceil(day / 7)) || (rule.nth.has(-1) && day + 7 > dim);
     }
     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);
+}
 /** 規則の value を取り出す（value が必須の規則用） */
 function requiredValue(c) {
     return (entry, path) => {
@@ -485,7 +557,19 @@ const SCHEDULE_OPTION_KEYS = [
     "recurring",
 ];
 /** @internal 繰り返しの規則の項目 */
-export const RECURRING_RULE_KEYS = ["weekday", "nth", "day", "months", "name", "onHolidayRule"];
+/** @internal 有効期間の項目 */
+export const PERIOD_KEYS = ["effectiveFrom", "effectiveTo"];
+export const RECURRING_RULE_KEYS = [
+    "weekday",
+    "nth",
+    "interval",
+    "anchor",
+    "day",
+    "months",
+    "name",
+    "onHolidayRule",
+    ...PERIOD_KEYS,
+];
 /** @internal スケジュールの設定を検証して取り込む（誤りは c に集める） */
 export function compileScheduleOptions(c, options) {
     if (!isObject(options)) {
@@ -526,12 +610,16 @@ export function compileScheduleOptions(c, options) {
 }
 /** 振替元をさかのぼる最大日数（祝日が続く日数の上限。2019 年の大型連休でも 10 日） */
 const MAX_HOLIDAY_RUN = 31;
-/** @internal 毎年の月日の規則がその月日 "MM-DD" に当てはまるか */
-export function matchAnnual(rule, monthDay) {
+/** @internal 毎年の月日の規則の形がその月日 "MM-DD" に当てはまるか（有効期間は考えない） */
+export function matchMonthDay(rule, monthDay) {
     return rule.from <= rule.to
         ? monthDay >= rule.from && monthDay <= rule.to
         : monthDay >= rule.from || monthDay <= rule.to;
 }
+/** @internal 毎年の月日の規則がその日に当てはまるか（有効期間を含む） */
+export function matchAnnual(rule, date) {
+    return inPeriod(rule, toDayNumber(date)) && matchMonthDay(rule, date.slice(5));
+}
 /**
  * @internal 検証済みの規則から、1 日分の値と値を決めた規則を返す関数を作る。
  * 規則の診断では、規則を取り除いた版と結果を比べるために、祝日を調べる機能（lookup）を共有して作る
@@ -585,8 +673,7 @@ export function createResolver(compiled, lookup) {
         const byDate = dates.find((r) => dayNumber >= r.from && dayNumber <= r.to);
         if (byDate)
             return make(byDate.value, "date", byDate, byDate.name);
-        const monthDay = date.slice(5);
-        const byAnnual = annual.find((r) => matchAnnual(r, monthDay));
+        const byAnnual = annual.find((r) => matchAnnual(r, date));
         if (byAnnual)
             return make(byAnnual.value, "annual", byAnnual, byAnnual.name);
         if (holiday) {

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は 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 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 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/jp/index.d.ts

@@ -47,16 +47,23 @@ export declare function holidaysInYear(year: number): readonly JapaneseHoliday[]
 export declare function holidaysBetween(from: DateInput, to: DateInput): readonly JapaneseHoliday[];
 /**
  * 日本時間での暦日。
+ * @deprecated 0.10.0 で非推奨。ルートの toDateString(input, "Asia/Tokyo")、または営業日カレンダー・スケジュールの
+ * dateOf(input) に移行する（同じ変換。docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare function toJapanDate(input: DateInput): DateString;
 /**
  * 日本時間での暦日と時刻（"HH:mm"。暦日だけの入力では null）。
  * 時刻を必ず持つ入力（Date・Temporal.Instant など）では、time の型が string になる。
+ * @deprecated 0.10.0 で非推奨。ルートの toDateTimeParts(input, "Asia/Tokyo")、または営業日カレンダー・スケジュールの
+ * civilOf(input) に移行する（同じ変換・同じ型。docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export declare function toJapanDateTime(input: DateTimeInput): CivilDateTimeParts<string>;
-/** @public */
+/**
+ * @deprecated 0.10.0 で非推奨。toDateTimeParts(input, "Asia/Tokyo") または civilOf(input) に移行する
+ * @public
+ */
 export declare function toJapanDateTime(input: DateInput): CivilDateTimeParts;
 /**
  * 反映済みの官報の年月。

package/dist/jp/index.js

@@ -64,6 +64,8 @@ export function holidaysBetween(from, to) {
 }
 /**
  * 日本時間での暦日。
+ * @deprecated 0.10.0 で非推奨。ルートの toDateString(input, "Asia/Tokyo")、または営業日カレンダー・スケジュールの
+ * dateOf(input) に移行する（同じ変換。docs/migration.md）。1.0.0 で削除する
  * @public
  */
 export function toJapanDate(input) {

package/package.json

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