bizdays-toolkit 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -4,6 +4,55 @@
 
 ## [Unreleased]
 
+## [0.20.0] - 2026-10-25
+
+### 移行
+
+動作が変わる既存の API はない。サブパス `bizdays-toolkit/fr` が増える。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- フランスの祝日の提供元 `bizdays-toolkit/fr` を追加した。`metropole`（ID `FR`。労働法典 L3133-1 の 11 日）と `alsaceMoselle`（ID `FR-AM`。Vendredi saint と 12 月 26 日が加わる）で、タイムゾーンは `Europe/Paris`、対応年は 2000〜2099 年。固定日と復活祭からの日数で計算し、振替はない。名称は data.gouv.fr の表記（フランス語）、`nameEn` は英訳、`key` は英語名から（`labour-day`・`pentecost-monday` など 13 個。型 `KnownFrHolidayKey`）。2 つの祝日が同じ日に当たる年（2008 年・2059 年の Ascension）は復活祭の側の名称で 1 件。祝日は法令で定まり年ごとの告示がないので、すべて `confirmed: true` で `confirmedThrough` は持たない。型 `FrHoliday`・`FrHolidayKind`・`KnownFrHolidayKind` を追加した
+- data.gouv.fr の「Jours fériés en France」（DINUM。Métropole と Alsace-Moselle のゾーンの JSON）の 2006〜2031 年のすべての日付と名称に一致することをテストで確かめる（`test/fixtures/datagouv-jours-feries.json`）
+
+### Changed
+
+- README: 提供元の表にフランスを足し、min+gzip のサイズの値を 0.20.0 で測り直した（ルート 10.0 → 11.0 KB。0.18.0・0.19.0 の追加分を含む）
+- `docs/guide.md`・`docs/guide.ja.md`: 「French public holidays / フランスの祝日」の節と、識別子の表のフランスの行を足した
+- `RELEASING.md`: 「フランスのデータの更新」の節を足し、区分の表の「規則で計算する提供元」にフランスを含めた
+- `docs/decisions.md`: 48 番（フランスの提供元と、4 か国目の選び方の基準）を追加した
+- `package.json`: `exports` に `./fr`、keywords に `france` を足した
+
+### 開発
+
+- 監視のワークフロー `data-watch.yml` に data.gouv.fr の照合を足した（issue のラベル `datagouv-data`。ハートビートは 4 つの照合がすべて動いたときだけ）。`scripts/verify-datagouv.ts` を英国・シンガポール・日本と同じ形で追加した（`pnpm verify:datagouv`）
+- テスト: `test/fr-rules.test.ts`・`test/fr-datagouv.test.ts` を追加し、`test/holiday-key.test.ts`・ESM/CJS/ブラウザー/workerd の確認・利用者の型チェックにフランスを足した
+- サイズの上限（`size-limits.json`）に `./fr` 6,500（測定 5,404）を足した（gzip）
+
+## [0.19.0] - 2026-10-25
+
+### 移行
+
+動作が変わる既存の API はない（`"after-holiday"` の規則に `skipWeekdays` を付けなければ振替先はこれまでどおり）。繰り返しの規則の形 `{ businessDayOfMonth }` と項目 `skipWeekdays`・`calendar`、診断コード `counting-basis` が増える。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 繰り返しの規則に月の第 n 営業日の形 `{ businessDayOfMonth: n }` を追加した（型 `BusinessDayOfMonthPattern`・`BusinessDayOfMonth`。n は 1〜31 と -1（最後）〜-31、配列可、`months` で絞れる）。「月末最終営業日は棚卸しで休業」「四半期初の第 1・第 5 営業日は予約を止める」を規則として書ける。数える基準はそのカレンダーの繰り返しの規則をすべて除いた判定（個別の日付・毎年の休業日・祝日・定休日の曜日）で、`nthBusinessDayOfMonth`・`lastBusinessDayOfMonth` は規則を適用した後の実際の営業日を返す。`onHolidayRule` は `"under-holiday"`（既定）と `"over-holiday"`（`holidayPolicy: "open"` で第 n 営業日が祝日に当たるときも適用する）を受け、`"after-holiday"` は `invalid-option`。スケジュールでは数える基準のカレンダーを `calendar` で指定する（必須。タイムゾーンが違えば `time-zone-conflict`。カレンダーの側に書くと `invalid-option`）
+- `"after-holiday"` の曜日・日の規則に `skipWeekdays` を追加した。本来の日が祝日かその曜日なら、以降で最初の「祝日でもその曜日でもない日」に振り替える（「6 月 15 日は創立記念日。土日祝なら翌営業日」は `{ day: 15, months: [6], onHolidayRule: "after-holiday", skipWeekdays: [0, 6] }`、「月曜定休。祝日なら翌平日（土曜日には落とさない）」は `{ weekday: 1, onHolidayRule: "after-holiday", skipWeekdays: [6] }`）。`"after-holiday"` 以外の規則や規則自身の曜日に付けると `invalid-option`
+- 診断コード `counting-basis`（info）を追加した。`businessDayOfMonth` の規則と、同じ設定の毎週の曜日の規則（`{ weekday }`）が同居する設定で、その曜日が営業日として数えられることを知らせる。`businessDayOfMonth` の規則は `never-matches`（その月にない回）・`shadowed`（n・months・基準のカレンダーの包含）・`redundant` の対象。`holidayPolicy: "closed"` の `businessDayOfMonth` の規則の `"over-holiday"` は `redundant`（info）。`skipWeekdays` が違う規則どうしは `shadowed` にしない
+
+### Changed
+
+- `docs/guide.md`・`docs/guide.ja.md`: 繰り返しの規則の表と本文に第 n 営業日と `skipWeekdays` を足し、コード例（銀行の支店とスケジュール）を足した
+- README: 規則の表に `businessDayOfMonth`・`skipWeekdays` を足した
+- `docs/decisions.md`: 47 番（第 n 営業日の規則・`skipWeekdays`・監視の報告書の日付）を追加し、14 番に `skipWeekdays` の追記をした
+
+### 開発
+
+- 監視の照合スクリプト（`scripts/verify-govuk.ts`・`verify-datagovsg.ts`・`verify-cao.ts`）の「確認した日付」を UTC から日本時間に揃えた（issue のコメントの日付と同じ基準）
+- テスト: `test/business-day-of-month.test.ts`・`test/skip-weekdays.test.ts` を追加し、`test/types.check.ts`・利用者の型チェックに新しい規則を足した
+- サイズの上限（`size-limits.json`）を上げた。ルート 25,000 → 26,500（測定 25,100）、`./jp` 28,000 → 29,500（測定 28,128）、`./diagnose` 33,000 → 35,500（測定 34,038）（gzip）。第 n 営業日の規則の判定・基準のキャッシュ・検証と、`skipWeekdays` の振替、診断の追加のため
+
 ## [0.18.0] - 2026-10-25
 
 ### 移行
@@ -494,7 +543,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.18.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.20.0...HEAD
+[0.20.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.19.0...v0.20.0
+[0.19.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.17.1...v0.18.0
 [0.17.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.17.0...v0.17.1
 [0.17.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...v0.17.0

package/README.md

@@ -19,12 +19,12 @@
 
 A business-day calendar that combines public holidays with company or store closures.
 
-- **Holidays verified day by day against official data**: Japan (Cabinet Office, 1955 to the latest year in the Official Gazette), the UK (GOV.UK; England, Wales, Scotland and Northern Ireland, 2012 onwards) and Singapore (Ministry of Manpower on data.gov.sg, 2020 onwards). Every date is checked in the tests, differences are watched daily and shipped as patch versions
+- **Holidays verified day by day against official data**: Japan (Cabinet Office, 1955 to the latest year in the Official Gazette), France (data.gouv.fr; metropolitan France and Alsace-Moselle, verified for 2006–2031), the UK (GOV.UK; England, Wales, Scotland and Northern Ireland, 2012 onwards) and Singapore (Ministry of Manpower on data.gov.sg, 2020 onwards). Every date is checked in the tests, differences are watched daily and shipped as patch versions
 - **Business-day arithmetic**: closed weekdays, annual closures (across the new year too), specific closed and open dates and holidays combine into "N business days later", "next business day after the cutoff" and month-based due dates with the four adjustment conventions used in finance
 - **Recurring rules**: "closed on the 3rd Wednesday", "every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays, or the next weekday when Monday is a holiday", "the day after (or before) a holiday", each with its own behaviour on holidays and an optional effective period
 - **Day-by-day values and combined calendars**: store hours that change by weekday, holiday and date; a business-day calendar made from such a schedule; and the days on which all (or any) of several calendars are open
 - **Option diagnostics**: `bizdays-toolkit/diagnose` lists rules that never apply, rules that are shadowed or redundant, rules that have ended, typos in option names and options with no business day at all, without throwing. One line in a test keeps options honest
-- **Lightweight, zero dependencies, time-zone safe**: about 10.0 KB min+gzip (about 11.8 KB with Japanese holidays, about 11.7 KB with UK bank holidays, about 10.9 KB with Singapore holidays; measured for 0.17.0). Standard JavaScript and `Intl` only, ESM with bundled types; tested on Node.js, Chrome, Firefox, Edge, Safari, Cloudflare Workers, Bun and Deno. Instants such as `Date` are converted to a civil date in the calendar's time zone before evaluation
+- **Lightweight, zero dependencies, time-zone safe**: about 11.0 KB min+gzip (about 12.9 KB with Japanese holidays, about 11.9 KB with French holidays, about 12.8 KB with UK bank holidays, about 11.9 KB with Singapore holidays; measured for 0.20.0). Standard JavaScript and `Intl` only, ESM with bundled types; tested on Node.js, Chrome, Firefox, Edge, Safari, Cloudflare Workers, Bun and Deno. Instants such as `Date` are converted to a civil date in the calendar's time zone before evaluation
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface, and `bizdays-toolkit/provider` exposes the calendar arithmetic (nth weekday of a month, Easter, substitute days for holidays on a weekend) that most countries' holidays are built from
 
 ## Installation
@@ -60,11 +60,12 @@ The [guide](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md)
 
 ## What you can do
 
-### Holidays of Japan, the UK and Singapore
+### Holidays of Japan, France, the UK and Singapore
 
 | Provider                                          | Subpath              | Time zone        | Supported years | Verified against                       |
 | ------------------------------------------------- | -------------------- | ---------------- | --------------- | -------------------------------------- |
 | `jp`                                              | `bizdays-toolkit/jp` | `Asia/Tokyo`     | 1955–2099       | Cabinet Office "National Holidays" CSV |
+| `metropole`, `alsaceMoselle`                      | `bizdays-toolkit/fr` | `Europe/Paris`   | 2000–2099       | data.gouv.fr "Jours fériés en France"  |
 | `england`, `wales`, `scotland`, `northernIreland` | `bizdays-toolkit/uk` | `Europe/London`  | 2012–2099       | GOV.UK bank holidays                   |
 | `sg`                                              | `bizdays-toolkit/sg` | `Asia/Singapore` | 2020–2027       | data.gov.sg (Ministry of Manpower)     |
 
@@ -74,15 +75,17 @@ Each holiday carries its date, name (and English name), `kind` (national, substi
 
 A calendar is built from the holiday provider and your closures: `closedWeekdays`, `closedAnnual` (month-day ranges, across the new year too), `closedDates` and `openDates`, and recurring rules in `closedRecurring` / `openRecurring`:
 
-| Rule                                                      | Meaning                                                                         |
-| --------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `{ weekday: 3, nth: 3 }`                                  | The 3rd Wednesday (`nth` is 1–5 or -1 for the last; an array for several)       |
-| `{ weekday: 3, interval: 2, anchor: "2026-01-07" }`       | Every other Wednesday, counted from the anchor                                  |
-| `{ day: 20 }`, `{ day: -1 }`                              | The 20th, the last day of the month                                             |
-| `{ holiday: true, kinds: ["substitute"] }`                | Holidays, optionally narrowed by kind or by key (`keys: ["vernal-equinox"]`)    |
-| `{ dayAfterHoliday: true }`, `{ dayBeforeHoliday: true }` | The day after (or before) a holiday or a run of holidays                        |
-| `onHolidayRule: "after-holiday"`                          | "Closed on Mondays, or the next weekday when Monday is a holiday" (museum rule) |
-| `effectiveFrom`, `effectiveTo`                            | The period the rule is in effect                                                |
+| Rule                                                      | Meaning                                                                          |
+| --------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| `{ weekday: 3, nth: 3 }`                                  | The 3rd Wednesday (`nth` is 1–5 or -1 for the last; an array for several)        |
+| `{ weekday: 3, interval: 2, anchor: "2026-01-07" }`       | Every other Wednesday, counted from the anchor                                   |
+| `{ day: 20 }`, `{ day: -1 }`                              | The 20th, the last day of the month                                              |
+| `{ businessDayOfMonth: -1 }`, `{ businessDayOfMonth: 5 }` | The last business day of the month, the 5th business day                         |
+| `{ holiday: true, kinds: ["substitute"] }`                | Holidays, optionally narrowed by kind or by key (`keys: ["vernal-equinox"]`)     |
+| `{ dayAfterHoliday: true }`, `{ dayBeforeHoliday: true }` | The day after (or before) a holiday or a run of holidays                         |
+| `onHolidayRule: "after-holiday"`                          | "Closed on Mondays, or the next weekday when Monday is a holiday" (museum rule)  |
+| `skipWeekdays: [0, 6]`                                    | With `"after-holiday"`: also skip weekends ("June 15, or the next business day") |
+| `effectiveFrom`, `effectiveTo`                            | The period the rule is in effect                                                 |
 
 `dayInfo` tells you why a day is open or closed (`reason`, `name`, `rulePath`). Every bundled holiday that recurs each year has a stable `key` (`vernal-equinox`, `good-friday`, `hari-raya-puasa`, …), so a rule can select individual holidays that no date pattern can express. Details: [Business-day calendars](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#business-day-calendars), [Recurring rules](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#recurring-rules), [Holiday keys](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#holiday-keys), [Common recipes](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#common-recipes).
 
@@ -126,7 +129,7 @@ A holiday provider is an object with `id`, `timeZone`, `supportedYears` and `hol
 
 Versioning follows [Semantic Versioning](https://semver.org/). See [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md) (Japanese) for details.
 
-- Official data updates (new, moved and one-off holidays by law, Official Gazette or proclamation, fixed equinox days in Japan, newly published years on GOV.UK, newly gazetted years and revised dates in Singapore) are released as **patch** versions, so they reach you with either `^` or `~`
+- Official data updates (new, moved and one-off holidays by law, Official Gazette or proclamation, fixed equinox days in Japan, newly published years on GOV.UK, newly gazetted years and revised dates in Singapore, changes to the French Labour Code) are released as **patch** versions, so they reach you with either `^` or `~`
 - To freeze the holiday results, pin an exact version (for example `"bizdays-toolkit": "0.8.0"`)
 - The reflected data is shown by the provider's `dataVersion` (for Japan, the year and month of the Official Gazette reflected; for the UK and Singapore, the year and month of the GOV.UK or data.gov.sg data reflected) and `confirmedThrough` (`jp.dataVersion`, `england.confirmedThrough` and so on). The module-level constants `dataVersion` and `confirmedThrough` in `bizdays-toolkit/jp` and `bizdays-toolkit/uk` are deprecated since 0.12.0 and will be removed in 1.0.0
 - Before 1.0.0, minor versions may contain breaking changes. What you need to change when moving between minor versions is listed in the [migration guide](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/migration.md) (Japanese) and in the "移行" (migration) part of each version in the CHANGELOG
@@ -140,7 +143,9 @@ UK bank holidays are verified with the GOV.UK bank holidays data (<https://www.g
 
 Singapore public holidays are verified with the "Singapore Public Holidays" collection published by the Ministry of Manpower on data.gov.sg (<https://data.gov.sg/collections/691/view>), with the Ministry's press releases as the authority where the two differ (the verification data is a test fixture only; not included in the package).
 
-Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/), and data from data.gov.sg made available under the [Singapore Open Data Licence](https://data.gov.sg/open-data-licence).
+French public holidays are verified with the "Jours fériés en France" dataset published by DINUM on data.gouv.fr (<https://www.data.gouv.fr/datasets/jours-feries-en-france>, JSON exports for the Métropole and Alsace-Moselle zones; the verification data is a test fixture only; not included in the package).
+
+Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/), data from data.gov.sg made available under the [Singapore Open Data Licence](https://data.gov.sg/open-data-licence), and data from data.gouv.fr made available under the [Licence Ouverte / Open Licence 2.0](https://www.etalab.gouv.fr/licence-ouverte-open-licence).
 
 ## License
 

package/dist/core/calendar.js

@@ -72,8 +72,8 @@ export function compileCalendarOptions(c, options) {
     const annual = compileAnnualRules(c, "closedAnnual", o["closedAnnual"], () => false, true);
     const open = compileDateRules(c, "openDates", o["openDates"], () => true, true);
     const closed = compileDateRules(c, "closedDates", o["closedDates"], () => false, true);
-    const openRecurring = compileRecurringRules(c, "openRecurring", o["openRecurring"], () => true, RECURRING_RULE_KEYS);
-    const closedRecurring = compileRecurringRules(c, "closedRecurring", o["closedRecurring"], () => false, RECURRING_RULE_KEYS);
+    const openRecurring = compileRecurringRules(c, "openRecurring", o["openRecurring"], () => true, RECURRING_RULE_KEYS, "calendar");
+    const closedRecurring = compileRecurringRules(c, "closedRecurring", o["closedRecurring"], () => false, RECURRING_RULE_KEYS, "calendar");
     return {
         schedule: {
             source,

package/dist/core/diagnose.d.ts

@@ -13,6 +13,8 @@
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
  *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *             counting-basis: 第 n 営業日の規則（businessDayOfMonth）の数える基準は繰り返しの規則を除くので、
+ *                             同じ設定の毎週の曜日の規則（{ weekday }）の曜日は営業日として数えられる（relatedPath にその規則）
  *
  * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
  * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
@@ -51,7 +53,9 @@ export type KnownDiagnosticCode = KnownErrorCode
 /** 取り除いても結果が変わらない */
  | "redundant"
 /** 基準日（asOf）より前に終わった規則・日付（整理の候補） */
- | "expired";
+ | "expired"
+/** 第 n 営業日の規則の数える基準に、同じ設定の曜日の規則が入らない（その曜日を営業日として数える） */
+ | "counting-basis";
 /**
  * 診断コード。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
  * @public

package/dist/core/diagnose.js

@@ -13,6 +13,8 @@
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
  *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *             counting-basis: 第 n 営業日の規則（businessDayOfMonth）の数える基準は繰り返しの規則を除くので、
+ *                             同じ設定の毎週の曜日の規則（{ weekday }）の曜日は営業日として数えられる（relatedPath にその規則）
  *
  * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
  * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
@@ -26,7 +28,7 @@
 import { daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, } from "./date.js";
 import { compileCalendarOptions } from "./calendar.js";
 import { IssueCollector, rangeError } from "./errors.js";
-import { compileScheduleOptions, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
+import { compileScheduleOptions, createBasis, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
 // ------------------------------------------------------------
 // 知らないキーの候補
 // ------------------------------------------------------------
@@ -311,6 +313,7 @@ function analyze(c, compiled, isCalendar) {
     if (!checkProviderData(c, source))
         return;
     const lookup = createHolidayLookup({ ...source, unconfirmedHolidays: "accept" });
+    const basis = createBasis(compiled, lookup);
     const cycle = patternCycle(recurring);
     const window = scanWindow(source, [...annual, ...recurring], cycle);
     /** 使われないことが分かった規則（redundant を重ねて出さない） */
@@ -381,12 +384,41 @@ function analyze(c, compiled, isCalendar) {
         eachDay(window, (n) => (found = inPeriod(rule, n) && matchPattern(rule, fromDayNumber(n), holidayOfSafe)));
         return found;
     };
+    /** 第 n 営業日の規則が、調べる期間と有効期間の中で 1 日でも当てはまるか（基準は祝日次第で年ごとに違うので、全日を調べる。対応年の外は当てはまらないとみなす） */
+    const businessDayRuleMatches = (rule) => {
+        if (!window)
+            return false;
+        let found = false;
+        eachDay(window, (n) => {
+            if (!inPeriod(rule, n))
+                return false;
+            try {
+                found = matchPattern(rule, fromDayNumber(n), holidayOfSafe, basis);
+            }
+            catch {
+                found = false;
+            }
+            return found;
+        });
+        return found;
+    };
     /** 集合 a（null はすべて）が集合 b（null はすべて）を含むか */
     const setCovers = (a, b) => a === null || (b !== null && [...b].every((v) => a.has(v)));
+    /** 振替で飛ばす曜日が同じか（違えば当てはまる日が違うので覆わない） */
+    const sameSkip = (a, b) => a.skipWeekdays === null
+        ? b.skipWeekdays === null
+        : b.skipWeekdays !== null &&
+            a.skipWeekdays.size === b.skipWeekdays.size &&
+            [...a.skipWeekdays].every((w) => b.skipWeekdays.has(w));
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
         const holidayBased = rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday;
-        const matches = holidayBased ? holidayRuleMatches(rule) : matchesAnyDay(rule, cycle);
+        const businessDayBased = rule.businessDays !== null;
+        const matches = holidayBased
+            ? holidayRuleMatches(rule)
+            : businessDayBased
+                ? businessDayRuleMatches(rule)
+                : matchesAnyDay(rule, cycle);
         if (!matches) {
             unused.add(rule);
             c.warning("never-matches", rule.path, holidayBased
@@ -397,15 +429,35 @@ function analyze(c, compiled, isCalendar) {
                         : rule.dayAfterHoliday
                             ? "This rule matches no day: no day after a holiday on the selected weekdays and months within its effective period"
                             : "This rule matches no day: no day before a holiday on the selected weekdays and months 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");
+                : businessDayBased
+                    ? "This rule matches no day: no month has that many business days of the counting basis in the selected months 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;
         }
+        // 第 n 営業日の規則の "over-holiday" は、祝日が基準の営業日にならない設定（holidayPolicy: "closed"）では結果を変えない
+        if (businessDayBased &&
+            rule.basis === null &&
+            rule.onHolidayRule === "over-holiday" &&
+            typeof compiled.holiday === "object" &&
+            "value" in compiled.holiday &&
+            compiled.holiday.value === false) {
+            c.info("redundant", `${rule.path}.onHolidayRule`, 'This option does not change the result: holidays are closed (holidayPolicy: "closed"), so an nth business day is never a holiday');
+        }
+        // 第 n 営業日の規則の数える基準は繰り返しの規則を除くので、同じ設定の毎週の曜日の規則があれば知らせる（定休日を曜日の規則で書いた設定）
+        if (businessDayBased && rule.basis === null) {
+            const weekly = recurring.find((r) => r.weekday !== null && r.nth === null && r.interval === null && r.months === null);
+            if (weekly) {
+                c.info("counting-basis", rule.path, `The business days are counted without recurring rules, so the weekday rule ${weekly.path} does not reduce the count; ` +
+                    "write regular closed weekdays as closedWeekdays if they should not be counted", weekly.path);
+            }
+        }
         // 祝日・祝日の翌日・祝前日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・識別子・曜日・月の絞り込み）だけで調べる
         const k = recurring.findIndex((r, i) => i < j &&
             canCover(r, rule) &&
             periodCovers(r, rule) &&
+            sameSkip(r, rule) &&
             (rule.holiday
                 ? r.holiday &&
                     setCovers(r.kinds, rule.kinds) &&
@@ -417,11 +469,17 @@ function analyze(c, compiled, isCalendar) {
                         r.dayBeforeHoliday === rule.dayBeforeHoliday &&
                         setCovers(r.weekdays, rule.weekdays) &&
                         setCovers(r.months, rule.months)
-                    : !r.holiday &&
-                        !r.dayAfterHoliday &&
-                        !r.dayBeforeHoliday &&
-                        intervalCovers(r, rule) &&
-                        isSubset(bits, recurringBits[i])));
+                    : rule.businessDays !== null
+                        ? r.businessDays !== null &&
+                            r.calendar === rule.calendar &&
+                            setCovers(r.businessDays, rule.businessDays) &&
+                            setCovers(r.months, rule.months)
+                        : !r.holiday &&
+                            !r.dayAfterHoliday &&
+                            !r.dayBeforeHoliday &&
+                            r.businessDays === null &&
+                            intervalCovers(r, rule) &&
+                            isSubset(bits, recurringBits[i])));
         if (k < 0)
             return;
         unused.add(rule);

package/dist/core/schedule.d.ts

@@ -23,6 +23,7 @@ import { IssueCollector } from "./errors.ts";
 import { type CivilDateTimeParts, type DateInput, type DateTimeInput } from "./input.ts";
 export type { CivilDateTimeParts } from "./input.ts";
 import { type Holiday, type HolidayProvider } from "./types.ts";
+import type { Calendar } from "./calendar.ts";
 /**
  * 祝日の値の決め方（スケジュールの holiday の設定）。
  * @public
@@ -48,6 +49,11 @@ export type Nth = 1 | 2 | 3 | 4 | 5 | -1;
  * @public
  */
 export type DayOfMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -1;
+/**
+ * 月の第 n 営業日（1〜31。-1 は最後、-2 はその前、… -31 まで。0 は不可）。
+ * @public
+ */
+export type BusinessDayOfMonth = number;
 /**
  * 月（1〜12）。
  * @public
@@ -89,7 +95,16 @@ export interface WeekdayPattern {
     readonly anchor?: DateString;
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
+    /**
+     * onHolidayRule: "after-holiday" と組で、祝日に加えて飛ばす曜日（0 = 日曜日〜6 = 土曜日）。
+     * 本来の日が祝日かこの曜日なら、その日以降で最初の、祝日でもこの曜日でもない日に振り替える
+     * （例: 月曜定休で、月曜が祝日なら翌平日（土曜日には落とさない）は { weekday: 1, onHolidayRule: "after-holiday", skipWeekdays: [6] }）。
+     * weekday 自身は含められない。"after-holiday" 以外と組にすると invalid-option
+     */
+    readonly skipWeekdays?: readonly Weekday[];
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
@@ -106,16 +121,61 @@ export interface DayOfMonthPattern {
     readonly day: DayOfMonth | readonly DayOfMonth[];
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
+    /**
+     * onHolidayRule: "after-holiday" と組で、祝日に加えて飛ばす曜日。本来の日が祝日かこの曜日なら、その日以降で最初の、
+     * 祝日でもこの曜日でもない日に振り替える（例: 「6 月 15 日は創立記念日。土日祝なら翌営業日」は
+     * { day: 15, months: [6], onHolidayRule: "after-holiday", skipWeekdays: [0, 6] }）。"after-holiday" 以外と組にすると invalid-option
+     */
+    readonly skipWeekdays?: readonly Weekday[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
+    readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
+    readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
+    readonly keys?: never;
+}
+/**
+ * 月の第 n 営業日（例: 月末最終営業日、第 5 営業日）。n は 1〜31、-1 は最後、-2 はその前。その月にない回は当てはまらない。
+ *
+ * 数える基準はこの規則を書いたカレンダーの「繰り返しの規則をすべて除いた判定」（個別の日付 → 毎年の月日 → 祝日 → 定休日の曜日）で、
+ * 定休日の曜日・祝日・年末年始休業（closedAnnual）・臨時休業日は数えに入らない。繰り返しの規則（定休日を closedRecurring の
+ * 曜日の規則で書いたものを含む）は基準に入らない。nthBusinessDayOfMonth・lastBusinessDayOfMonth はこの規則を適用した後の
+ * 実際の営業日を返すので、{ businessDayOfMonth: -1 } を休業にすると lastBusinessDayOfMonth はその前日になる。
+ * onHolidayRule は "under-holiday"（既定）と "over-holiday" を受け、"after-holiday" は invalid-option（第 n 営業日をずらす意味がない）。
+ * holidayPolicy: "open" のカレンダーでは祝日も営業日として数えるので第 n 営業日が祝日に当たることがあり、既定ではその日は
+ * 祝日の段階が先に決めてこの規則は当てはまらない（曜日の規則と同じ優先順位）。「第 1 営業日は祝日でも休業」は "over-holiday" で書く。
+ * holidayPolicy: "closed" では祝日が基準の営業日にならないので "over-holiday" は結果を変えない（診断が info で知らせる）。
+ *
+ * スケジュール（createSchedule の recurring）では、スケジュール自身に営業・休業の概念がないので、数える基準にする作成済みの
+ * カレンダーを calendar で指定する（必須。タイムゾーンはスケジュールと同じであること）。カレンダー（closedRecurring・openRecurring）
+ * では calendar は指定できない（invalid-option。基準は自分の設定で決まる）。
+ * @public
+ */
+export interface BusinessDayOfMonthPattern {
+    /** 月の第 n 営業日（1〜31、-1 は最後、-2 はその前、… -31 まで）。配列で複数指定できる */
+    readonly businessDayOfMonth: BusinessDayOfMonth | readonly BusinessDayOfMonth[];
+    /** 当てはめる月（省略時はすべての月） */
+    readonly months?: readonly Month[];
+    /** 営業日を数える基準のカレンダー（スケジュールでは必須。カレンダーでは指定できない） */
+    readonly calendar?: Calendar;
     readonly weekday?: never;
     readonly nth?: never;
     readonly interval?: never;
     readonly anchor?: never;
+    readonly day?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly weekdays?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
@@ -133,10 +193,13 @@ export interface DayAfterHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝前日（翌日が祝日で、その日自身は祝日でない日。連休なら連休の初日の前日）。「祝日」は提供元の祝日だけ。
@@ -155,10 +218,13 @@ export interface DayBeforeHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly holiday?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝日（提供元の祝日である日）。kinds で祝日の種別を、keys で個別の祝日を絞れる（省略時はすべての祝日）。
@@ -188,14 +254,17 @@ export interface HolidayPattern<Kind extends string = string> {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
+export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | BusinessDayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
@@ -421,6 +490,14 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly anchor: number | null;
     /** 日の集合（曜日の規則では null） */
     readonly days: ReadonlySet<number> | null;
+    /** 第 n 営業日の集合（第 n 営業日の規則以外では null） */
+    readonly businessDays: ReadonlySet<number> | null;
+    /** 営業日を数える基準（スケジュールの第 n 営業日の規則の calendar から。null なら自分の設定の「繰り返しの規則を除いた判定」） */
+    readonly basis: BasisOfMonth | null;
+    /** basis の元のカレンダー（診断で同じ基準かを比べるため。basis が null なら null） */
+    readonly calendar: Calendar | null;
+    /** "after-holiday" の振替で、祝日に加えて飛ばす曜日（null はなし） */
+    readonly skipWeekdays: ReadonlySet<number> | null;
     /** 祝日の翌日の規則か */
     readonly dayAfterHoliday: boolean;
     /** 祝前日の規則か */
@@ -439,18 +516,31 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly value: T;
     readonly name: string | undefined;
 }
+/**
+ * @internal 営業日を数える基準。年と月を受け取り、その月の基準で営業日である日（1〜31）を日付順に返す。
+ * 第 n 営業日の規則（businessDayOfMonth）の判定に使う
+ */
+export type BasisOfMonth = (year: number, month: number) => readonly number[];
+/** @internal カレンダーの判定関数から、月ごとに結果をキャッシュする基準を作る */
+export declare function basisFromPredicate(isOpen: (date: DateString) => boolean): BasisOfMonth;
 /** @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>[];
+export declare function compileRecurringRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, keys: readonly string[], context: "calendar" | "schedule"): RecurringRuleCompiled<T>[];
 /** @internal その日の祝日を返す関数（祝日・祝日の翌日・祝前日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
 export type HolidayOf = (date: DateString) => Holiday<string> | undefined;
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・第 n 営業日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない。
+ * 第 n 営業日の規則は、規則自身の基準（スケジュールの calendar）か basis で数え、どちらもなければ当てはまらない
  */
-export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf): boolean;
+export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf, basis?: BasisOfMonth): boolean;
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf: HolidayOf): boolean;
+export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf: HolidayOf, basis?: BasisOfMonth): boolean;
+/**
+ * @internal 第 n 営業日の規則が自分の設定を基準にする場合の基準を作る（繰り返しの規則をすべて除いた判定で営業日か）。
+ * 基準が要らない設定（第 n 営業日の規則がない、またはすべて calendar を持つ）では undefined
+ */
+export declare function createBasis<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>, lookup: HolidayLookupInternal<Kind>): BasisOfMonth | undefined;
 /** @internal 祝日の提供元とタイムゾーンの設定を検証した結果 */
 export interface HolidaySource<Kind extends string> {
     readonly providers: readonly HolidayProvider<Kind>[];

package/dist/core/schedule.js

@@ -18,7 +18,7 @@
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
-import { addDays, daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
+import { addDays, daysInMonth, formatDate, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, rangeError } from "./errors.js";
 import { instantToCivil, toCivil, toDateTimeParts, toInstant, validateTimeZone, } from "./input.js";
 import { HOLIDAY_KEY_PATTERN } from "./types.js";
@@ -176,6 +176,29 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
     return rules;
 }
 const NTH_VALUES = [1, 2, 3, 4, 5, -1];
+const isBusinessDayOfMonth = (v) => Number.isInteger(v) && v !== 0 && v >= -31 && v <= 31;
+/** @internal カレンダーの判定関数から、月ごとに結果をキャッシュする基準を作る */
+export function basisFromPredicate(isOpen) {
+    const cache = new Map();
+    return (year, month) => {
+        const key = year * 12 + month;
+        let days = cache.get(key);
+        if (days === undefined) {
+            const list = [];
+            const dim = daysInMonth(year, month);
+            for (let d = 1; d <= dim; d++)
+                if (isOpen(formatDate(year, month, d)))
+                    list.push(d);
+            days = Object.freeze(list);
+            if (cache.size >= 240)
+                cache.clear();
+            cache.set(key, days);
+        }
+        return days;
+    };
+}
+/** 作成済みのカレンダーか（createCalendar の結果の形。isBusinessDay と timeZone を持つ） */
+const isCalendarLike = (v) => isObject(v) && typeof v["isBusinessDay"] === "function" && typeof v["timeZone"] === "string";
 const ON_HOLIDAY_RULES = [
     "under-holiday",
     "over-holiday",
@@ -193,7 +216,7 @@ function checkSet(c, path, raw, valid, expected) {
     return new Set(list);
 }
 /** @internal 繰り返しの規則を検証して取り込む */
-export function compileRecurringRules(c, path, entries, valueOf, keys) {
+export function compileRecurringRules(c, path, entries, valueOf, keys, context) {
     if (entries === undefined)
         return [];
     if (!Array.isArray(entries)) {
@@ -215,13 +238,15 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const hasAfter = "dayAfterHoliday" in entry;
         const hasBefore = "dayBeforeHoliday" in entry;
         const hasHoliday = "holiday" in entry;
+        const hasBusinessDay = "businessDayOfMonth" in entry;
         if (Number(hasWeekday) +
             Number(hasDay) +
+            Number(hasBusinessDay) +
             Number(hasAfter) +
             Number(hasBefore) +
             Number(hasHoliday) !==
             1) {
-            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
+            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "businessDayOfMonth", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
             return;
         }
         let kinds = null;
@@ -229,6 +254,9 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         let weekday = null;
         let nth = null;
         let days = null;
+        let businessDays = null;
+        let basis = null;
+        let basisCalendar = null;
         let interval = null;
         let anchor = null;
         const hasInterval = "interval" in entry;
@@ -288,6 +316,32 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 else
                     ok = false;
             }
+            else if (hasBusinessDay) {
+                const set = checkSet(c, `${p}.businessDayOfMonth`, entry["businessDayOfMonth"], isBusinessDayOfMonth, "1-31 or -1 (last business day) to -31");
+                if (set)
+                    businessDays = set;
+                else
+                    ok = false;
+                if (entry["onHolidayRule"] === "after-holiday") {
+                    c.error("invalid-option", `${p}.onHolidayRule`, '"after-holiday" cannot be used with "businessDayOfMonth" (shifting the nth business day has no meaning; use "under-holiday" or "over-holiday")');
+                    ok = false;
+                }
+                if (context === "calendar") {
+                    if ("calendar" in entry) {
+                        c.error("invalid-option", `${p}.calendar`, '"calendar" cannot be used in a calendar (the counting basis is the calendar\'s own options without recurring rules)');
+                        ok = false;
+                    }
+                }
+                else if (!isCalendarLike(entry["calendar"])) {
+                    c.error("invalid-option", `${p}.calendar`, "must be a calendar made with createCalendar (the basis for counting business days; required in a schedule)");
+                    ok = false;
+                }
+                else {
+                    const calendar = entry["calendar"];
+                    basisCalendar = calendar;
+                    basis = basisFromPredicate((date) => calendar.isBusinessDay(date));
+                }
+            }
             else {
                 const key = hasAfter ? "dayAfterHoliday" : hasBefore ? "dayBeforeHoliday" : "holiday";
                 if (entry[key] !== true) {
@@ -315,6 +369,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 }
             }
         }
+        if (!hasBusinessDay && "calendar" in entry) {
+            c.error("invalid-option", `${p}.calendar`, '"calendar" can be used only with "businessDayOfMonth"');
+            ok = false;
+        }
         if (!hasHoliday && "kinds" in entry) {
             c.error("invalid-option", `${p}.kinds`, '"kinds" can be used only with "holiday"');
             ok = false;
@@ -375,6 +433,28 @@ 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;
         }
+        let skipWeekdays = null;
+        if ("skipWeekdays" in entry) {
+            if (entry["onHolidayRule"] !== "after-holiday" || !(hasWeekday || hasDay)) {
+                c.error("invalid-option", `${p}.skipWeekdays`, '"skipWeekdays" can be used only with onHolidayRule: "after-holiday" on a "weekday" or "day" rule');
+                ok = false;
+            }
+            else if (!Array.isArray(entry["skipWeekdays"])) {
+                c.error("invalid-option", `${p}.skipWeekdays`, "must be a non-empty array of weekdays (0 = Sunday to 6 = Saturday)");
+                ok = false;
+            }
+            else {
+                const set = checkSet(c, `${p}.skipWeekdays`, entry["skipWeekdays"], isWeekday, "a weekday (0 = Sunday to 6 = Saturday)");
+                if (set === undefined)
+                    ok = false;
+                else if (weekday !== null && set.has(weekday)) {
+                    c.error("invalid-option", `${p}.skipWeekdays`, `cannot include the rule's own weekday ${weekday} (the rule would be shifted every time)`);
+                    ok = false;
+                }
+                else
+                    skipWeekdays = set;
+            }
+        }
         const period = checkPeriod(c, p, entry);
         if (ok && period && value !== undefined) {
             rules.push(Object.freeze({
@@ -384,6 +464,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 interval,
                 anchor,
                 days,
+                businessDays,
+                basis,
+                calendar: basisCalendar,
+                skipWeekdays,
                 dayAfterHoliday: hasAfter,
                 dayBeforeHoliday: hasBefore,
                 holiday: hasHoliday,
@@ -401,14 +485,26 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
     return rules;
 }
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・第 n 営業日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない。
+ * 第 n 営業日の規則は、規則自身の基準（スケジュールの calendar）か basis で数え、どちらもなければ当てはまらない
  */
-export function matchPattern(rule, date, holidayOf) {
+export function matchPattern(rule, date, holidayOf, basis) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
+    if (rule.businessDays) {
+        // 第 n 営業日: 規則自身の基準（スケジュールの calendar）か、呼び出し側の基準（カレンダーの「繰り返しの規則を除いた判定」）で数える
+        const b = rule.basis ?? basis;
+        if (b === undefined)
+            return false;
+        const days = b(year, month);
+        const index = days.indexOf(day);
+        if (index < 0)
+            return false;
+        return rule.businessDays.has(index + 1) || rule.businessDays.has(index - days.length);
+    }
     if (rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday) {
         if (holidayOf === undefined)
             return false;
@@ -438,8 +534,18 @@ export function matchPattern(rule, date, holidayOf) {
     return rule.days.has(day) || (rule.days.has(-1) && day === dim);
 }
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export function matchRecurring(rule, date, holidayOf) {
-    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, holidayOf);
+export function matchRecurring(rule, date, holidayOf, basis) {
+    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, holidayOf, basis);
+}
+/**
+ * @internal 第 n 営業日の規則が自分の設定を基準にする場合の基準を作る（繰り返しの規則をすべて除いた判定で営業日か）。
+ * 基準が要らない設定（第 n 営業日の規則がない、またはすべて calendar を持つ）では undefined
+ */
+export function createBasis(compiled, lookup) {
+    if (!compiled.recurring.some((r) => r.businessDays !== null && r.basis === null))
+        return undefined;
+    const resolve = createResolver({ ...compiled, recurring: [] }, lookup);
+    return basisFromPredicate((date) => resolve(date).day.value === true);
 }
 /** 規則の value を取り出す（value が必須の規則用） */
 function requiredValue(c) {
@@ -705,6 +811,9 @@ export const RECURRING_RULE_KEYS = [
     "keys",
     "weekdays",
     "months",
+    "businessDayOfMonth",
+    "calendar",
+    "skipWeekdays",
     "name",
     "onHolidayRule",
     ...PERIOD_KEYS,
@@ -744,7 +853,17 @@ export function compileScheduleOptions(c, options) {
     }
     const annual = compileAnnualRules(c, "annual", options["annual"], requiredValue(c), false);
     const dates = compileDateRules(c, "dates", options["dates"], requiredValue(c), false);
-    const recurring = compileRecurringRules(c, "recurring", options["recurring"], requiredValue(c), [...RECURRING_RULE_KEYS, "value"]);
+    const recurring = compileRecurringRules(c, "recurring", options["recurring"], requiredValue(c), [...RECURRING_RULE_KEYS, "value"], "schedule");
+    // 第 n 営業日の規則の基準のカレンダーは、スケジュールと同じタイムゾーンであること（合成と同じ理由。瞬間の暦日が食い違うため）
+    for (const rule of recurring) {
+        if (rule.businessDays === null)
+            continue;
+        const entry = options["recurring"][Number(/\[(\d+)\]$/.exec(rule.path)[1])];
+        const tz = entry["calendar"].timeZone;
+        if (tz !== source.timeZone) {
+            c.error("time-zone-conflict", `${rule.path}.calendar`, `the calendar's time zone ${tz} differs from the schedule's ${source.timeZone}`);
+        }
+    }
     return { source, weekly, holiday, annual, dates, recurring };
 }
 /** 振替元をさかのぼる最大日数（祝日が続く日数の上限。2019 年の大型連休でも 10 日） */
@@ -766,6 +885,7 @@ export function matchAnnual(rule, date) {
 export function createResolver(compiled, lookup) {
     const { weekly, holiday: holidayRule, annual, dates, recurring } = compiled;
     const hasShift = recurring.some((r) => r.onHolidayRule === "after-holiday");
+    const basis = createBasis(compiled, lookup);
     /** 振替・祝日の規則の判断に使う祝日。提供元の対応年の外は祝日でないとみなす（振替元をさかのぼる途中で範囲を出る場合のため） */
     function holidayOfSafe(date) {
         try {
@@ -786,7 +906,8 @@ export function createResolver(compiled, lookup) {
     function shiftedOrigin(rule, date) {
         for (let k = 1; k <= MAX_HOLIDAY_RUN; k++) {
             const prev = addDays(date, -k);
-            if (!isHolidaySafe(prev))
+            // 飛ばす日は祝日と、skipWeekdays の曜日。それ以外の日に達したら、振替元はない
+            if (!isHolidaySafe(prev) && !rule.skipWeekdays?.has(weekdayOf(prev)))
                 return undefined;
             if (matchRecurring(rule, prev, holidayOfSafe))
                 return prev;
@@ -823,7 +944,7 @@ export function createResolver(compiled, lookup) {
             return make(byAnnual.value, "annual", byAnnual, byAnnual.name);
         if (holiday) {
             // 3. 祝日の上（"over-holiday"。祝日の規則 { holiday: true } もここ）
-            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, holidayOfSafe));
+            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, holidayOfSafe, basis));
             if (over)
                 return make(over.value, "recurring", over, over.name);
             // 4. 祝日
@@ -833,14 +954,17 @@ export function createResolver(compiled, lookup) {
             }
             // 祝日の扱いが「曜日どおり」なら、祝日の下（"under-holiday"）の規則も当てはまる。
             // "after-holiday" の規則は祝日には当てはめない（振り替える）
-            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, holidayOfSafe));
+            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, holidayOfSafe, basis));
             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, holidayOfSafe))
+            // skipWeekdays の曜日には当てはめない（祝日と同じく振り替える）
+            if (rule.skipWeekdays?.has(weekday))
+                continue;
+            if (matchRecurring(rule, date, holidayOfSafe, basis))
                 return make(rule.value, "recurring", rule, rule.name);
             if (hasShift && rule.onHolidayRule === "after-holiday") {
                 const origin = shiftedOrigin(rule, date);

package/dist/fr/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * フランスの祝日（jours fériés）。本土（metropole）と Alsace-Moselle の 2 つの提供元。
+ *
+ * 労働法典 L3133-1 が定める 11 日（固定日 8 日と復活祭から決まる 3 日）を規則で計算し、Alsace-Moselle には地方法の
+ * Vendredi saint と 12 月 26 日が加わる。振替はない。data.gouv.fr の「Jours fériés en France」（DINUM）の JSON と全日照合している。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { metropole } from "bizdays-toolkit/fr";
+ * const paris = createCalendar({ holidays: metropole, closedWeekdays: [0, 6] });
+ *
+ * @example Lundi de Pentecôte を「連帯の日」として出勤日にする企業（法律上は祝日のまま。既定の扱いの例外として書く）
+ * createCalendar({ holidays: metropole, closedWeekdays: [0, 6],
+ *   openRecurring: [{ holiday: true, keys: ["pentecost-monday"], name: "Journée de solidarité" }] });
+ */
+import type { Holiday, HolidayProvider } from "../core/types.ts";
+import { type FrHolidayKind } from "./rules.ts";
+export type { FrHolidayKind, KnownFrHolidayKey, KnownFrHolidayKind } from "./rules.ts";
+/**
+ * フランスの祝日。
+ * @public
+ */
+export type FrHoliday = Holiday<FrHolidayKind>;
+/**
+ * フランス本土（および data.gouv.fr の「Métropole」ゾーンに従う地域）の祝日の提供元。ID は FR、タイムゾーンは Europe/Paris。
+ * 対応年は 2000〜2099 年で、祝日は法令で定まり年ごとの告示はないので、すべて confirmed: true（confirmedThrough は持たない）。
+ * @public
+ */
+export declare const metropole: HolidayProvider<FrHolidayKind>;
+/**
+ * Alsace-Moselle（Bas-Rhin・Haut-Rhin・Moselle の 3 県。ISO 3166-2 に 1 つのコードがないので、このライブラリの ID は FR-AM）の
+ * 祝日の提供元。本土の 11 日に Vendredi saint（kind "regular"、key "good-friday"）と 12 月 26 日（"saint-stephens"）が加わる。
+ * @public
+ */
+export declare const alsaceMoselle: HolidayProvider<FrHolidayKind>;

package/dist/fr/index.js

@@ -0,0 +1,45 @@
+/**
+ * フランスの祝日（jours fériés）。本土（metropole）と Alsace-Moselle の 2 つの提供元。
+ *
+ * 労働法典 L3133-1 が定める 11 日（固定日 8 日と復活祭から決まる 3 日）を規則で計算し、Alsace-Moselle には地方法の
+ * Vendredi saint と 12 月 26 日が加わる。振替はない。data.gouv.fr の「Jours fériés en France」（DINUM）の JSON と全日照合している。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { metropole } from "bizdays-toolkit/fr";
+ * const paris = createCalendar({ holidays: metropole, closedWeekdays: [0, 6] });
+ *
+ * @example Lundi de Pentecôte を「連帯の日」として出勤日にする企業（法律上は祝日のまま。既定の扱いの例外として書く）
+ * createCalendar({ holidays: metropole, closedWeekdays: [0, 6],
+ *   openRecurring: [{ holiday: true, keys: ["pentecost-monday"], name: "Journée de solidarité" }] });
+ */
+import { DATA_VERSION, SUPPORTED_YEARS, computeFrHolidays, } from "./rules.js";
+function provider(id, zone) {
+    const cache = new Map();
+    return Object.freeze({
+        id,
+        timeZone: "Europe/Paris",
+        supportedYears: SUPPORTED_YEARS,
+        dataVersion: DATA_VERSION,
+        holidaysInYear(year) {
+            let list = cache.get(year);
+            if (!list) {
+                list = Object.freeze(computeFrHolidays(zone, year));
+                cache.set(year, list);
+            }
+            return list;
+        },
+    });
+}
+/**
+ * フランス本土（および data.gouv.fr の「Métropole」ゾーンに従う地域）の祝日の提供元。ID は FR、タイムゾーンは Europe/Paris。
+ * 対応年は 2000〜2099 年で、祝日は法令で定まり年ごとの告示はないので、すべて confirmed: true（confirmedThrough は持たない）。
+ * @public
+ */
+export const metropole = provider("FR", "metropole");
+/**
+ * Alsace-Moselle（Bas-Rhin・Haut-Rhin・Moselle の 3 県。ISO 3166-2 に 1 つのコードがないので、このライブラリの ID は FR-AM）の
+ * 祝日の提供元。本土の 11 日に Vendredi saint（kind "regular"、key "good-friday"）と 12 月 26 日（"saint-stephens"）が加わる。
+ * @public
+ */
+export const alsaceMoselle = provider("FR-AM", "alsace-moselle");

package/dist/fr/rules.d.ts

@@ -0,0 +1,47 @@
+/**
+ * フランスの祝日（jours fériés。労働法典 L3133-1 の 11 日と、Alsace-Moselle の 2 日）の計算。
+ *
+ * - 固定日の祝日（1/1・5/1・5/8・7/14・8/15・11/1・11/11・12/25。Alsace-Moselle は 12/26 も）と、
+ *   復活祭から決まる祝日（Lundi de Pâques = +1 日、Ascension = +39 日、Lundi de Pentecôte = +50 日。
+ *   Alsace-Moselle は Vendredi saint = −2 日も）を規則で計算する。振替はない
+ * - 2 つの祝日が同じ日に当たる年（復活祭が 3 月 23 日なら 5 月 1 日 = Ascension（2008 年）、3 月 30 日なら 5 月 8 日 = Ascension（2059 年））は、
+ *   復活祭から決まる祝日の名称・識別子で 1 件にする
+ *   （data.gouv.fr の JSON と同じ扱い。提供元は 1 日に 1 件を返す契約のため）
+ * - 名称は data.gouv.fr の表記（フランス語）。nameEn はライブラリの英訳
+ * - 識別子（key）は英語名から 1 つずつ（KnownFrHolidayKey）
+ *
+ * 対応年のうち data.gouv.fr が公開している範囲（過去 20 年・未来 5 年）のすべての日付と名称が一致することを、
+ * テスト用フィクスチャ（test/fixtures/datagouv-jours-feries.json）で検証している。祝日は法令で定まり年ごとの告示はないので、
+ * 対応年はすべて confirmed: true（法改正があれば労働法典の改正として反映する）。
+ */
+import type { Holiday } from "../core/types.ts";
+/**
+ * フランスの祝日の種別（既知の値）。
+ * @public
+ */
+export type KnownFrHolidayKind = 
+/** 労働法典・地方法で定まる祝日（振替・臨時の祝日はない） */
+"regular";
+/**
+ * フランスの祝日の種別。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
+ * すべての値を網羅したことを型で確かめたい場合は KnownFrHolidayKind を使う。
+ * @public
+ */
+export type FrHolidayKind = KnownFrHolidayKind | (string & {});
+/**
+ * フランスの祝日の識別子（Holiday.key。既知の値）。英語名から 1 つずつ。
+ * 規則の keys に書くときの補完に使う（型は開いているので他の文字列も通る）。
+ * @beta
+ */
+export type KnownFrHolidayKey = "new-year" | "easter-monday" | "labour-day" | "victory-in-europe" | "ascension" | "pentecost-monday" | "bastille" | "assumption" | "all-saints" | "armistice" | "christmas" | "good-friday" | "saint-stephens";
+/** @internal 地域（data.gouv.fr のゾーン） */
+export type FrZone = "metropole" | "alsace-moselle";
+/** @internal 対応年 */
+export declare const SUPPORTED_YEARS: Readonly<{
+    from: 2000;
+    to: 2099;
+}>;
+/** @internal 反映済みの data.gouv.fr のデータの年月（2006〜2031 年の公開） */
+export declare const DATA_VERSION = "2026-10";
+/** @internal その年・地域の祝日（日付順） */
+export declare function computeFrHolidays(zone: FrZone, year: number): Holiday<FrHolidayKind>[];

package/dist/fr/rules.js

@@ -0,0 +1,77 @@
+/**
+ * フランスの祝日（jours fériés。労働法典 L3133-1 の 11 日と、Alsace-Moselle の 2 日）の計算。
+ *
+ * - 固定日の祝日（1/1・5/1・5/8・7/14・8/15・11/1・11/11・12/25。Alsace-Moselle は 12/26 も）と、
+ *   復活祭から決まる祝日（Lundi de Pâques = +1 日、Ascension = +39 日、Lundi de Pentecôte = +50 日。
+ *   Alsace-Moselle は Vendredi saint = −2 日も）を規則で計算する。振替はない
+ * - 2 つの祝日が同じ日に当たる年（復活祭が 3 月 23 日なら 5 月 1 日 = Ascension（2008 年）、3 月 30 日なら 5 月 8 日 = Ascension（2059 年））は、
+ *   復活祭から決まる祝日の名称・識別子で 1 件にする
+ *   （data.gouv.fr の JSON と同じ扱い。提供元は 1 日に 1 件を返す契約のため）
+ * - 名称は data.gouv.fr の表記（フランス語）。nameEn はライブラリの英訳
+ * - 識別子（key）は英語名から 1 つずつ（KnownFrHolidayKey）
+ *
+ * 対応年のうち data.gouv.fr が公開している範囲（過去 20 年・未来 5 年）のすべての日付と名称が一致することを、
+ * テスト用フィクスチャ（test/fixtures/datagouv-jours-feries.json）で検証している。祝日は法令で定まり年ごとの告示はないので、
+ * 対応年はすべて confirmed: true（法改正があれば労働法典の改正として反映する）。
+ */
+import { addDays, easterSunday, formatDate } from "../core/date.js";
+import { rangeError } from "../core/errors.js";
+/** @internal 対応年 */
+export const SUPPORTED_YEARS = Object.freeze({ from: 2000, to: 2099 });
+/** @internal 反映済みの data.gouv.fr のデータの年月（2006〜2031 年の公開） */
+export const DATA_VERSION = "2026-10";
+/** 固定日の祝日 [月, 日, 名称, 英語名, 識別子] */
+const FIXED = [
+    [1, 1, "1er janvier", "New Year’s Day", "new-year"],
+    [5, 1, "1er mai", "Labour Day", "labour-day"],
+    [5, 8, "8 mai", "Victory in Europe Day", "victory-in-europe"],
+    [7, 14, "14 juillet", "Bastille Day", "bastille"],
+    [8, 15, "Assomption", "Assumption", "assumption"],
+    [11, 1, "Toussaint", "All Saints’ Day", "all-saints"],
+    [11, 11, "11 novembre", "Armistice Day", "armistice"],
+    [12, 25, "Jour de Noël", "Christmas Day", "christmas"],
+];
+const FIXED_ALSACE_MOSELLE = [[12, 26, "2ème jour de Noël", "Saint Stephen’s Day", "saint-stephens"]];
+/** 復活祭から決まる祝日 [日数差, 名称, 英語名, 識別子] */
+const EASTER_BASED = [
+    [1, "Lundi de Pâques", "Easter Monday", "easter-monday"],
+    [39, "Ascension", "Ascension Day", "ascension"],
+    [50, "Lundi de Pentecôte", "Pentecost Monday", "pentecost-monday"],
+];
+const EASTER_BASED_ALSACE_MOSELLE = [[-2, "Vendredi saint", "Good Friday", "good-friday"]];
+/** @internal その年・地域の祝日（日付順） */
+export function computeFrHolidays(zone, year) {
+    if (!Number.isInteger(year) || year < SUPPORTED_YEARS.from || year > SUPPORTED_YEARS.to) {
+        throw rangeError("out-of-range", `French public holidays are supported for ${SUPPORTED_YEARS.from}-${SUPPORTED_YEARS.to}; requested ${year}`);
+    }
+    const alsaceMoselle = zone === "alsace-moselle";
+    const byDate = new Map();
+    for (const [month, day, name, nameEn, key] of alsaceMoselle
+        ? [...FIXED, ...FIXED_ALSACE_MOSELLE]
+        : FIXED) {
+        byDate.set(formatDate(year, month, day), {
+            date: formatDate(year, month, day),
+            name,
+            nameEn,
+            key,
+        });
+    }
+    // 復活祭から決まる祝日が固定日と同じ日に当たる年は、復活祭の側で上書きする（data.gouv.fr の JSON と同じ）
+    const easter = easterSunday(year);
+    for (const [offset, name, nameEn, key] of alsaceMoselle
+        ? [...EASTER_BASED_ALSACE_MOSELLE, ...EASTER_BASED]
+        : EASTER_BASED) {
+        const date = addDays(easter, offset);
+        byDate.set(date, { date, name, nameEn, key });
+    }
+    return [...byDate.values()]
+        .sort((a, b) => (a.date < b.date ? -1 : 1))
+        .map((e) => Object.freeze({
+        date: e.date,
+        name: e.name,
+        nameEn: e.nameEn,
+        kind: "regular",
+        confirmed: true,
+        key: e.key,
+    }));
+}

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
 export { combineCalendars, createCalendar, createCalendarFromSchedule, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, type CombineOptions, type DateRange, type DayInfo, type DayReason, type DueDateOptions, type HolidayPolicy, type KnownDayReason, type SpecificDate, } from "./core/calendar.ts";
-export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayBeforeHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
+export { createSchedule, type AnnualRangeValue, type AnnualValue, type BusinessDayOfMonth, type BusinessDayOfMonthPattern, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayBeforeHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
 export { closingMonth, closingPeriod, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.18.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; Singapore public holidays verified against data.gov.sg. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK、シンガポールの祝日は data.gov.sg のデータで全日照合）",
+  "version": "0.20.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; Singapore public holidays verified against data.gov.sg; French public holidays (metropole, Alsace-Moselle) verified against data.gouv.fr. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK、シンガポールの祝日は data.gov.sg、フランスの祝日は data.gouv.fr のデータで全日照合）",
   "keywords": [
     "bank-holidays",
     "bizdays",
     "business-day",
     "business-days",
     "calendar",
+    "france",
     "holiday",
     "holidays",
     "japan",
@@ -51,6 +52,10 @@
       "types": "./dist/sg/index.d.ts",
       "default": "./dist/sg/index.js"
     },
+    "./fr": {
+      "types": "./dist/fr/index.d.ts",
+      "default": "./dist/fr/index.js"
+    },
     "./diagnose": {
       "types": "./dist/diagnose/index.d.ts",
       "default": "./dist/diagnose/index.js"
@@ -75,6 +80,7 @@
     "verify:cao": "node scripts/verify-cao.ts",
     "verify:govuk": "node scripts/verify-govuk.ts",
     "verify:datagovsg": "node scripts/verify-datagovsg.ts",
+    "verify:datagouv": "node scripts/verify-datagouv.ts",
     "prepublishOnly": "pnpm check",
     "release-notes": "node scripts/release-notes.ts",
     "api:update": "pnpm build && node scripts/api-report.ts --update"