bizdays-toolkit 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -4,6 +4,53 @@
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-10-18
+
+### 移行
+
+作業は要りません（機能の追加だけ）。時刻を必ず持つ入力では `time` の型が `string` になったので、これまでの `null` の分岐は不要になります（残しても動く）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 期間の日ごとの情報を返す `daysBetween(from, to)` を、スケジュール（`ScheduleDay` の配列）と営業日カレンダー（`DayInfo` の配列）に追加した。両端を含み、`from` が `to` より後なら `invalid-range`。祝日だけ欲しい場合は、結果を `holiday` で絞る
+- 時刻を必ず持つ入力の型 `DateTimeInput`（`Date`・Temporal の `Instant`・`ZonedDateTime`・`PlainDateTime`・`"YYYY-MM-DDTHH:mm…"` の文字列）と、`TemporalDateTimeLike` を追加した
+
+### Changed
+
+- `civilOf`（スケジュール・営業日カレンダー）・`toDateTimeParts`・`toJapanDateTime` に、`DateTimeInput` を渡したときは `time` の型を `string` とするオーバーロードを加えた。返す値は変わらない。`CivilDateTimeParts` は時刻の型を引数に取る型になった（省略時はこれまでと同じ `string | null`）
+- README: スケジュールの `dayInfo` の `reason` は値を決めた規則であり、祝日の規則が `"weekday"` のときは祝日でも `"weekday"` になること（祝日かどうかは `holiday` で判定する）を書いた。`createCalendar`・`createSchedule` は作ったものを使い回すのが基本で、作成のコストも小さいこと（測った値）を書いた。1 つの配列で持つ特別営業日を `dates` と `annual` に振り分ける例と、型定義の確認の範囲（CI で `moduleResolution` の `node16`・`nodenext`・`bundler`、0.9.0 の時点で TypeScript 5.0・5.5・5.8 も手作業で確認）を足した
+- README のサイズの値を測り直した（ルート約 7.5KB・日本の祝日込み約 9.0KB・英国の祝日込み約 9.1KB。0.9.0 で測定）
+- 移行ガイド（`docs/migration.md`）を追加した。0.2.0〜0.9.0 で利用者がする作業を版ごとにまとめた
+
+### 開発
+
+- `pnpm check` で、利用者のプロジェクトとして公開する型定義を型チェックするようにした（`scripts/check-consumer-types.ts`・`test/consumer/consumer.mts`。`moduleResolution` を `node16`・`nodenext`・`bundler` に変え、ライブラリの型定義の検査も有効にする）
+
+- GOV.UK の監視を、外部の cron サービス（cron-job.org）から `workflow_dispatch` で起動する形にした（毎日 06:00 日本時間）。GitHub の schedule は予備として 18:17（日本時間）に移した。GitHub の schedule は高負荷時に遅れたり落ちたりし、追加してから一度も動かなかったため。動いたことは最後に healthchecks.io へ知らせ（Secrets の `HEALTHCHECKS_PING_URL`。照合そのものが失敗したときは `/fail`）、知らせが途絶えたらメールが届くようにした（RELEASING.md の「監視の起動とハートビート」。cron-job.org からの呼び出しは REST API の 2026-03-10 版を指定する）
+
+- ブラウザーでの確認（`scripts/test-browsers.ts`）に時間制限を設けた。ページの読み込みとスクリプトの実行は 30 秒（WebDriver の `timeouts`）、ドライバーへの各呼び出しは 60 秒。結果を受け取る前の段階（ドライバーの起動・セッションの作成・ページの読み込み・結果の待ち）で止まったときだけ、ドライバーを起動し直して 1 回だけやり直し、その理由を `RETRY` としてログに出す。確認の結果が FAIL のときはやり直さない。CI でランナー上の Edge がページの読み込みで応答しなくなり、既定の 300 秒を待って失敗したため
+
+## [0.8.1] - 2026-10-18
+
+ライブラリのコードは 0.8.0 と同じ。動作を確かめる環境を広げ、README の記述を確かめた範囲に合わせた。
+
+### Changed
+
+- README の動作環境の記述を、CI で確かめた範囲に合わせた。「Node.js・ブラウザー・エッジランタイムで動作」を、確かめている環境（Node.js・Chrome・Firefox・Edge・Safari・Cloudflare Workers）の明記に改め、確かめていない環境（Deno・Bun・Vercel の Edge Runtime など）も書いた。Temporal は形で判別していることと、本物の Temporal を備えた環境では CI で確かめていることを書いた。サイズの値に測った版（0.8.1）を添えた。エラーコードの一覧に `invalid-input` を足した
+- README に、CI で確かめている Node.js の版（22.12・22・24・26）と、CommonJS の `require()` で読み込めることを CI で確かめていることを書いた。Node.js 22.12 では `require()` での読み込みに実験的な機能の警告が出ることも書いた（結果には影響しない）。`engines`（`>=22.12`）は変わらない
+
+### 開発
+
+- 公開する `dist` を ESM（`import`）と CommonJS（`require()`）で確かめるテスト（`test/compat`、`pnpm test:compat`）を追加し、`pnpm check` に含めた。CI に `compat` ジョブを追加し、engines の下限の Node.js 22.12.0 と 26.12.0 でも確かめる（これらの版ではテストの `.ts` と npm 12 が動かないため、ビルドは Node.js 24 で行い、Node.js を切り替えて `dist` だけを確かめる）
+
+- CI に、公開する `dist` をブラウザーと Cloudflare Workers で確かめるジョブを追加した。`browsers`（Chrome・Firefox・Edge。ランナーのドライバーを WebDriver で操作する `scripts/test-browsers.ts`）・`safari`（macOS）・`workerd`（版と SHA-256 を固定した公式のリリースの workerd で動かす `scripts/test-workerd.ts`）。確認の中身は `test/compat/smoke.mjs` に共通化し、本物の Temporal を備えた環境では Temporal のオブジェクトでも確かめる
+- `pnpm check` で、README（英語・日本語）のコード例を実行し、コメントに書いた結果と比べるようにした（`scripts/check-readme-examples.ts`）
+- `pnpm check`（`scripts/check-package.ts`）で、`src` が Node.js 固有の機能（`node:` のモジュール・`process`・`Buffer` など）を使っていないことを確かめるようにした
+- 自前のスクリプトとテストで Node.js の警告が出たら失敗にするようにした（`scripts/strict-warnings.ts`。`test/compat` は対象外）
+- `pnpm check` の最初に、開発用のツールの版を確かめる `scripts/check-toolchain.ts` を追加した（ワークフローどうしの Node.js の版、compat の行列の engines の下限、実行している Node.js・npm・pnpm と固定版の比較。固定版との違いは CI ではエラー、手元では注意の表示）
+- GOV.UK の監視のワークフローに、手動実行の入力 `simulate` を追加した。架空の祝日を 1 件足して照合し（`pnpm verify:govuk --simulate`）、ラベル `govuk-data-simulation` の issue で差分の経路を確かめられる
+- `pnpm check` のパッケージの中身の検査（`npm pack --dry-run`）を、Windows で Node.js の非推奨の警告（DEP0190）が出ない形で npm を起動するようにした
+
 ## [0.8.0] - 2026-10-17
 
 ### Added
@@ -179,7 +226,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.1...v0.9.0
+[0.8.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.5.0...v0.6.0

package/README.md

@@ -26,7 +26,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **Month-based due dates**: due dates such as "closing on the 20th, paid on the 10th of the next month (next business day if closed)" or "the last business day of the month", with the four adjustment conventions used in finance (following, preceding, modified-following, modified-preceding)
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 7.4 KB min+gzip (about 9.0 KB with Japanese holidays, about 9.0 KB with UK bank holidays). ESM, bundled types and `sideEffects: false`; runs on Node.js, browsers and edge runtimes
+- **Lightweight, zero dependencies**: about 7.5 KB min+gzip (about 9.0 KB with Japanese holidays, about 9.1 KB with UK bank holidays; measured for 0.9.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -35,7 +35,9 @@ A business-day calendar that combines public holidays with company or store clos
 pnpm add bizdays-toolkit
 ```
 
-Node.js 22.12 or later. The package is ESM only, but Node.js 22.12 and later can also load it from CommonJS with `require()`.
+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.
 
 ## Usage
 
@@ -112,8 +114,13 @@ shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
 
 shipping.dayInfo("2027-01-01");
 // { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "New Year closure", holiday: {…} }
+shipping.daysBetween("2026-12-30", "2027-01-04").map((d) => d.businessDay); // [true, false, false, false, false, true]
 ```
 
+`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included).
+
+`createCalendar` and `createSchedule` validate the options when they are created, so the usual pattern is to create them once and reuse them. Creating is also cheap (about 0.02 ms for a calendar and 0.04 ms for a schedule with Japanese holidays on a development machine), so creating one per request is not a problem in practice.
+
 Each day is decided in this order of priority (top first).
 
 1. `openDates` (specific open days)
@@ -203,6 +210,23 @@ const jpWithoutCitizensHoliday = {
 const calendar = createCalendar({ holidays: jpWithoutCitizensHoliday, closedWeekdays: [0, 6] });
 ```
 
+**Split special days kept in one list**: dates (`"YYYY-MM-DD"`) go in `dates` and annual dates (`"MM-DD"`) in `annual`.
+
+```ts
+type Hours = { open: string; close: string } | null;
+const regular: Hours = { open: "10:00", close: "19:00" };
+const specialDays: { date: string; value: Hours }[] = [
+  { date: "2026-12-31", value: { open: "10:00", close: "17:00" } },
+  { date: "01-01", value: null },
+];
+const special = createSchedule<Hours>({
+  weekly: [regular, regular, regular, regular, regular, regular, regular],
+  dates: specialDays.filter((d) => d.date.length === 10),
+  annual: specialDays.filter((d) => d.date.length === 5),
+});
+special.valueOn("2027-01-01"); // null
+```
+
 **Build per-store calendars from shared options**: options are plain objects, so spread and extend them.
 
 ```ts
@@ -288,8 +312,16 @@ const storeHours = createSchedule<Hours>({
 storeHours.valueOn("2026-11-03"); // { open: "10:00", close: "19:00" } (Culture Day uses Sunday hours)
 storeHours.dayInfo("2027-01-01");
 // { date: "2027-01-01", weekday: 5, value: null, reason: "annual", name: "Closed on New Year's Day", holiday: {…} }
+
+// Holidays in a period with their hours: filter daysBetween by holiday
+storeHours
+  .daysBetween("2026-11-01", "2026-11-30")
+  .filter((d) => d.holiday)
+  .map((d) => d.date); // ["2026-11-03", "2026-11-23"]
 ```
 
+`reason` is the rule that decided the value. With `holiday: "weekday"` (holidays follow the weekday rule), a holiday has `reason: "weekday"`, so check `holiday` to know whether a day is a holiday.
+
 Values are decided in the order `dates` (specific dates and ranges) → `annual` (annual dates and ranges) → `recurring` (`"over-holiday"`) → holidays → `recurring` (default and moved days) → `weekly` (weekday). When rules of the same type overlap, the one written first in the array wins.
 
 Checking a time range such as "is the store open now" is left to your app, because industries differ (opening past midnight, breaks and so on). With `civilOf` you get the civil date and time in the time zone, and the check is short.
@@ -297,10 +329,10 @@ Checking a time range such as "is the store open now" is left to your app, becau
 ```ts
 const { date, time } = storeHours.civilOf(new Date()); // { date: "2026-10-14", time: "16:30" } (Japan time)
 const hours = storeHours.valueOn(date);
-const isOpen = hours !== null && time !== null && hours.open <= time && time < hours.close;
+const isOpen = hours !== null && hours.open <= time && time < hours.close;
 ```
 
-`civilOf` is also on business-day calendars, and the same conversion is available as `toJapanDateTime` in `bizdays-toolkit/jp` and `toDateTimeParts(input, timeZone)` in the root.
+For inputs that always carry a time (a `Date`, Temporal `Instant`, `ZonedDateTime` or `PlainDateTime`, or a `"YYYY-MM-DDTHH:mm"` string), `time` is typed as `string`, so no `null` check is needed. `civilOf` is also on business-day calendars, and the same conversion is available as `toJapanDateTime` in `bizdays-toolkit/jp` and `toDateTimeParts(input, timeZone)` in the root.
 
 ### Date and date-time inputs
 
@@ -315,6 +347,8 @@ Every method accepts the following inputs. Returned dates are always `"YYYY-MM-D
 | Temporal `PlainDate`, `PlainDateTime`                | A civil date or date and time (no dependency on Temporal)         |
 | Temporal `Instant`, `ZonedDateTime`                  | An instant                                                        |
 
+Temporal objects are recognized by their shape, so the package does not depend on Temporal. CI also checks real Temporal objects in the runtimes that provide Temporal (the CI log shows whether each runtime had it).
+
 The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
 ### Holidays of other countries and regions
@@ -379,7 +413,7 @@ try {
 }
 ```
 
-Main codes: `invalid-date`, `invalid-month`, `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`. Future versions may add codes.
+Main codes: `invalid-date`, `invalid-input`, `invalid-month`, `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`. Future versions may add codes.
 
 ### Option diagnostics
 
@@ -446,7 +480,7 @@ Versioning follows [Semantic Versioning](https://semver.org/). See [RELEASING.md
 - 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) 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 `dataVersion` (for Japan, the year and month of the Official Gazette reflected; for the UK, the year and month of the GOV.UK data reflected) and `confirmedThrough`
-- Before 1.0.0, minor versions may contain breaking changes
+- 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
 - Decision reasons (`reason`), holiday kinds (`kind`), error codes and diagnostic codes may gain values in future versions. When you branch on their values, handle "anything else" too (see "互換性の約束", the compatibility promise, in [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md))
 
 ## Data sources

package/dist/core/calendar.d.ts

@@ -161,6 +161,8 @@ export interface DueDateOptions {
 export interface Calendar<Kind extends string = string> extends HolidayLookup<Kind> {
     /** 1 日分の判定結果（営業日か・理由・祝日） */
     dayInfo(input: DateInput): DayInfo<Kind>;
+    /** 期間内の日ごとの判定結果（両端を含む。from が to より後ならエラー） */
+    daysBetween(from: DateInput, to: DateInput): readonly DayInfo<Kind>[];
     /** 営業日か */
     isBusinessDay(input: DateInput): boolean;
     /** 翌営業日（入力日の翌日以降） */

package/dist/core/calendar.js

@@ -20,7 +20,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, isWeekday, RECURRING_RULE_KEYS, } from "./schedule.js";
+import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
     "timeZone",
@@ -236,6 +236,7 @@ export function createCalendar(options = {}) {
         holidaysInYear: schedule.holidaysInYear,
         holidaysBetween: schedule.holidaysBetween,
         dayInfo: (input) => info(dateOf(input)),
+        daysBetween: (from, to) => mapDays(dateOf(from), dateOf(to), info),
         isBusinessDay: (input) => isOpen(dateOf(input)),
         nextBusinessDay: (input) => search(addDays(dateOf(input), 1), 1),
         previousBusinessDay: (input) => search(addDays(dateOf(input), -1), -1),

package/dist/core/input.d.ts

@@ -33,6 +33,30 @@ export interface TemporalInstantLike {
  * @public
  */
 export type DateInput = string | Date | TemporalDateLike | TemporalInstantLike;
+/**
+ * Temporal.PlainDateTime として受け付ける最小限の形（時刻を持つ TemporalDateLike）。
+ * @public
+ */
+export interface TemporalDateTimeLike extends TemporalDateLike {
+    readonly hour: number;
+    readonly minute: number;
+}
+/**
+ * 時刻を必ず持つ入力（瞬間、Temporal.PlainDateTime、"YYYY-MM-DDTHH:mm…" の文字列）。
+ * これを渡すと、civilOf・toDateTimeParts・toJapanDateTime の time の型が string になる。
+ * @public
+ */
+export type DateTimeInput = Date | TemporalInstantLike | TemporalDateTimeLike | `${number}-${number}-${number}T${string}`;
+/**
+ * タイムゾーンでの暦日と時刻。Time は時刻の型で、時刻を必ず持つ入力（DateTimeInput）では string になる。
+ * @public
+ */
+export interface CivilDateTimeParts<Time extends string | null = string | null> {
+    /** 暦日 "YYYY-MM-DD" */
+    readonly date: DateString;
+    /** 時刻 "HH:mm"。暦日だけの入力では null */
+    readonly time: Time;
+}
 /** @internal 暦日と、分かる場合は 0 時からの経過分 */
 export interface CivilDateTime {
     readonly date: DateString;
@@ -52,11 +76,11 @@ export declare function toCivil(input: DateInput, timeZone: string): CivilDateTi
 export declare function toDateString(input: DateInput, timeZone: string): DateString;
 /**
  * 入力を、タイムゾーンでの暦日と時刻（"HH:mm"。暦日だけの入力では null）に変換する。
+ * 時刻を必ず持つ入力（DateTimeInput）では、time の型が string になる。
  * @public
  */
-export declare function toDateTimeParts(input: DateInput, timeZone: string): {
-    readonly date: DateString;
-    readonly time: string | null;
-};
+export declare function toDateTimeParts(input: DateTimeInput, timeZone: string): CivilDateTimeParts<string>;
+/** @public */
+export declare function toDateTimeParts(input: DateInput, timeZone: string): CivilDateTimeParts;
 /** @internal "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export declare function parseTimeOfDay(value: string): number;

package/dist/core/input.js

@@ -136,10 +136,6 @@ export function toCivil(input, timeZone) {
 export function toDateString(input, timeZone) {
     return toCivil(input, validateTimeZone(timeZone)).date;
 }
-/**
- * 入力を、タイムゾーンでの暦日と時刻（"HH:mm"。暦日だけの入力では null）に変換する。
- * @public
- */
 export function toDateTimeParts(input, timeZone) {
     const civil = toCivil(input, validateTimeZone(timeZone));
     const time = civil.minutes === null

package/dist/core/schedule.d.ts

@@ -16,7 +16,8 @@
  */
 import { type DateString, type Weekday } from "./date.ts";
 import { IssueCollector } from "./errors.ts";
-import { type DateInput } from "./input.ts";
+import { type CivilDateTimeParts, type DateInput, type DateTimeInput } from "./input.ts";
+export type { CivilDateTimeParts } from "./input.ts";
 import type { Holiday, HolidayProvider } from "./types.ts";
 /**
  * 祝日の値の決め方（スケジュールの holiday の設定）。
@@ -198,16 +199,6 @@ export interface ScheduleDay<T, Kind extends string = string> {
     /** 祝日から振り替えられた規則で値が決まった場合、振替の元の日付（onHolidayRule: "after-holiday"） */
     readonly shiftedFrom?: DateString;
 }
-/**
- * 暦日と時刻（カレンダーのタイムゾーン）。
- * @public
- */
-export interface CivilDateTimeParts {
-    /** 暦日 "YYYY-MM-DD" */
-    readonly date: DateString;
-    /** 時刻 "HH:mm"。暦日だけの入力では null */
-    readonly time: string | null;
-}
 /**
  * 祝日を調べる機能（スケジュールと営業日カレンダーで共通）。
  * @public
@@ -220,6 +211,7 @@ export interface HolidayLookup<Kind extends string = string> {
     /** 入力をタイムゾーンでの暦日に変換する */
     dateOf(input: DateInput): DateString;
     /** 入力をタイムゾーンでの暦日と時刻に変換する */
+    civilOf(input: DateTimeInput): CivilDateTimeParts<string>;
     civilOf(input: DateInput): CivilDateTimeParts;
     /** 今日の日付（タイムゾーン） */
     today(now?: Date): DateString;
@@ -239,8 +231,13 @@ export interface HolidayLookup<Kind extends string = string> {
 export interface Schedule<T, Kind extends string = string> extends HolidayLookup<Kind> {
     /** その日の値 */
     valueOn(input: DateInput): T;
-    /** その日の値と、値を決めた規則 */
+    /**
+     * その日の値と、値を決めた規則（reason）。reason は値を決めた規則なので、祝日の規則が "weekday"（曜日どおり）の
+     * ときは、祝日でも "weekday" になる。祝日かどうかは holiday の有無で判定する
+     */
     dayInfo(input: DateInput): ScheduleDay<T, Kind>;
+    /** 期間内の日ごとの値と規則（両端を含む。from が to より後ならエラー） */
+    daysBetween(from: DateInput, to: DateInput): readonly ScheduleDay<T, Kind>[];
 }
 /** @internal "MM-DD" として正しいか（2 月 29 日は可） */
 export declare function isValidMonthDay(value: unknown): value is string;
@@ -331,6 +328,8 @@ type HolidayLookupInternal<Kind extends string> = ReturnType<typeof createHolida
  * 規則の診断では、規則を取り除いた版と結果を比べるために、祝日を調べる機能（lookup）を共有して作る
  */
 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 検証済みの規則からスケジュールを作る */
 export declare function buildSchedule<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>): Schedule<T, Kind>;
 /**
@@ -341,4 +340,3 @@ 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

@@ -14,7 +14,7 @@
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
-import { addDays, daysInMonth, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
+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";
 // ------------------------------------------------------------
@@ -454,7 +454,7 @@ export function createHolidayLookup(source) {
         providers,
         holidayOn,
         dateOf,
-        civilOf: (input) => toDateTimeParts(input, timeZone),
+        civilOf: ((input) => toDateTimeParts(input, timeZone)),
         today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
         isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
         getHoliday: (input) => holidayOn(dateOf(input)),
@@ -620,6 +620,16 @@ export function createResolver(compiled, lookup) {
         return make(weekly[weekday], "weekday", null, undefined);
     };
 }
+/** @internal 期間（両端を含む）の日ごとに fn を呼んだ結果。from が to より後ならエラー */
+export function mapDays(from, to, fn) {
+    if (from > to) {
+        throw rangeError("invalid-range", `"from" must not be after "to" (${from} > ${to})`);
+    }
+    const result = [];
+    for (let n = toDayNumber(from); n <= toDayNumber(to); n++)
+        result.push(fn(fromDayNumber(n)));
+    return Object.freeze(result);
+}
 /** @internal 検証済みの規則からスケジュールを作る */
 export function buildSchedule(compiled) {
     const lookup = createHolidayLookup(compiled.source);
@@ -637,6 +647,7 @@ export function buildSchedule(compiled) {
         holidaysBetween: lookup.holidaysBetween,
         valueOn: (input) => info(lookup.dateOf(input)).value,
         dayInfo: (input) => info(lookup.dateOf(input)),
+        daysBetween: (from, to) => mapDays(lookup.dateOf(from), lookup.dateOf(to), info),
     };
     return Object.freeze(schedule);
 }

package/dist/index.d.ts

@@ -12,5 +12,5 @@ export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDate
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
 export { closingMonth, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";
-export { toDateString, toDateTimeParts, type DateInput, type TemporalDateLike, type TemporalInstantLike, } from "./core/input.ts";
+export { toDateString, toDateTimeParts, type DateInput, type DateTimeInput, type TemporalDateLike, type TemporalDateTimeLike, type TemporalInstantLike, } from "./core/input.ts";
 export type { Holiday, HolidayProvider } from "./core/types.ts";

package/dist/jp/index.d.ts

@@ -11,7 +11,7 @@
  * isHoliday("2026-11-23"); // true
  */
 import type { DateString } from "../core/date.ts";
-import type { DateInput } from "../core/input.ts";
+import type { CivilDateTimeParts, DateInput, DateTimeInput } from "../core/input.ts";
 import type { Holiday, HolidayProvider } from "../core/types.ts";
 import { type JapaneseHolidayKind } from "./rules.ts";
 export type { JapaneseHolidayKind, KnownJapaneseHolidayKind } from "./rules.ts";
@@ -52,12 +52,12 @@ export declare function holidaysBetween(from: DateInput, to: DateInput): readonl
 export declare function toJapanDate(input: DateInput): DateString;
 /**
  * 日本時間での暦日と時刻（"HH:mm"。暦日だけの入力では null）。
+ * 時刻を必ず持つ入力（Date・Temporal.Instant など）では、time の型が string になる。
  * @public
  */
-export declare function toJapanDateTime(input: DateInput): {
-    readonly date: DateString;
-    readonly time: string | null;
-};
+export declare function toJapanDateTime(input: DateTimeInput): CivilDateTimeParts<string>;
+/** @public */
+export declare function toJapanDateTime(input: DateInput): CivilDateTimeParts;
 /**
  * 反映済みの官報の年月。
  * @public

package/dist/jp/index.js

@@ -69,10 +69,6 @@ export function holidaysBetween(from, to) {
 export function toJapanDate(input) {
     return calendar().dateOf(input);
 }
-/**
- * 日本時間での暦日と時刻（"HH:mm"。暦日だけの入力では null）。
- * @public
- */
 export function toJapanDateTime(input) {
     return calendar().civilOf(input);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.8.0",
+  "version": "0.9.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",
@@ -56,12 +56,13 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --deny-warnings src scripts test",
-    "test": "node --test \"test/**/*.test.ts\"",
+    "test": "node --import ./scripts/strict-warnings.ts --test \"test/**/*.test.ts\"",
     "test:tz": "node scripts/test-tz.ts",
+    "test:compat": "node --test test/compat/esm.test.mjs test/compat/cjs.test.cjs",
     "bench": "node scripts/bench.ts",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
-    "check": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:tz && pnpm build && pnpm fmt:check && node scripts/check-package.ts && node scripts/check-size.ts && node scripts/api-report.ts",
+    "check": "node scripts/check-toolchain.ts && pnpm typecheck && pnpm lint && pnpm test && pnpm test:tz && pnpm build && pnpm test:compat && node scripts/check-readme-examples.ts && node scripts/check-consumer-types.ts && pnpm fmt:check && node scripts/check-package.ts && node scripts/check-size.ts && node scripts/api-report.ts",
     "verify:cao": "node scripts/verify-cao.ts",
     "verify:govuk": "node scripts/verify-govuk.ts",
     "prepublishOnly": "pnpm check",