bizdays-toolkit 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -4,7 +4,27 @@
 
 ## [Unreleased]
 
-## [0.4.0] - 2026-10-16
+## [0.5.0] - 2026-10-16
+
+### Added
+
+- 規則の診断（サブパス `bizdays-toolkit/diagnose`）: `diagnoseCalendar(options)`・`diagnoseSchedule(options)`。例外を投げず、`{ severity, code, path, message, relatedPath? }` の配列を返す
+  - `error`: 作成で例外になる誤り（`code` は例外と同じ）。作成時は最初の 1 件で止まるが、診断ではすべて返す。祝日の提供元が返すデータは、対応年のすべての年を調べる（`invalid-provider-data`）
+  - `warning`: `unknown-option`（知らないキー。近い既知のキーを候補に挙げる）・`shadowed`（同じ種類の先の規則に完全に含まれる。`relatedPath` に先の規則）・`never-matches`（当てはまる日がない繰り返しの規則）・`out-of-range`（個別の日付が祝日の提供元の対応年の外）・`no-business-day`（営業日が 1 日もない設定）
+  - `info`: `redundant`（取り除いても結果が変わらない規則）
+- 型: `Diagnostic`・`DiagnosticSeverity`・`DiagnosticCode`・`KnownDiagnosticCode`
+
+### Removed
+
+- `HolidayRule` 型（0.4.0 で非推奨）: `HolidayValueRule` を使う
+
+### 開発
+
+- 診断の性質のテスト（`test/diagnose-properties.test.ts`）: 使われない・取り除いても変わらないと診断した規則を実際に取り除き、結果が変わらないことを乱数の設定で確かめる
+- サイズの上限に `./diagnose` を追加
+- `docs/decisions.md` に 15 番目（規則の診断の設計）を追加
+
+## [0.4.0] - 2026-10-15
 
 ### Added
 
@@ -109,7 +129,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.2.0...v0.3.0

package/README.md

@@ -19,6 +19,7 @@
 - **日本の祝日を内閣府のデータで全日照合**: 1955 年〜官報公表済みの年まで、内閣府「国民の祝日」CSV のすべての日付と一致することをテストで確かめています（振替休日・国民の休日・皇室行事による休日・五輪特措法による移動を含む）
 - **繰り返しの規則**: 「第 3 水曜定休」「毎月末日は棚卸」「月曜休館（祝日の場合は翌平日）」のような規則を、祝日に当たったときの扱い（祝日に従う・祝日でも当てはめる・翌日に振り替える）とあわせて指定できます
 - **日ごとの値（営業時間など）**: 「火曜定休、祝日は日曜の営業時間、元日は休業、大晦日は短縮営業」のように、曜日・祝日・特定日で変わる値を同じ規則で引けます
+- **設定の診断**: `bizdays-toolkit/diagnose` の `diagnoseCalendar`・`diagnoseSchedule` が、決して使われない規則・取り除いても結果が変わらない規則・キーの打ち間違い・営業日が 1 日もない設定などを、例外を投げずに一覧で返します。テストに 1 行足せば、設定の変更で規則が死んでいないかを確かめられます
 - **営業日の計算**: 定休日の曜日・毎年の休業日（年末年始のような年をまたぐ期間も可）・臨時休業日・臨時営業日と祝日を組み合わせ、「N 営業日後」「締め時刻を過ぎたら翌営業日」などを計算します
 - **タイムゾーンを間違えない**: `Date` などの瞬間は、カレンダーのタイムゾーン（日本は `Asia/Tokyo`）で暦日に変換してから判定します。UTC で動くサーバーでも、日本時間 0〜9 時が前日扱いになりません
 - **軽量・依存ゼロ**: minify + gzip で約 6.5KB（日本の祝日込みで約 7.5KB）。ESM・型定義同梱・`sideEffects: false` で、Node.js・ブラウザー・Edge ランタイムで動作します
@@ -275,6 +276,64 @@ try {
 
 主なコード: `invalid-date`・`invalid-month-day`・`invalid-time`・`invalid-range`・`invalid-weekday`・`invalid-time-zone`・`invalid-option`・`out-of-range`・`invalid-provider`・`invalid-provider-data`・`no-business-day`。将来の版でコードが増えることがあります。
 
+### 設定の診断
+
+`bizdays-toolkit/diagnose` の `diagnoseCalendar`・`diagnoseSchedule` は、設定を調べて問題を一覧で返します。例外は投げません（問題がなければ空の配列）。
+
+```ts
+import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
+import { jp } from "bizdays-toolkit/jp";
+
+diagnoseCalendar({
+  holidays: jp,
+  closedWeekdays: [0],
+  closedRecurring: [
+    { weekday: 3, nth: 3, name: "第 3 水曜定休" },
+    { weekday: 3, nth: 3, months: [8], name: "8 月の第 3 水曜" }, // 先の規則に含まれる
+    { weekday: 0, name: "日曜休み" }, // 定休日の曜日と同じ
+  ],
+  closedDates: ["2100-01-05"], // 日本の祝日の対応年（1955〜2099 年）の外
+  closeAnnual: ["12-31"], // 打ち間違い
+});
+// [
+//   { severity: "warning", code: "unknown-option", path: "closeAnnual", message: '… (did you mean "closedAnnual"?)' },
+//   { severity: "warning", code: "out-of-range", path: "closedDates[0]", relatedPath: "holidays", message: "…" },
+//   { severity: "warning", code: "shadowed", path: "closedRecurring[1]", relatedPath: "closedRecurring[0]", message: "…" },
+//   { severity: "info", code: "redundant", path: "closedRecurring[2]", message: "…" },
+// ]
+```
+
+| 重さ（`severity`） | `code`                  | 内容                                                                                                                       |
+| ------------------ | ----------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `error`            | 例外と同じコード        | `createCalendar`・`createSchedule` で例外になる誤り。作成時は最初の 1 件で止まりますが、診断ではすべて返します             |
+| `error`            | `invalid-provider-data` | 祝日の提供元が返したデータの誤り。作成時は使った年だけを調べますが、診断では対応年のすべての年を調べます                   |
+| `warning`          | `unknown-option`        | 知らないキー（作成時は無視されます）。近い既知のキーがあれば `message` に候補を挙げます                                    |
+| `warning`          | `shadowed`              | 同じ種類の先の規則（`relatedPath`）に完全に含まれ、決して使われない規則                                                    |
+| `warning`          | `never-matches`         | 当てはまる日がない繰り返しの規則（`{ day: 30, months: [2] }` など）                                                        |
+| `warning`          | `out-of-range`          | 個別の日付が祝日の提供元（`relatedPath`）の対応年の外                                                                      |
+| `warning`          | `no-business-day`       | 営業日が 1 日もない設定（営業日カレンダーのみ。営業日を探すと例外になります）                                              |
+| `info`             | `redundant`             | 取り除いても結果が変わらない規則（先の規則の組み合わせに覆われる、定休日の曜日と同じ、スケジュールで曜日の値と同じ値など） |
+
+- 判定には `code` を使ってください。`message` は英語で、文言は変わることがあります。`code` は将来の版で増えることがあります
+- `error` があるときは、規則どうしの診断（`shadowed`・`redundant` など）は行いません
+- `shadowed` は同じ種類の規則どうし（個別の日付どうし、毎年の月日どうし、繰り返しの規則どうし）だけを調べます。判定の順番は固定なので、種類をまたいで使われない規則は `redundant` として見つかります。臨時営業日（`openDates`）と臨時休業日（`closedDates`）は同じ種類で、先の臨時営業日に含まれる臨時休業日は `shadowed` です
+- 繰り返しの規則の `shadowed` は、祝日の扱い（`onHolidayRule`）も見ます。たとえば `"under-holiday"` の規則は、同じ日に当たる `"over-holiday"` の規則を覆いません（祝日には後の規則が当たるため）
+- `redundant` は、規則を取り除いた結果と 1 日ずつ比べます。個別の日付はその期間を、毎年の月日と繰り返しの規則は個別の日付を除いた設定で、祝日の提供元の対応年（日本は 1955〜2099 年）を、提供元がなければ 2001〜2028 年（曜日と月日の組み合わせが一巡する 28 年）を調べます。スケジュールの値は、配列と普通のオブジェクトなら中身で、それ以外（`Date` など）は同じものかで比べます
+- 日本の祝日を使う設定では、全日を調べるため数百ミリ秒かかります。リクエストごとではなく、テストや起動時の確認で使ってください。開発・テスト用の道具なので、アプリの本体のバンドルに入らないようサブパスに分けています
+
+テストで設定を守る例:
+
+```ts
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
+import { shippingOptions } from "../src/calendar.ts";
+
+test("出荷カレンダーの設定に問題がない", () => {
+  assert.deepEqual(diagnoseCalendar(shippingOptions), []);
+});
+```
+
 ## バージョン番号とデータの更新
 
 [Semantic Versioning](https://semver.org/lang/ja/) に従います。詳しくは [RELEASING.md](./RELEASING.md) を参照してください。
@@ -283,7 +342,7 @@ try {
 - 祝日の判定結果を固定したい場合は、版を完全一致で指定してください（例: `"bizdays-toolkit": "0.1.0"`）
 - 反映済みのデータは `dataVersion`（日本は反映済みの官報の年月）と `confirmedThrough` で確認できます
 - 1.0.0 までは、マイナー版で破壊的変更を行うことがあります
-- 判定の理由（`reason`）・祝日の種別（`kind`）・エラーコードは、将来の版で値が増えることがあります。値を列挙して分岐するときは「その他」も扱ってください（[RELEASING.md](./RELEASING.md) の「互換性の約束」）
+- 判定の理由（`reason`）・祝日の種別（`kind`）・エラーコード・診断のコードは、将来の版で値が増えることがあります。値を列挙して分岐するときは「その他」も扱ってください（[RELEASING.md](./RELEASING.md) の「互換性の約束」）
 
 ## 出典
 
@@ -302,6 +361,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **Japanese holidays verified day by day** against the Cabinet Office CSV, from 1955 through the latest year officially announced (substitute holidays, citizens' holidays, imperial ceremonies, and the Olympic moves included)
 - **Day-by-day schedules**: `createSchedule` returns any value per day (e.g. store hours) from weekly values, a holiday rule (`"weekday"`, `{ sameAs: 0 }`, or `{ value }`), annual dates and specific dates
 - **Recurring rules**: weekly, nth-weekday-of-month (`{ weekday: 3, nth: 3 }`) and day-of-month (`{ day: -1 }`) rules, with per-rule holiday handling (`onHolidayRule`: `"under-holiday"`, `"over-holiday"`, or `"after-holiday"` to move the rule to the next non-holiday, e.g. "closed on Mondays; if Monday is a holiday, closed on the next weekday")
+- **Option diagnostics**: `diagnoseCalendar` / `diagnoseSchedule` from `bizdays-toolkit/diagnose` return a list of problems without throwing: rules that can never apply (`shadowed`, `never-matches`), rules whose removal changes nothing (`redundant`), typos in option keys with a suggestion (`unknown-option`), dates outside the holiday provider's years (`out-of-range`), and calendars with no business day. Use `code` to branch; `message` is for humans
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed/open dates, holiday policy, `addBusinessDays`, cut-off times, and more
 - **Time-zone safe**: instants (`Date`, ISO strings with offsets, Temporal) are converted to a civil date in the calendar's time zone before evaluation
 - **Lightweight, zero dependencies**: about 6.5 KB min+gzip (about 7.5 KB with Japanese holidays), ESM, bundled types, `sideEffects: false`

package/dist/core/diagnose.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 規則の診断（diagnoseCalendar・diagnoseSchedule）。
+ *
+ * 設定を作るときと同じ検証（IssueCollector）で誤りと知らないキーを集め、誤りがなければ
+ * 規則どうしの関係を調べる。例外は投げず、見つけた問題を配列で返す。
+ *
+ * - error   … createCalendar・createSchedule で例外になる誤り（code は例外と同じ）
+ * - warning … 作れるが、意図と違う可能性が高いもの
+ *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
+ *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日など）
+ *     out-of-range   … 個別の日付が祝日の提供元の対応年の外にある（relatedPath に提供元）
+ *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
+ * - info    … redundant: 取り除いても結果が変わらない規則
+ *
+ * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
+ * 固定なので、shadowed は同じ種類の規則どうしに限って調べる。種類をまたいで使われない規則は
+ * redundant（取り除いても結果が変わらない）として見つかる。
+ */
+import { type CalendarOptions } from "./calendar.ts";
+import { type KnownErrorCode } from "./errors.ts";
+import { type ScheduleOptions } from "./schedule.ts";
+/**
+ * 診断の重さ。
+ * - "error": 作成すると例外になる誤り
+ * - "warning": 作れるが、意図と違う可能性が高い
+ * - "info": 結果には影響しないが、整理できる
+ *
+ * 出力の列挙だが、重さの段階は増やさないため閉じた型にしている（docs/decisions.md の 15）。
+ * @public
+ */
+export type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * 既知の診断コード（増えることがある）。error の code は例外の code（KnownErrorCode）と同じ。
+ * @public
+ */
+export type KnownDiagnosticCode = KnownErrorCode
+/** 知らないキー（作成時は無視される） */
+ | "unknown-option"
+/** 同じ種類の先の規則に完全に覆われ、決して使われない */
+ | "shadowed"
+/** 当てはまる日がない繰り返しの規則 */
+ | "never-matches"
+/** 取り除いても結果が変わらない */
+ | "redundant";
+/**
+ * 診断コード。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
+ * @public
+ */
+export type DiagnosticCode = KnownDiagnosticCode | (string & {});
+/**
+ * 診断の結果 1 件。message は英語で、文言は API に含まない（判定には code を使う）。
+ * @public
+ */
+export interface Diagnostic {
+    readonly severity: DiagnosticSeverity;
+    readonly code: DiagnosticCode;
+    /** 設定の中の位置（例: "closedRecurring[1]"・"closedDates[0].date"）。設定全体なら "" */
+    readonly path: string;
+    readonly message: string;
+    /** 関係する別の位置（shadowed では覆っている先の規則、out-of-range では祝日の提供元） */
+    readonly relatedPath?: string;
+}
+/**
+ * 営業日カレンダーの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
+ *
+ * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
+ * JavaScript から渡された型の合わない設定も受け付ける。
+ * @public
+ */
+export declare function diagnoseCalendar(options?: CalendarOptions | object): readonly Diagnostic[];
+/**
+ * スケジュールの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
+ *
+ * 値が同じかは、配列と普通のオブジェクトは中身で、それ以外は Object.is で比べる。
+ * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
+ * @public
+ */
+export declare function diagnoseSchedule(options: ScheduleOptions<unknown> | object): readonly Diagnostic[];

package/dist/core/diagnose.js

@@ -0,0 +1,386 @@
+/**
+ * 規則の診断（diagnoseCalendar・diagnoseSchedule）。
+ *
+ * 設定を作るときと同じ検証（IssueCollector）で誤りと知らないキーを集め、誤りがなければ
+ * 規則どうしの関係を調べる。例外は投げず、見つけた問題を配列で返す。
+ *
+ * - error   … createCalendar・createSchedule で例外になる誤り（code は例外と同じ）
+ * - warning … 作れるが、意図と違う可能性が高いもの
+ *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
+ *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日など）
+ *     out-of-range   … 個別の日付が祝日の提供元の対応年の外にある（relatedPath に提供元）
+ *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
+ * - info    … redundant: 取り除いても結果が変わらない規則
+ *
+ * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
+ * 固定なので、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";
+// ------------------------------------------------------------
+// 知らないキーの候補
+// ------------------------------------------------------------
+/** 2 つの文字列の編集距離（挿入・削除・置換・隣り合う 2 文字の入れ替えを 1 と数える） */
+function editDistance(a, b) {
+    const d = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let v = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                v = Math.min(v, d[i - 2][j - 2] + 1);
+            }
+            d[i][j] = v;
+        }
+    }
+    return d[a.length][b.length];
+}
+/**
+ * 知らないキーに近い既知のキーを返す（なければ undefined）。
+ * 大文字・小文字の違い、打ち間違い（編集距離が短いキーで 1・長いキーで 2〜3）、
+ * 既知のキーの先頭部分（4 文字以上）の順に探す
+ */
+function closestKey(key, known) {
+    const lower = key.toLowerCase();
+    const sameCase = known.find((k) => k.toLowerCase() === lower);
+    if (sameCase !== undefined)
+        return sameCase;
+    const limit = Math.max(1, Math.floor(key.length / 4));
+    let best;
+    let bestDistance = limit + 1;
+    for (const k of known) {
+        const distance = editDistance(lower, k.toLowerCase());
+        if (distance < bestDistance) {
+            best = k;
+            bestDistance = distance;
+        }
+    }
+    if (best !== undefined)
+        return best;
+    if (key.length >= 4)
+        return known.find((k) => k.toLowerCase().startsWith(lower));
+    return undefined;
+}
+// ------------------------------------------------------------
+// 調べる期間
+// ------------------------------------------------------------
+/** 繰り返しの規則の当てはまり方は、年の種類（1 月 1 日の曜日 × うるう年か）の 14 通りで決まる。28 年でそろう */
+const PATTERN_FROM = toDayNumber("2001-01-01");
+const PATTERN_TO = toDayNumber("2028-12-31");
+/** 祝日の提供元があるときに調べる年の上限（長すぎる対応年は 1900〜2099 年に絞る） */
+const MAX_WINDOW_YEARS = 200;
+/** 個別の日付の期間で、取り除いた結果と比べる最大日数 */
+const MAX_DATE_RULE_DAYS = 366 * MAX_WINDOW_YEARS;
+/** 長すぎる年の範囲を 1900〜2099 年（重ならなければ先頭の 200 年）に絞る */
+function clipYears(from, to) {
+    if (to - from + 1 <= MAX_WINDOW_YEARS)
+        return [from, to];
+    const a = Math.max(from, 1900);
+    const b = Math.min(to, 2099);
+    return a <= b ? [a, b] : [from, from + MAX_WINDOW_YEARS - 1];
+}
+/** 毎年の月日・繰り返しの規則を調べる期間（祝日が年ごとに変わるので、提供元の対応年を使う） */
+function scanWindow(source) {
+    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));
+    }
+    else {
+        from = Math.max(...ranges.map((r) => r.from));
+        to = Math.min(...ranges.map((r) => r.to));
+    }
+    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;
+    }
+    return bits;
+}
+/** 毎年の月日の規則が当てはまる月日（うるう年の 366 日） */
+const LEAP_MONTH_DAYS = (() => {
+    const list = [];
+    for (let m = 1; m <= 12; m++) {
+        for (let d = 1; d <= daysInMonth(2028, m); d++) {
+            list.push(`${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`);
+        }
+    }
+    return list;
+})();
+function annualMatches(rule) {
+    return Uint8Array.from(LEAP_MONTH_DAYS, (md) => (matchAnnual(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);
+/**
+ * 先の繰り返しの規則 earlier が、後の規則 later を完全に覆えるか（祝日の扱いの組み合わせ）。
+ * - "over-holiday" の規則は、祝日でも先に当てはめる "over-holiday" の規則にしか覆われない
+ * - "under-holiday" の規則は、"over-holiday"・"under-holiday" の規則に覆われる
+ * - "after-holiday" の規則は、振替先まで同じになる "after-holiday" の規則にしか覆われない
+ */
+function canCover(earlier, later) {
+    switch (later.onHolidayRule) {
+        case "over-holiday":
+            return earlier.onHolidayRule === "over-holiday";
+        case "under-holiday":
+            return earlier.onHolidayRule !== "after-holiday";
+        case "after-holiday":
+            return earlier.onHolidayRule === "after-holiday";
+        default: {
+            const unreachable = later.onHolidayRule;
+            return unreachable;
+        }
+    }
+}
+// ------------------------------------------------------------
+// 値の比較（取り除いても結果が変わらないか）
+// ------------------------------------------------------------
+/** 値が同じか。配列と普通のオブジェクトは中身で比べ、それ以外は Object.is で比べる */
+function sameValue(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return (Array.isArray(a) &&
+            Array.isArray(b) &&
+            a.length === b.length &&
+            a.every((v, i) => sameValue(v, b[i])));
+    }
+    const plain = (o) => {
+        const proto = Object.getPrototypeOf(o);
+        return proto === Object.prototype || proto === null;
+    };
+    if (!plain(a) || !plain(b))
+        return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    return (ka.length === kb.length &&
+        ka.every((k) => Object.hasOwn(b, k) &&
+            sameValue(a[k], b[k])));
+}
+// ------------------------------------------------------------
+// 規則どうしの診断
+// ------------------------------------------------------------
+const yearOf = (dayNumber) => parseDate(fromDayNumber(dayNumber)).year;
+function without(compiled, rule, dropDates) {
+    return {
+        ...compiled,
+        dates: dropDates ? [] : compiled.dates.filter((r) => r !== rule),
+        annual: compiled.annual.filter((r) => r !== rule),
+        recurring: compiled.recurring.filter((r) => r !== rule),
+    };
+}
+/**
+ * 祝日の提供元が返すデータを、対応年（長すぎる場合は絞った範囲）のすべての年で検証する。
+ * 作成時は年ごとに初めて使うときに検証するので、使っていない年の誤りもここで見つける
+ */
+function checkProviderData(c, source) {
+    let ok = true;
+    source.providers.forEach((provider, i) => {
+        const path = source.providers.length === 1 ? "holidays" : `holidays[${i}]`;
+        const lookup = createHolidayLookup({ ...source, providers: [provider], outOfRange: "ignore" });
+        const [from, to] = clipYears(provider.supportedYears.from, provider.supportedYears.to);
+        try {
+            for (let y = from; y <= to; y++)
+                lookup.holidaysInYear(y);
+        }
+        catch (error) {
+            ok = false;
+            c.error("invalid-provider-data", path, error instanceof Error ? error.message : `Holiday provider threw ${String(error)}`);
+        }
+    });
+    return ok;
+}
+function analyze(c, compiled, isCalendar) {
+    const { source, dates, annual, recurring } = compiled;
+    if (!checkProviderData(c, source))
+        return;
+    const lookup = createHolidayLookup(source);
+    const window = scanWindow(source);
+    /** 使われないことが分かった規則（redundant を重ねて出さない） */
+    const unused = new Set();
+    // --- 個別の日付: 対応年の外・覆われている ---
+    dates.forEach((rule, j) => {
+        const fromYear = yearOf(rule.from);
+        const toYear = yearOf(rule.to);
+        source.providers.forEach((p, i) => {
+            const { from, to } = p.supportedYears;
+            if (fromYear >= from && toYear <= to)
+                return;
+            const related = source.providers.length === 1 ? "holidays" : `holidays[${i}]`;
+            c.warning("out-of-range", rule.path, `The date is outside the years supported by holiday provider ${p.id} (${from}-${to}); ` +
+                (source.outOfRange === "throw"
+                    ? "looking up this date throws"
+                    : "holidays are not considered for this date"), related);
+        });
+        const cover = dates.slice(0, j).find((r) => r.from <= rule.from && rule.to <= r.to);
+        if (cover) {
+            unused.add(rule);
+            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);
+    annual.forEach((rule, j) => {
+        const k = annualBits.findIndex((bits, i) => i < j && isSubset(annualBits[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);
+    recurring.forEach((rule, j) => {
+        const bits = recurringBits[j];
+        if (isEmpty(bits)) {
+            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)");
+            return;
+        }
+        const k = recurring.findIndex((r, i) => i < j && canCover(r, rule) && isSubset(bits, recurringBits[i]));
+        if (k < 0)
+            return;
+        unused.add(rule);
+        c.warning("shadowed", rule.path, `This rule is never used: the earlier rule ${recurring[k].path} covers all of its days`, recurring[k].path);
+    });
+    // --- 営業日が 1 日もない（営業日カレンダー） ---
+    // 個別の日付は有限なので、臨時営業日（値が true）がなければ、個別の日付を除いて調べる
+    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;
+        }
+        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");
+        }
+    }
+    // --- 取り除いても結果が変わらない ---
+    const redundant = (rule, base, days) => {
+        const resolve = createResolver(without(base, rule, false), lookup);
+        return days.every((n) => sameValue(rule.value, resolve(fromDayNumber(n)).day.value));
+    };
+    // 個別の日付は、その期間を調べる（対応年の外で例外になる日は除く）
+    const full = createResolver(compiled, lookup);
+    for (const rule of dates) {
+        if (unused.has(rule))
+            continue;
+        const decided = [];
+        let checked = 0;
+        const last = Math.min(rule.to, rule.from + MAX_DATE_RULE_DAYS - 1);
+        for (let n = rule.from; n <= last; n++) {
+            let decidedBy;
+            try {
+                decidedBy = full(fromDayNumber(n)).rule;
+            }
+            catch {
+                continue;
+            }
+            checked++;
+            if (decidedBy === rule)
+                decided.push(n);
+        }
+        if (checked > 0 && redundant(rule, compiled, decided)) {
+            c.info("redundant", rule.path, decided.length === 0
+                ? "This rule is never used: earlier rules cover all of its days"
+                : "Removing this rule does not change any result");
+        }
+    }
+    // 毎年の月日・繰り返しの規則は、調べる期間の全日を調べる。個別の日付は有限なので除いて調べる
+    if (!window)
+        return;
+    const candidates = [...annual, ...recurring].filter((r) => !unused.has(r));
+    if (candidates.length === 0)
+        return;
+    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++) {
+        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))
+            continue;
+        c.info("redundant", rule.path, days.length === 0
+            ? `This rule is never used: other rules decide every day it matches (checked ${window.label})`
+            : `Removing this rule does not change any result (checked ${window.label})`);
+    }
+}
+/** 診断を実行する。祝日の提供元の誤り（年ごとに初めて使うときに分かる）も error として返す */
+function run(c, compiled, isCalendar) {
+    if (compiled && !c.hasErrors) {
+        const before = c.issues.length;
+        try {
+            analyze(c, compiled, isCalendar);
+        }
+        catch (error) {
+            // 規則どうしの診断の途中の結果は、提供元の誤りで信頼できないので捨てる
+            c.issues.length = before;
+            const code = error?.code;
+            c.error(code === "out-of-range" ? "out-of-range" : "invalid-provider-data", "holidays", error instanceof Error ? error.message : String(error));
+        }
+    }
+    return Object.freeze(c.issues.map(({ unknownKey, knownKeys, ...issue }) => {
+        const suggestion = unknownKey === undefined || knownKeys === undefined
+            ? undefined
+            : closestKey(unknownKey, knownKeys);
+        if (suggestion !== undefined) {
+            issue.message += ` (did you mean ${JSON.stringify(suggestion)}?)`;
+        }
+        return Object.freeze(issue);
+    }));
+}
+/**
+ * 営業日カレンダーの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
+ *
+ * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
+ * JavaScript から渡された型の合わない設定も受け付ける。
+ * @public
+ */
+export function diagnoseCalendar(options = {}) {
+    const c = new IssueCollector();
+    const compiled = compileCalendarOptions(c, options);
+    return run(c, compiled?.schedule, true);
+}
+/**
+ * スケジュールの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
+ *
+ * 値が同じかは、配列と普通のオブジェクトは中身で、それ以外は Object.is で比べる。
+ * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
+ * @public
+ */
+export function diagnoseSchedule(options) {
+    const c = new IssueCollector();
+    const compiled = compileScheduleOptions(c, options);
+    return run(c, compiled, false);
+}

package/dist/core/errors.d.ts

@@ -3,6 +3,7 @@
  *
  * 例外は従来どおり RangeError・TypeError・Error のインスタンスで、code プロパティを持つ。
  * 例外のメッセージの文言は API に含まない（変わることがある）。判定には code を使う。
+ * 問題を集める仕組み（IssueCollector）は、作成時のチェックと規則の診断（diagnose）で共通。
  */
 /**
  * 既知のエラーコード（増えることがある）。
@@ -61,18 +62,28 @@ export type IssueSeverity = "error" | "warning" | "info";
 export interface Issue {
     readonly severity: IssueSeverity;
     readonly code: string;
-    /** 設定の中の位置（例: "dates[1].from"） */
+    /** 設定の中の位置（例: "dates[1].from"）。設定全体なら "" */
     readonly path: string;
     readonly message: string;
+    /** 関係する別の位置（例: 覆っている先の規則） */
+    readonly relatedPath?: string;
+    /** unknown-option の知らないキーと既知のキー（診断で候補を挙げるため。結果には出さない） */
+    readonly unknownKey?: string;
+    readonly knownKeys?: readonly string[];
 }
 /** @internal 問題を集める */
 export declare class IssueCollector {
     readonly issues: Issue[];
     error(code: KnownErrorCode, path: string, message: string): void;
-    warning(code: string, path: string, message: string): void;
+    warning(code: string, path: string, message: string, relatedPath?: string): void;
+    info(code: string, path: string, message: string, relatedPath?: string): void;
+    private add;
     get hasErrors(): boolean;
     /** 最初の誤りを例外にして投げる（誤りがなければ何もしない） */
     throwFirstError(): void;
 }
-/** @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する */
+/**
+ * @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する。
+ * 近い既知のキーを候補に挙げるのは規則の診断で行う（作成時は警告を使わないので、ここでは既知のキーを渡すだけ）
+ */
 export declare function checkUnknownKeys(collector: IssueCollector, path: string, value: object, known: readonly string[]): void;

package/dist/core/errors.js

@@ -3,6 +3,7 @@
  *
  * 例外は従来どおり RangeError・TypeError・Error のインスタンスで、code プロパティを持つ。
  * 例外のメッセージの文言は API に含まない（変わることがある）。判定には code を使う。
+ * 問題を集める仕組み（IssueCollector）は、作成時のチェックと規則の診断（diagnose）で共通。
  */
 /**
  * このライブラリが投げた例外（code 付き）か。
@@ -36,8 +37,16 @@ export class IssueCollector {
     error(code, path, message) {
         this.issues.push({ severity: "error", code, path, message });
     }
-    warning(code, path, message) {
-        this.issues.push({ severity: "warning", code, path, message });
+    warning(code, path, message, relatedPath) {
+        this.add("warning", code, path, message, relatedPath);
+    }
+    info(code, path, message, relatedPath) {
+        this.add("info", code, path, message, relatedPath);
+    }
+    add(severity, code, path, message, relatedPath) {
+        this.issues.push(relatedPath === undefined
+            ? { severity, code, path, message }
+            : { severity, code, path, message, relatedPath });
     }
     get hasErrors() {
         return this.issues.some((i) => i.severity === "error");
@@ -51,11 +60,21 @@ export class IssueCollector {
         throw rangeError(first.code, message);
     }
 }
-/** @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する */
+/**
+ * @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する。
+ * 近い既知のキーを候補に挙げるのは規則の診断で行う（作成時は警告を使わないので、ここでは既知のキーを渡すだけ）
+ */
 export function checkUnknownKeys(collector, path, value, known) {
     for (const key of Object.keys(value)) {
         if (!known.includes(key)) {
-            collector.warning("unknown-option", path ? `${path}.${key}` : key, `Unknown option ${JSON.stringify(key)} is ignored`);
+            collector.issues.push({
+                severity: "warning",
+                code: "unknown-option",
+                path: path ? `${path}.${key}` : key,
+                message: `Unknown option ${JSON.stringify(key)} is ignored`,
+                unknownKey: key,
+                knownKeys: known,
+            });
         }
     }
 }

package/dist/core/schedule.d.ts

@@ -33,12 +33,6 @@ export type HolidayValueRule<T> =
  | {
     readonly value: T;
 };
-/**
- * HolidayValueRule の旧名。繰り返しの規則の onHolidayRule と紛れないよう改名した。
- * @deprecated HolidayValueRule を使うこと。次以降のマイナー版で削除する
- * @public
- */
-export type HolidayRule<T> = HolidayValueRule<T>;
 /**
  * 月の第 n 回目（1〜5）。-1 は最終（その月の最後のその曜日）。
  * @public
@@ -254,6 +248,8 @@ export declare function isValidMonthDay(value: unknown): value is string;
 export declare const isWeekday: (value: unknown) => value is Weekday;
 /** @internal 個別の日付の規則（日数で表した期間） */
 export interface DateRule<T> {
+    /** 設定の中の位置（例: "closedDates[1]"） */
+    readonly path: string;
     readonly from: number;
     readonly to: number;
     readonly value: T;
@@ -261,6 +257,8 @@ export interface DateRule<T> {
 }
 /** @internal 毎年の月日の規則 */
 export interface AnnualRule<T> {
+    /** 設定の中の位置（例: "closedAnnual[0]"） */
+    readonly path: string;
     readonly from: string;
     readonly to: string;
     readonly value: T;
@@ -275,6 +273,8 @@ export declare function compileDateRules<T>(c: IssueCollector, path: string, ent
 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> {
+    /** 設定の中の位置（例: "closedRecurring[0]"） */
+    readonly path: string;
     /** 曜日の規則なら曜日、日の規則なら null */
     readonly weekday: Weekday | null;
     /** 第 n 回目の集合（null は毎週） */
@@ -316,6 +316,21 @@ export interface CompiledSchedule<T, Kind extends 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 値を決めた規則（祝日・曜日で決まった場合は null） */
+export type DecidingRule<T> = DateRule<T> | AnnualRule<T> | RecurringRuleCompiled<T>;
+/** @internal 1 日分の結果と、値を決めた規則 */
+export interface Resolution<T, Kind extends string> {
+    readonly day: ScheduleDay<T, Kind>;
+    readonly rule: DecidingRule<T> | null;
+}
+type HolidayLookupInternal<Kind extends string> = ReturnType<typeof createHolidayLookup<Kind>>;
+/**
+ * @internal 検証済みの規則から、1 日分の値と値を決めた規則を返す関数を作る。
+ * 規則の診断では、規則を取り除いた版と結果を比べるために、祝日を調べる機能（lookup）を共有して作る
+ */
+export declare function createResolver<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>, lookup: HolidayLookupInternal<Kind>): (date: DateString) => Resolution<T, Kind>;
 /** @internal 検証済みの規則からスケジュールを作る */
 export declare function buildSchedule<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>): Schedule<T, Kind>;
 /**
@@ -326,3 +341,4 @@ export declare function buildSchedule<T, Kind extends string>(compiled: Compiled
  * @public
  */
 export declare function createSchedule<T, Kind extends string = string>(options: ScheduleOptions<T, Kind>): Schedule<T, Kind>;
+export {};

package/dist/core/schedule.js

@@ -84,7 +84,7 @@ export function compileDateRules(c, path, entries, valueOf, allowString) {
             checkUnknownKeys(c, p, entry, ["date", "name", "value"]);
             const n = checkDate(c, `${p}.date`, entry["date"]);
             if (n !== undefined && value !== undefined)
-                rules.push({ from: n, to: n, value, name });
+                rules.push({ path: p, from: n, to: n, value, name });
             return;
         }
         if (!("from" in entry) || !("to" in entry)) {
@@ -101,7 +101,7 @@ export function compileDateRules(c, path, entries, valueOf, allowString) {
             return;
         }
         if (value !== undefined)
-            rules.push({ from, to, value, name });
+            rules.push({ path: p, from, to, value, name });
     });
     return rules;
 }
@@ -126,8 +126,9 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
         if ("date" in entry) {
             checkUnknownKeys(c, p, entry, ["date", "name", "value"]);
             const md = checkMonthDay(c, `${p}.date`, entry["date"]);
-            if (md !== undefined && value !== undefined)
-                rules.push({ from: md, to: md, value, name });
+            if (md !== undefined && value !== undefined) {
+                rules.push({ path: p, from: md, to: md, value, name });
+            }
             return;
         }
         if (!("from" in entry) || !("to" in entry)) {
@@ -138,7 +139,7 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
         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({ from, to, value, name });
+            rules.push({ path: p, from, to, value, name });
         }
     });
     return rules;
@@ -235,6 +236,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         }
         if (ok && value !== undefined) {
             rules.push(Object.freeze({
+                path: p,
                 weekday,
                 nth,
                 days,
@@ -487,15 +489,18 @@ export function compileScheduleOptions(c, options) {
 }
 /** 振替元をさかのぼる最大日数（祝日が続く日数の上限。2019 年の大型連休でも 10 日） */
 const MAX_HOLIDAY_RUN = 31;
-function matchAnnual(rule, monthDay) {
+/** @internal 毎年の月日の規則がその月日 "MM-DD" に当てはまるか */
+export function matchAnnual(rule, monthDay) {
     return rule.from <= rule.to
         ? monthDay >= rule.from && monthDay <= rule.to
         : monthDay >= rule.from || monthDay <= rule.to;
 }
-/** @internal 検証済みの規則からスケジュールを作る */
-export function buildSchedule(compiled) {
+/**
+ * @internal 検証済みの規則から、1 日分の値と値を決めた規則を返す関数を作る。
+ * 規則の診断では、規則を取り除いた版と結果を比べるために、祝日を調べる機能（lookup）を共有して作る
+ */
+export function createResolver(compiled, lookup) {
     const { weekly, holiday: holidayRule, annual, dates, recurring } = compiled;
-    const lookup = createHolidayLookup(compiled.source);
     const hasShift = recurring.some((r) => r.onHolidayRule === "after-holiday");
     /** 振替の判断に使う「祝日」か。提供元の対応年の外は祝日でないとみなす（振替元をさかのぼる途中で範囲を出る場合のため） */
     function isHolidaySafe(date) {
@@ -520,11 +525,11 @@ export function buildSchedule(compiled) {
         }
         return undefined;
     }
-    function info(date) {
+    return function resolve(date) {
         const dayNumber = toDayNumber(date);
         const weekday = weekdayOf(date);
         const holiday = lookup.holidayOn(date);
-        const make = (value, reason, name, shiftedFrom) => {
+        const make = (value, reason, rule, name, shiftedFrom) => {
             const result = {
                 date,
                 weekday,
@@ -537,46 +542,52 @@ export function buildSchedule(compiled) {
                 result.holiday = holiday;
             if (shiftedFrom !== undefined)
                 result.shiftedFrom = shiftedFrom;
-            return Object.freeze(result);
+            return { day: Object.freeze(result), rule };
         };
         // 1. 個別の日付  2. 毎年の月日
         const byDate = dates.find((r) => dayNumber >= r.from && dayNumber <= r.to);
         if (byDate)
-            return make(byDate.value, "date", byDate.name);
+            return make(byDate.value, "date", byDate, byDate.name);
         const monthDay = date.slice(5);
         const byAnnual = annual.find((r) => matchAnnual(r, monthDay));
         if (byAnnual)
-            return make(byAnnual.value, "annual", byAnnual.name);
+            return make(byAnnual.value, "annual", byAnnual, byAnnual.name);
         if (holiday) {
             // 3. 祝日の上（"over-holiday"）
             const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date));
             if (over)
-                return make(over.value, "recurring", over.name);
+                return make(over.value, "recurring", over, over.name);
             // 4. 祝日
             if (holidayRule !== "weekday") {
                 const value = "sameAs" in holidayRule ? weekly[holidayRule.sameAs] : holidayRule.value;
-                return make(value, "holiday", holiday.name);
+                return make(value, "holiday", null, holiday.name);
             }
             // 祝日の扱いが「曜日どおり」なら、祝日の下（"under-holiday"）の規則も当てはまる。
             // "after-holiday" の規則は祝日には当てはめない（振り替える）
             const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date));
             if (under)
-                return make(under.value, "recurring", under.name);
-            return make(weekly[weekday], "weekday", undefined);
+                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))
-                return make(rule.value, "recurring", rule.name);
+                return make(rule.value, "recurring", rule, rule.name);
             if (hasShift && rule.onHolidayRule === "after-holiday") {
                 const origin = shiftedOrigin(rule, date);
                 if (origin !== undefined)
-                    return make(rule.value, "recurring", rule.name, origin);
+                    return make(rule.value, "recurring", rule, rule.name, origin);
             }
         }
         // 6. 曜日
-        return make(weekly[weekday], "weekday", undefined);
-    }
+        return make(weekly[weekday], "weekday", null, undefined);
+    };
+}
+/** @internal 検証済みの規則からスケジュールを作る */
+export function buildSchedule(compiled) {
+    const lookup = createHolidayLookup(compiled.source);
+    const resolve = createResolver(compiled, lookup);
+    const info = (date) => resolve(date).day;
     const schedule = {
         timeZone: lookup.timeZone,
         providers: lookup.providers,

package/dist/diagnose/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 規則の診断（bizdays-toolkit/diagnose）。
+ *
+ * 営業日カレンダー・スケジュールの設定を調べ、誤り・使われない規則・打ち間違いなどを返す。
+ * 開発やテストで使う道具なので、アプリの本体のバンドルに入らないようサブパスに分けている。
+ */
+export { diagnoseCalendar, diagnoseSchedule, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type KnownDiagnosticCode, } from "../core/diagnose.ts";

package/dist/diagnose/index.js

@@ -0,0 +1,7 @@
+/**
+ * 規則の診断（bizdays-toolkit/diagnose）。
+ *
+ * 営業日カレンダー・スケジュールの設定を調べ、誤り・使われない規則・打ち間違いなどを返す。
+ * 開発やテストで使う道具なので、アプリの本体のバンドルに入らないようサブパスに分けている。
+ */
+export { diagnoseCalendar, diagnoseSchedule, } from "../core/diagnose.js";

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
 export { createCalendar, type AnnualDate, type AnnualRange, type BusinessDayOptions, type Calendar, type CalendarOptions, type DateRange, type DayInfo, type DayReason, 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 HolidayRule, 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 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 { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";
 export { toDateString, toDateTimeParts, type DateInput, type TemporalDateLike, type TemporalInstantLike, } from "./core/input.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.4.0",
+  "version": "0.5.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. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府データで全日照合）",
   "keywords": [
     "bizdays",
@@ -40,6 +40,10 @@
       "types": "./dist/jp/index.d.ts",
       "default": "./dist/jp/index.js"
     },
+    "./diagnose": {
+      "types": "./dist/diagnose/index.d.ts",
+      "default": "./dist/diagnose/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {