bizdays-toolkit 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -4,6 +4,49 @@
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-10-20
+
+### 移行
+
+動作は変わりません（締め期間と、暦日と時刻から瞬間への変換の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 締め日で区切ったときのその月分の期間を返す `closingPeriod(monthOrDate, closingDay)` を追加した（`closingMonth` の逆算。前月の締め日の翌日からその月の締め日まで、両端を含む `{ from, to }`）。暦日を渡すとその日が属する期間。返す値は変更できず、日付の期間の形なので `closedDates` や `listBusinessDays` にそのまま渡せる。締め日がその月にない場合の読み替え（末日）は `closingMonth` と同じ内部関数で行い、期間が隙間も重なりもなく敷き詰められることをテストで確かめた
+- 暦日と時刻（`"HH:mm"` または `"HH:mm:ss"`）からタイムゾーンでの瞬間を `Date` で返す `toInstant(date, time, timeZone)` と、営業日カレンダー・スケジュールのメソッド `instantOf(date, time)`（そのタイムゾーンで。合成したカレンダー・スケジュールからのカレンダーにも付く）を追加した。`civilOf`・`toDateTimeParts` の逆向き。夏時間で存在しない時刻は飛んだ分だけ後ろに、2 回ある時刻は先のほう（Temporal の `disambiguation: "compatible"` と同じ）。`Intl` だけで実装し、オフセットの差が 1 時間でないゾーン（`Australia/Lord_Howe`）と南半球（`Pacific/Auckland`）でも確かめた。受け付けるのは暦日の文字列だけ（`invalid-date`）。時刻の誤りは `invalid-time`
+
+### Changed
+
+- README: 月のヘルパーの節に `closingPeriod` を、日付・日時の入力の節に `toInstant`・`instantOf` と夏時間の例を足した。サイズの値を測り直した（ルート約 9.3KB・日本の祝日込み約 11.1KB・英国の祝日込み約 11.1KB。0.14.0 で測定）
+- `docs/decisions.md`: 39 番（`closingPeriod`）・40 番（`toInstant`）を追加した
+- `src/core/schedule.ts` の `buildSchedule` の注釈の位置を直した（0.13.0 で関数の間に別の定義が入り、注釈が離れていた。動作は変わらない）
+
+### 開発
+
+- サイズの上限（`size-limits.json`）を上げた。ルート 20,500 → 22,000、`./jp` 23,500 → 25,000、`./diagnose` 27,000 → 28,500（gzip）。`closingPeriod` と瞬間への変換（ルートで約 1.3KB）のため。0.13.0 で上限に近づいていた分も含めて余裕を持たせた
+
+## [0.13.0] - 2026-10-20
+
+### 移行
+
+動作は変わりません（スケジュールから営業日カレンダーを作る関数と、判定の理由の新しい値の追加。CI の改善）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- スケジュールから営業日カレンダーを作る `createCalendarFromSchedule(schedule, isOpen, { maxSearchDays? })` を追加した。`isOpen` が true を返す値の日を営業日とする通常のカレンダーを返し、営業時間表のようなスケジュールが唯一の設定になる。`isOpen` は値だけを受け取る純粋な関数（日付は渡さない。営業日の探索で繰り返し呼ぶため）。`dayInfo` の `reason` はスケジュールの `reason` と営業・休業の組み合わせで、`name`・`holiday`・`shiftedFrom`・`rulePath` はスケジュールの結果を引き継ぐ。祝日・タイムゾーン・`outOfRange` はスケジュールのもの。`createSchedule` が作ったスケジュール以外は `invalid-argument`
+- 判定の理由（`DayReason`）に `"open-annual"`（スケジュールの `annual` の値で営業になる日）を追加した。`createCalendar` の結果には現れない（`closedAnnual` は休業だけ）
+
+### Changed
+
+- README: 「スケジュールから営業日カレンダーを作る」の節を足した。型定義の確認の範囲を、CI で確かめる TypeScript の版（5.0・5.5・5.8・6.0・7.0）に改めた。サイズの値を測り直した（ルート約 9.0KB・日本の祝日込み約 10.8KB・英国の祝日込み約 10.7KB。0.13.0 で測定）
+- `docs/decisions.md`: 38 番（スケジュールからのカレンダー・`"open-annual"`・利用者の TypeScript の版の確認）を追加した
+
+### 開発
+
+- CI に `consumer-types` ジョブを追加した。公開する型定義を、利用者が使う TypeScript 5.0.4・5.5.4・5.8.3・7.0.2（ネイティブ版）のそれぞれで、`moduleResolution` の `node16`・`nodenext`・`bundler` で型チェックする。各版は依存にせず、版と SHA-256 を固定した tgz から一時ディレクトリに入れる（7.0 はランナー向けの実行形式 `@typescript/typescript-linux-x64` も固定）。`pnpm check` は従来どおり開発用の 6.0.3 で確かめる
+- `scripts/check-consumer-types.ts` に `--tsc <path>` を足し、わざと型エラーを含む `test/consumer/consumer-error.mts` が各版で失敗として報告されること（検査が機能していること）も確かめるようにした。リポジトリの `@types` を読まないよう `--typeRoots` を空にした（古い TypeScript では `@types/node` の新しい構文を読めないため）。`--ignoreConfig` は 6.0 以降でだけ渡す
+- `createCalendar` の `dayInfo` の変換を `createCalendarFromSchedule` と共用の内部関数に切り出した。結果は変わらない
+
 ## [0.12.0] - 2026-10-20
 
 ### 移行
@@ -330,7 +373,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...v0.14.0
+[0.13.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.1...v0.12.0
 [0.11.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.0...v0.11.1
 [0.11.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.10.0...v0.11.0

package/README.md

@@ -25,9 +25,10 @@ A business-day calendar that combines public holidays with company or store clos
 - **Option diagnostics**: `diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` list rules that can never apply, rules whose removal changes nothing, typos in option keys, calendars with no business day and more, without throwing. One line in your tests keeps a change of settings from silently killing a rule
 - **Month-based due dates**: due dates such as "closing on the 20th, paid on the 10th of the next month (next business day if closed)" or "the last business day of the month", with the four adjustment conventions used in finance (following, preceding, modified-following, modified-preceding)
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
+- **A calendar from a schedule**: `createCalendarFromSchedule` turns a schedule such as store hours into a business-day calendar, so the hours are the only configuration and business-day arithmetic works on them
 - **Combining calendars**: `combineCalendars` builds a calendar of the days on which all of several calendars are open (your company and the bank, for a remittance date) or any of them is open (any of several stores), and business-day arithmetic works on the result
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 8.8 KB min+gzip (about 10.6 KB with Japanese holidays, about 10.5 KB with UK bank holidays; measured for 0.12.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
+- **Lightweight, zero dependencies**: about 9.3 KB min+gzip (about 11.1 KB with Japanese holidays, about 11.1 KB with UK bank holidays; measured for 0.14.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -38,7 +39,7 @@ pnpm add bizdays-toolkit
 
 Node.js 22.12 or later. CI tests the package on Node.js 22.12, 22, 24 and 26, on Chrome, Firefox and Edge (Linux) and Safari (macOS), and on Cloudflare Workers (workerd, the open-source Workers runtime). The browsers are the latest stable versions on GitHub's runners, so their versions change as the runners are updated. The package is ESM only, but it can also be loaded from CommonJS with `require()` (tested in CI as well; on Node.js 22.12, `require()` prints an experimental-feature warning, which does not affect the result, and Node.js 26 prints none). Other runtimes (such as Deno, Bun or Vercel's Edge Runtime) are not tested.
 
-Types are bundled. CI type-checks a consumer project against the published type definitions with `moduleResolution` set to `node16`, `nodenext` and `bundler` (TypeScript 6); TypeScript 5.0, 5.5 and 5.8 were also checked by hand for 0.9.0.
+Types are bundled. CI type-checks a consumer project against the published type definitions with TypeScript 5.0, 5.5, 5.8, 6.0 and 7.0 (the native compiler), each with `moduleResolution` set to `node16`, `nodenext` and `bundler`, and confirms that an intentional type error is reported by each.
 
 ## Usage
 
@@ -396,6 +397,15 @@ calendar.dueDate(monthOf(billing, 1), { day: -1, convention: "preceding" }); //
 
 - `monthOf(dateOrMonth, offset?)`: the month `offset` months after (before, if negative) a date or a month `"YYYY-MM"`
 - `closingMonth(date, closingDay)`: the month a date belongs to when months are closed on `closingDay` (1–31, `-1` for the last day). The day after a closing day up to the next closing day belongs to the month of the next closing day. If the closing day does not exist in a month (closing on the 31st in February), the last day is used
+- `closingPeriod(monthOrDate, closingDay)`: the inverse: the period `{ from, to }` (both ends included) that belongs to the month, from the day after the previous closing day to the closing day. Given a date, the period that date belongs to. The result has the shape of a date range, so it can go straight into `closedDates` or `listBusinessDays`
+
+```ts
+closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" } (closing on the 31st in February means the 28th)
+const { from, to } = closingPeriod("2026-11-05", 20); // the period "2026-11-05" belongs to
+const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
+office.listBusinessDays(from, to).length; // 22 (business days in the November period)
+```
 
 The `day` of `dueDate` also maps days that do not exist in a month (such as February 30) to the last day. Recurring rules (`{ day: 31 }`) do not match such days, so the two behave differently: a due date must always fall somewhere in its month.
 
@@ -450,6 +460,33 @@ const isOpen = hours !== null && hours.open <= time && time < hours.close;
 
 For inputs that always carry a time (a `Date`, Temporal `Instant`, `ZonedDateTime` or `PlainDateTime`, or a `"YYYY-MM-DDTHH:mm"` string), `time` is typed as `string`, so no `null` check is needed. `civilOf` is also on business-day calendars, and the same conversion is available as `toDateTimeParts(input, timeZone)` in the root. (`toJapanDate` and `toJapanDateTime` in `bizdays-toolkit/jp` are deprecated since 0.10.0: use `toDateString(input, "Asia/Tokyo")`, `toDateTimeParts(input, "Asia/Tokyo")` or `dateOf`/`civilOf` on a calendar instead. They will be removed in 1.0.0.)
 
+### A business-day calendar from a schedule
+
+When the schedule (store hours, say) is the real configuration, `createCalendarFromSchedule(schedule, isOpen)` makes a business-day calendar from it, so you do not write a second set of rules to keep in sync. `isOpen` decides from the value alone whether the day is a business day; the result is an ordinary calendar with business-day arithmetic, `adjust`, `dueDate` and the rest.
+
+```ts
+import { createCalendarFromSchedule } from "bizdays-toolkit";
+
+const hours = createSchedule<Hours>({
+  holidays: jp,
+  weekly: [null, weekday, weekday, weekday, weekday, weekday, { open: "10:00", close: "17:00" }],
+  holiday: { sameAs: 0 },
+  annual: [
+    { from: "12-31", to: "01-03", value: null, name: "New Year closure" },
+    { date: "01-04", value: { open: "11:00", close: "15:00" }, name: "First day of the year" },
+  ],
+});
+const calendar = createCalendarFromSchedule(hours, (v) => v !== null);
+calendar.addBusinessDays("2026-12-29", 2); // "2027-01-04"
+calendar.dayInfo("2027-01-04");
+// { date: "2027-01-04", weekday: 1, businessDay: true, reason: "open-annual", name: "First day of the year", rulePath: "annual[1]" }
+```
+
+- `isOpen` must be a pure function of the value: it receives only the value (not the date), and the calendar calls it repeatedly while searching for business days, so a function that looks at the date, the time or outside state would make the result change from call to call. Conditions that depend on the date belong in the schedule's rules (`dates`, `recurring`)
+- `dayInfo` maps the schedule's `reason` to the calendar's: `date` → `"open-date"`/`"closed-date"`, `annual` → `"open-annual"`/`"closed-annual"`, `recurring` → `"open-recurring"`/`"closed-recurring"`, `holiday` → `"holiday"` (whether or not the holiday is open, as with `holidayPolicy: "open"`), `weekday` → `"regular"`/`"closed-weekday"`. `"open-annual"` exists only for calendars made this way, since `closedAnnual` of `createCalendar` only closes. `name`, `holiday`, `shiftedFrom` and `rulePath` are the schedule's
+- Holidays, the time zone and `outOfRange` are the schedule's. Diagnose the schedule's options with `diagnoseSchedule`; the calendar itself is not diagnosed. `maxSearchDays` (default 3660) can be given in the options
+- Use `createCalendar` when you only need open or closed; use this when you have a schedule anyway
+
 ### Date and date-time inputs
 
 Every method accepts the following inputs. Returned dates are always `"YYYY-MM-DD"` strings.
@@ -467,6 +504,26 @@ Temporal objects are recognized by their shape, so the package does not depend o
 
 The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
+**From a civil date and time to an instant**: `toInstant(date, time, timeZone)` and `calendar.instantOf(date, time)` (also on schedules) go the other way from `civilOf`: a civil date `"YYYY-MM-DD"` and a time `"HH:mm"` or `"HH:mm:ss"` become a `Date` for that instant in the time zone. Only a date string is accepted (a `Date` would be ambiguous about which day it means), and the result is a `Date`, which is one line from an ISO string (`.toISOString()`) or a Temporal `Instant` (`Temporal.Instant.fromEpochMilliseconds(d.getTime())`).
+
+```ts
+import { toInstant } from "bizdays-toolkit";
+
+toInstant("2026-11-23", "10:00", "Asia/Tokyo").toISOString(); // "2026-11-23T01:00:00.000Z"
+const store = createCalendar({ holidays: jp, closedWeekdays: [0] });
+const opensAt = store.instantOf(store.nextBusinessDay(store.today()), "10:00"); // the next opening, as a Date
+```
+
+Around daylight-saving changes the result follows Temporal's default (`disambiguation: "compatible"`): a time that does not exist (in the UK, 01:00–01:59 on the last Sunday of March) is moved forward by the length of the gap, and a time that occurs twice (01:00–01:59 on the last Sunday of October) is the earlier one.
+
+```ts
+import { england } from "bizdays-toolkit/uk";
+
+const uk = createCalendar({ holidays: england });
+uk.instantOf("2026-03-29", "01:30").toISOString(); // "2026-03-29T01:30:00.000Z" (02:30 BST; 01:30 does not exist)
+uk.instantOf("2026-10-25", "01:30").toISOString(); // "2026-10-25T00:30:00.000Z" (the first 01:30, still BST)
+```
+
 ### Holidays of other countries and regions
 
 Implement `HolidayProvider` and pass it as `holidays`. Several providers give their union (if their time zones differ, `timeZone` is required).

package/dist/core/calendar.d.ts

@@ -22,7 +22,7 @@ import { type DateString, type Weekday } from "./date.ts";
 import { IssueCollector } from "./errors.ts";
 import { type DateInput } from "./input.ts";
 import { type MonthString } from "./month.ts";
-import { type CompiledSchedule, type DayOfMonth, type EffectivePeriod, type RecurringRule, type HolidayLookup, type HolidaySourceOptions } from "./schedule.ts";
+import { type CompiledSchedule, type DayOfMonth, type EffectivePeriod, type RecurringRule, type HolidayLookup, type HolidaySourceOptions, type Schedule } from "./schedule.ts";
 import type { Holiday } from "./types.ts";
 /**
  * 祝日の扱い。
@@ -93,7 +93,7 @@ export interface CalendarOptions<Kind extends string = string> extends HolidaySo
  * 営業・休業を決めた規則（既知の値）。
  * @public
  */
-export type KnownDayReason = "open-date" | "closed-date" | "closed-annual" | "open-recurring" | "closed-recurring" | "holiday" | "closed-weekday" | "regular";
+export type KnownDayReason = "open-date" | "closed-date" | "open-annual" | "closed-annual" | "open-recurring" | "closed-recurring" | "holiday" | "closed-weekday" | "regular";
 /**
  * 営業・休業を決めた規則。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
  * すべての値を網羅したことを型で確かめたい場合は KnownDayReason を使う。
@@ -255,4 +255,21 @@ export declare function createCalendar<Kind extends string = string>(options?: C
  * @public
  */
 export declare function combineCalendars<Kind extends string = string>(calendars: readonly Calendar<Kind>[], options: CombineOptions): Calendar<Kind>;
+/**
+ * スケジュール（createSchedule）から営業日カレンダーを作る。isOpen が true を返す値の日を営業日とする。
+ * 営業時間表のような日ごとの値が設定の正本で、営業日の計算（加減算・調整・期日など）も同じ設定から行いたいときに使う
+ * （営業日カレンダーを別に書いて同期を取る必要がなくなる）。
+ *
+ * - isOpen は値だけで決まる純粋な関数であること（日付・時刻・外部の状態を見ない）。営業日の探索は isOpen を繰り返し呼ぶので、
+ *   結果が変わる関数を渡すと探索の結果が呼ぶたびに変わる。日付で変えたい条件は、スケジュールの規則（dates・recurring）に書く
+ * - dayInfo の reason は、スケジュールの reason と営業・休業の組み合わせ（date → "open-date"/"closed-date"、annual → "open-annual"/
+ *   "closed-annual"、recurring → "open-recurring"/"closed-recurring"、holiday → "holiday"、weekday → "regular"/"closed-weekday"）。
+ *   name・holiday・shiftedFrom・rulePath はスケジュールの結果をそのまま引き継ぐ
+ * - 祝日の判定（holiday・isHoliday など）・タイムゾーン・outOfRange はスケジュールのもの。規則の診断（diagnoseSchedule）は
+ *   スケジュールの設定に対して行う
+ * @public
+ */
+export declare function createCalendarFromSchedule<T, Kind extends string = string>(schedule: Schedule<T, Kind>, isOpen: (value: T) => boolean, options?: {
+    readonly maxSearchDays?: number;
+}): Calendar<Kind>;
 export {};

package/dist/core/calendar.js

@@ -22,7 +22,7 @@ import { addDays, daysInMonth, formatDate, fromDayNumber, toDayNumber, } from ".
 import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
 import { parseTimeOfDay, toCivil } from "./input.js";
 import { dayOfMonth, isDayOfMonthValue, parseMonth } from "./month.js";
-import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
+import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, infoOfSchedule, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
     "timeZone",
@@ -100,54 +100,62 @@ export function createCalendar(options = {}) {
     c.throwFirstError();
     const { maxSearchDays } = compiled;
     const schedule = buildSchedule(compiled.schedule);
-    function info(date) {
+    const info = (date) => {
         const day = schedule.dayInfo(date);
-        let reason;
-        // 内部では閉じた型（KnownScheduleReason）で分岐し、値が増えたときの対応漏れを型で検出する
-        const known = day.reason;
-        switch (known) {
-            case "date":
-                reason = day.value ? "open-date" : "closed-date";
-                break;
-            case "annual":
-                reason = "closed-annual";
-                break;
-            case "recurring":
-                reason = day.value ? "open-recurring" : "closed-recurring";
-                break;
-            case "holiday":
-                reason = "holiday";
-                break;
-            case "weekday":
-                reason = day.value ? "regular" : "closed-weekday";
-                break;
-            default: {
-                const unreachable = known;
-                throw plainError("invalid-option", `Unexpected schedule reason: ${String(unreachable)}`);
-            }
+        return dayInfoFromScheduleDay(day, day.value);
+    };
+    return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
+}
+/**
+ * @internal スケジュールの 1 日分の結果（値は営業日か）を、営業日カレンダーの結果に変換する。
+ * reason はスケジュールの reason と営業・休業の組み合わせで決まる。createCalendar の closedAnnual は休業だけなので
+ * "open-annual" にはならないが、createCalendarFromSchedule では annual の値で営業になる日がある
+ */
+function dayInfoFromScheduleDay(day, open) {
+    let reason;
+    // 内部では閉じた型（KnownScheduleReason）で分岐し、値が増えたときの対応漏れを型で検出する
+    const known = day.reason;
+    switch (known) {
+        case "date":
+            reason = open ? "open-date" : "closed-date";
+            break;
+        case "annual":
+            reason = open ? "open-annual" : "closed-annual";
+            break;
+        case "recurring":
+            reason = open ? "open-recurring" : "closed-recurring";
+            break;
+        case "holiday":
+            reason = "holiday";
+            break;
+        case "weekday":
+            reason = open ? "regular" : "closed-weekday";
+            break;
+        default: {
+            const unreachable = known;
+            throw plainError("invalid-option", `Unexpected schedule reason: ${String(unreachable)}`);
         }
-        const result = {
-            date: day.date,
-            weekday: day.weekday,
-            businessDay: day.value,
-            reason,
-        };
-        // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
-        if (day.name !== undefined && day.reason !== "weekday")
-            result.name = day.name;
-        if (day.holiday !== undefined)
-            result.holiday = day.holiday;
-        if (day.shiftedFrom !== undefined)
-            result.shiftedFrom = day.shiftedFrom;
-        if (day.rulePath !== undefined)
-            result.rulePath = day.rulePath;
-        return Object.freeze(result);
     }
-    return buildCalendar(schedule, (date) => schedule.valueOn(date), info, maxSearchDays);
+    const result = {
+        date: day.date,
+        weekday: day.weekday,
+        businessDay: open,
+        reason,
+    };
+    // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
+    if (day.name !== undefined && day.reason !== "weekday")
+        result.name = day.name;
+    if (day.holiday !== undefined)
+        result.holiday = day.holiday;
+    if (day.shiftedFrom !== undefined)
+        result.shiftedFrom = day.shiftedFrom;
+    if (day.rulePath !== undefined)
+        result.rulePath = day.rulePath;
+    return Object.freeze(result);
 }
 /**
  * @internal 祝日を調べる機能と 1 日分の判定から、営業日カレンダーの機能（探索・調整・月の営業日・期日）を組み立てる。
- * createCalendar と combineCalendars で共用する
+ * createCalendar・combineCalendars・createCalendarFromSchedule で共用する
  */
 function buildCalendar(lookup, isOpen, info, maxSearchDays) {
     const dateOf = lookup.dateOf;
@@ -241,6 +249,7 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         outOfRange: lookup.outOfRange,
         dateOf,
         civilOf: lookup.civilOf,
+        instantOf: lookup.instantOf,
         today: lookup.today,
         isHoliday: lookup.isHoliday,
         getHoliday: lookup.getHoliday,
@@ -386,3 +395,36 @@ export function combineCalendars(calendars, options) {
     }
     return buildCalendar(lookup, isOpen, info, maxSearchDays);
 }
+/**
+ * スケジュール（createSchedule）から営業日カレンダーを作る。isOpen が true を返す値の日を営業日とする。
+ * 営業時間表のような日ごとの値が設定の正本で、営業日の計算（加減算・調整・期日など）も同じ設定から行いたいときに使う
+ * （営業日カレンダーを別に書いて同期を取る必要がなくなる）。
+ *
+ * - isOpen は値だけで決まる純粋な関数であること（日付・時刻・外部の状態を見ない）。営業日の探索は isOpen を繰り返し呼ぶので、
+ *   結果が変わる関数を渡すと探索の結果が呼ぶたびに変わる。日付で変えたい条件は、スケジュールの規則（dates・recurring）に書く
+ * - dayInfo の reason は、スケジュールの reason と営業・休業の組み合わせ（date → "open-date"/"closed-date"、annual → "open-annual"/
+ *   "closed-annual"、recurring → "open-recurring"/"closed-recurring"、holiday → "holiday"、weekday → "regular"/"closed-weekday"）。
+ *   name・holiday・shiftedFrom・rulePath はスケジュールの結果をそのまま引き継ぐ
+ * - 祝日の判定（holiday・isHoliday など）・タイムゾーン・outOfRange はスケジュールのもの。規則の診断（diagnoseSchedule）は
+ *   スケジュールの設定に対して行う
+ * @public
+ */
+export function createCalendarFromSchedule(schedule, isOpen, options) {
+    const info = infoOfSchedule(schedule);
+    if (info === undefined) {
+        throw rangeError("invalid-argument", "schedule must be a schedule created by createSchedule");
+    }
+    if (typeof isOpen !== "function") {
+        throw rangeError("invalid-argument", "isOpen must be a function (value) => boolean");
+    }
+    const maxSearchDays = options?.maxSearchDays ?? 3660;
+    if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
+        throw rangeError("invalid-option", "maxSearchDays must be a positive integer");
+    }
+    const open = (date) => isOpen(info(date).value) === true;
+    return buildCalendar(schedule, open, (date) => {
+        const day = info(date);
+        // 変換は value を読まない（営業・休業は open で渡す）ので、boolean の値として扱ってよい
+        return dayInfoFromScheduleDay(day, isOpen(day.value) === true);
+    }, maxSearchDays);
+}

package/dist/core/input.d.ts

@@ -82,5 +82,21 @@ export declare function toDateString(input: DateInput, timeZone: string): DateSt
 export declare function toDateTimeParts(input: DateTimeInput, timeZone: string): CivilDateTimeParts<string>;
 /** @public */
 export declare function toDateTimeParts(input: DateInput, timeZone: string): CivilDateTimeParts;
+/**
+ * @internal 暦日と時刻（0 時からの経過分）から、タイムゾーンでの瞬間（エポックミリ秒）を求める。
+ * 夏時間の扱いは Temporal の disambiguation: "compatible" と同じ。存在しない時刻（飛び）は切り替え前のオフセットで解釈して
+ * 飛んだ分だけ後ろの瞬間に、2 回ある時刻（重複）は先のほう（切り替え前のオフセット）にする。
+ * Intl 以外に依存しないよう、前後 1 日のオフセットを候補にして、暦日に戻して一致するものを選ぶ
+ */
+export declare function civilToInstant(date: DateString, minutes: number, timeZone: string): number;
+/** @internal "HH:mm" または "HH:mm:ss" を 0 時からの経過秒に変換する（00:00:00〜23:59:59） */
+export declare function parseTimeOfDaySeconds(value: unknown): number;
+/**
+ * 暦日と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf・toDateTimeParts の逆向き）。
+ * 夏時間の切り替えで存在しない時刻は、飛んだ分だけ後ろの瞬間（英国の 3 月の 01:30 は 02:30 BST）、2 回ある時刻は先のほう
+ * （Temporal の disambiguation: "compatible" と同じ）。
+ * @public
+ */
+export declare function toInstant(date: DateString, time: string, timeZone: string): Date;
 /** @internal "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export declare function parseTimeOfDay(value: string): number;

package/dist/core/input.js

@@ -143,6 +143,56 @@ export function toDateTimeParts(input, timeZone) {
         : `${String(Math.floor(civil.minutes / 60)).padStart(2, "0")}:${String(civil.minutes % 60).padStart(2, "0")}`;
     return Object.freeze({ date: civil.date, time });
 }
+/**
+ * @internal 暦日と時刻（0 時からの経過分）から、タイムゾーンでの瞬間（エポックミリ秒）を求める。
+ * 夏時間の扱いは Temporal の disambiguation: "compatible" と同じ。存在しない時刻（飛び）は切り替え前のオフセットで解釈して
+ * 飛んだ分だけ後ろの瞬間に、2 回ある時刻（重複）は先のほう（切り替え前のオフセット）にする。
+ * Intl 以外に依存しないよう、前後 1 日のオフセットを候補にして、暦日に戻して一致するものを選ぶ
+ */
+export function civilToInstant(date, minutes, timeZone) {
+    const { year, month, day } = parseDate(date);
+    const wall = Date.UTC(year, month - 1, day, Math.floor(minutes / 60), minutes % 60);
+    const offsetAt = (ms) => {
+        const civil = instantToCivil(ms, timeZone);
+        const c = parseDate(civil.date);
+        const m = civil.minutes ?? 0; // 瞬間からの変換では時刻が必ずある
+        return Date.UTC(c.year, c.month - 1, c.day, Math.floor(m / 60), m % 60) - ms;
+    };
+    const before = offsetAt(wall - 86_400_000);
+    const after = offsetAt(wall + 86_400_000);
+    const valid = (ms) => {
+        const civil = instantToCivil(ms, timeZone);
+        return civil.date === date && civil.minutes === minutes;
+    };
+    const candidates = before === after ? [wall - before] : [wall - before, wall - after];
+    const found = candidates.filter(valid);
+    // 重複なら先のほう（小さいミリ秒）、飛びなら切り替え前のオフセット（before）で解釈した瞬間
+    return found.length > 0 ? Math.min(...found) : wall - before;
+}
+/** @internal "HH:mm" または "HH:mm:ss" を 0 時からの経過秒に変換する（00:00:00〜23:59:59） */
+export function parseTimeOfDaySeconds(value) {
+    const m = typeof value === "string" ? /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value) : null;
+    const seconds = m ? Number(m[3] ?? "0") : NaN;
+    if (!m || seconds > 59) {
+        throw rangeError("invalid-time", `Invalid time of day: ${JSON.stringify(value)} (expected HH:mm or HH:mm:ss)`);
+    }
+    return wallTime(Number(m[1]), Number(m[2])) * 60 + seconds;
+}
+/**
+ * 暦日と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf・toDateTimeParts の逆向き）。
+ * 夏時間の切り替えで存在しない時刻は、飛んだ分だけ後ろの瞬間（英国の 3 月の 01:30 は 02:30 BST）、2 回ある時刻は先のほう
+ * （Temporal の disambiguation: "compatible" と同じ）。
+ * @public
+ */
+export function toInstant(date, time, timeZone) {
+    const zone = validateTimeZone(timeZone);
+    if (typeof date !== "string")
+        throw typeError("invalid-date", `Invalid date: ${String(date)}`);
+    parseDate(date);
+    const seconds = parseTimeOfDaySeconds(time);
+    const ms = civilToInstant(date, Math.floor(seconds / 60), zone) + (seconds % 60) * 1000;
+    return new Date(ms);
+}
 /** @internal "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export function parseTimeOfDay(value) {
     const m = /^(\d{2}):(\d{2})$/.exec(value);

package/dist/core/month.d.ts

@@ -48,3 +48,20 @@ export declare function monthOf(input: DateString | MonthString, offset?: number
  * @public
  */
 export declare function closingMonth(date: DateString, closingDay: number): MonthString;
+/**
+ * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
+ *
+ * 前月の締め日の翌日から、その月の締め日まで。月の代わりに暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+ * 返す値は変更できず、name は付かない（DateRange の形なので、そのまま closedDates などに渡せる）。
+ *
+ * @example
+ * closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+ * closingPeriod("2026-10", -1); // { from: "2026-10-01", to: "2026-10-31" }（末日締め）
+ * closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" }（2 月の 31 日締めは 2 月末日）
+ * closingPeriod("2026-11-05", 20); // { from: "2026-10-21", to: "2026-11-20" }（この日が属する期間）
+ * @public
+ */
+export declare function closingPeriod(input: DateString | MonthString, closingDay: number): {
+    readonly from: DateString;
+    readonly to: DateString;
+};

package/dist/core/month.js

@@ -4,7 +4,7 @@
  * 営業日を考えない暦の計算なので、カレンダーなしで使える。営業日を考えた月の計算
  * （月の第 n 営業日・期日）は営業日カレンダーのメソッドにある。
  */
-import { daysInMonth, formatDate, parseDate } from "./date.js";
+import { addDays, daysInMonth, formatDate, parseDate } from "./date.js";
 import { rangeError } from "./errors.js";
 const MONTH_RE = /^(\d{4})-(\d{2})$/;
 /** @internal "YYYY-MM" を年と月に分解する（誤りは code: "invalid-month"） */
@@ -67,10 +67,40 @@ export function monthOf(input, offset = 0) {
  * @public
  */
 export function closingMonth(date, closingDay) {
+    checkClosingDay(closingDay);
+    const { year, month, day } = parseDate(date);
+    return formatMonth(shiftMonth({ year, month }, day <= closingDayIn({ year, month }, closingDay) ? 0 : 1));
+}
+function checkClosingDay(closingDay) {
     if (!isDayOfMonthValue(closingDay)) {
         throw rangeError("invalid-argument", `closingDay must be an integer from 1 to 31, or -1 (last day): ${closingDay}`);
     }
-    const { year, month, day } = parseDate(date);
-    const closing = closingDay === -1 ? daysInMonth(year, month) : closingDay;
-    return formatMonth(shiftMonth({ year, month }, day <= closing ? 0 : 1));
+}
+/** その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+function closingDayIn({ year, month }, closingDay) {
+    const last = daysInMonth(year, month);
+    return closingDay === -1 || closingDay > last ? last : closingDay;
+}
+/**
+ * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
+ *
+ * 前月の締め日の翌日から、その月の締め日まで。月の代わりに暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+ * 返す値は変更できず、name は付かない（DateRange の形なので、そのまま closedDates などに渡せる）。
+ *
+ * @example
+ * closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+ * closingPeriod("2026-10", -1); // { from: "2026-10-01", to: "2026-10-31" }（末日締め）
+ * closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" }（2 月の 31 日締めは 2 月末日）
+ * closingPeriod("2026-11-05", 20); // { from: "2026-10-21", to: "2026-11-20" }（この日が属する期間）
+ * @public
+ */
+export function closingPeriod(input, closingDay) {
+    checkClosingDay(closingDay);
+    const month = typeof input === "string" && input.split("-").length === 3
+        ? parseMonth(closingMonth(input, closingDay))
+        : parseMonth(input);
+    const previous = shiftMonth(month, -1);
+    const to = dayOfMonth(month, closingDayIn(month, closingDay));
+    const from = addDays(dayOfMonth(previous, closingDayIn(previous, closingDay)), 1);
+    return Object.freeze({ from, to });
 }

package/dist/core/schedule.d.ts

@@ -283,6 +283,11 @@ export interface HolidayLookup<Kind extends string = string> {
     /** 入力をタイムゾーンでの暦日と時刻に変換する */
     civilOf(input: DateTimeInput): CivilDateTimeParts<string>;
     civilOf(input: DateInput): CivilDateTimeParts;
+    /**
+     * 暦日 "YYYY-MM-DD" と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf の逆向き）。
+     * 夏時間で存在しない時刻は飛んだ分だけ後ろに、2 回ある時刻は先のほう（toInstant と同じ）
+     */
+    instantOf(date: DateString, time: string): Date;
     /** 今日の日付（タイムゾーン） */
     today(now?: Date): DateString;
     /** 祝日か */
@@ -429,6 +434,8 @@ type HolidayLookupInternal<Kind extends string> = ReturnType<typeof createHolida
 export declare function createResolver<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>, lookup: HolidayLookupInternal<Kind>): (date: DateString) => Resolution<T, Kind>;
 /** @internal 期間（両端を含む）の日ごとに fn を呼んだ結果。from が to より後ならエラー */
 export declare function mapDays<R>(from: DateString, to: DateString, fn: (date: DateString) => R): readonly R[];
+/** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
+export declare function infoOfSchedule<T, Kind extends string>(schedule: Schedule<T, Kind>): ((date: DateString) => ScheduleDay<T, Kind>) | undefined;
 /** @internal 検証済みの規則からスケジュールを作る */
 export declare function buildSchedule<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>): Schedule<T, Kind>;
 /**

package/dist/core/schedule.js

@@ -19,7 +19,7 @@
  */
 import { addDays, daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, rangeError } from "./errors.js";
-import { instantToCivil, toCivil, toDateTimeParts, validateTimeZone, } from "./input.js";
+import { instantToCivil, toCivil, toDateTimeParts, toInstant, validateTimeZone, } from "./input.js";
 // ------------------------------------------------------------
 // 入力チェック（誤りを集める。作成時は最初の誤りを例外にする）
 // ------------------------------------------------------------
@@ -577,6 +577,7 @@ export function createHolidayLookup(source) {
         holidayOn,
         dateOf,
         civilOf: ((input) => toDateTimeParts(input, timeZone)),
+        instantOf: (date, time) => toInstant(date, time, timeZone),
         today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
         isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
         getHoliday: (input) => holidayOn(dateOf(input)),
@@ -773,6 +774,15 @@ export function mapDays(from, to, fn) {
         result.push(fn(fromDayNumber(n)));
     return Object.freeze(result);
 }
+/**
+ * @internal スケジュールの内部の判定（暦日の文字列を直接受け取る）。createCalendarFromSchedule が、公開メソッド
+ * （入力の解析を通る）を経由せずに 1 日分の結果を得るために使う。スケジュールごとに作成時に登録する
+ */
+const internalInfo = new WeakMap();
+/** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
+export function infoOfSchedule(schedule) {
+    return internalInfo.get(schedule);
+}
 /** @internal 検証済みの規則からスケジュールを作る */
 export function buildSchedule(compiled) {
     const lookup = createHolidayLookup(compiled.source);
@@ -784,6 +794,7 @@ export function buildSchedule(compiled) {
         outOfRange: lookup.outOfRange,
         dateOf: lookup.dateOf,
         civilOf: lookup.civilOf,
+        instantOf: lookup.instantOf,
         today: lookup.today,
         isHoliday: lookup.isHoliday,
         getHoliday: lookup.getHoliday,
@@ -793,7 +804,9 @@ export function buildSchedule(compiled) {
         dayInfo: (input) => info(lookup.dateOf(input)),
         daysBetween: (from, to) => mapDays(lookup.dateOf(from), lookup.dateOf(to), info),
     };
-    return Object.freeze(schedule);
+    Object.freeze(schedule);
+    internalInfo.set(schedule, info);
+    return schedule;
 }
 /**
  * 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る。

package/dist/index.d.ts

@@ -7,10 +7,10 @@
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
-export { combineCalendars, createCalendar, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, type CombineOptions, type DateRange, type DayInfo, type DayReason, type DueDateOptions, type HolidayPolicy, type KnownDayReason, type SpecificDate, } from "./core/calendar.ts";
+export { 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 DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
-export { closingMonth, monthOf, type MonthString } from "./core/month.ts";
+export { closingMonth, closingPeriod, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";
-export { toDateString, toDateTimeParts, type DateInput, type DateTimeInput, type TemporalDateLike, type TemporalDateTimeLike, type TemporalInstantLike, } from "./core/input.ts";
+export { toDateString, toDateTimeParts, toInstant, type DateInput, type DateTimeInput, type TemporalDateLike, type TemporalDateTimeLike, type TemporalInstantLike, } from "./core/input.ts";
 export type { Holiday, HolidayProvider } from "./core/types.ts";

package/dist/index.js

@@ -7,9 +7,9 @@
  * 公開する API には TSDoc の @public（安定）または @beta（マイナー版で変わりうる）を付ける。
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
-export { combineCalendars, createCalendar, } from "./core/calendar.js";
+export { combineCalendars, createCalendar, createCalendarFromSchedule, } from "./core/calendar.js";
 export { createSchedule, } from "./core/schedule.js";
 export { addDays, diffDays, isValidDate, weekdayOf, } from "./core/date.js";
-export { closingMonth, monthOf } from "./core/month.js";
+export { closingMonth, closingPeriod, monthOf } from "./core/month.js";
 export { isBizdaysError } from "./core/errors.js";
-export { toDateString, toDateTimeParts, } from "./core/input.js";
+export { toDateString, toDateTimeParts, toInstant, } from "./core/input.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Holidays, business-day calendar and day-by-day schedules (e.g. store hours) with time zone support. Japanese holidays verified against the Cabinet Office data; UK bank holidays (England, Wales, Scotland, Northern Ireland) verified against GOV.UK. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK のデータで全日照合）",
   "keywords": [
     "bank-holidays",