@northguild/gmt 1.14.2 → 1.16.0

package/dist/plain/interval/splitIntervalByUnitDate.d.ts

@@ -1,22 +1,38 @@
 /**
  * Split a date interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Each boundary is computed from `start` (`start + k × amount`, as Temporal and Luxon's
+ *   `Interval.splitBy` do), not by stepping from the previous boundary, so month-end starts
+ *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - A step that resolves to the same date as the previous boundary is skipped, so no empty
+ *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainDate`, e.g. `"hours"`).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
  *   carry the *same* calendar tag, stepping (and each slice's boundaries) happens in that
- *   calendar — a Hebrew leap year splits into 13 month-slices, not 12 (E5 decision of record
- *   D5); otherwise (or if either is bare ISO) it falls back to Gregorian. Each boundary's tag is
+ *   calendar — a Hebrew leap year splits into 13 month-slices, not 12. When they name different
+ *   calendars (a bare ISO string names `iso8601`) the result is `[]`, as Temporal's `until` throws
+ *   when `CalendarEquals` is false (before 1.16.0 it stepped in ISO). Each boundary's tag is
  *   re-derived from the actual stepped date, never copied — a month-by-month step can cross a
  *   leap-month or era boundary mid-split.
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping where it can be, and
+ *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param start ISO PlainDate string for the interval start, optionally calendar-annotated
  * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
  * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
@@ -24,9 +40,13 @@
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-01", "day", 2) // [{ start: "2024-01-01", end: "2024-01-01" }]
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 0) // []
  * @example splitIntervalByUnitDate("invalid", "2024-01-10", "day", 2) // []
- * @example splitIntervalByUnitDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ * @example splitIntervalByUnitDate("2023-09-16[u-ca=hebrew]", "2024-10-03[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2, { maxPieces: 4 }) // [] (5 slices exceed the limit)
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2, { maxPieces: 5 }) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
  */
-export declare function splitIntervalByUnitDate(start: string, end: string, unit: string, amount: number): Array<{
+export declare function splitIntervalByUnitDate(start: string, end: string, unit: string, amount: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/splitIntervalByUnitDate.js

@@ -1,25 +1,44 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
-import { formatDateInCalendar, parseCalendarDatePairForArithmetic, resolveDurationUnit, } from "../../internal/index.js";
-import { isValidCalendarDate } from "../validate/index.js";
+import { formatDateInCalendar, NANOSECONDS_PER_DAY_NUMBER, parseCalendarDatePairForArithmetic, plainDateAdd, resolveDurationUnit, tileByUnit, } from "../../internal/index.js";
+import { isValidCalendarDate, isValidDateDurationUnit } from "../validate/index.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
+import { minSlicesForSpan } from "../../internal/splitStep.js";
 /**
  * Split a date interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Each boundary is computed from `start` (`start + k × amount`, as Temporal and Luxon's
+ *   `Interval.splitBy` do), not by stepping from the previous boundary, so month-end starts
+ *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - A step that resolves to the same date as the previous boundary is skipped, so no empty
+ *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainDate`, e.g. `"hours"`).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
  *   carry the *same* calendar tag, stepping (and each slice's boundaries) happens in that
- *   calendar — a Hebrew leap year splits into 13 month-slices, not 12 (E5 decision of record
- *   D5); otherwise (or if either is bare ISO) it falls back to Gregorian. Each boundary's tag is
+ *   calendar — a Hebrew leap year splits into 13 month-slices, not 12. When they name different
+ *   calendars (a bare ISO string names `iso8601`) the result is `[]`, as Temporal's `until` throws
+ *   when `CalendarEquals` is false (before 1.16.0 it stepped in ISO). Each boundary's tag is
  *   re-derived from the actual stepped date, never copied — a month-by-month step can cross a
  *   leap-month or era boundary mid-split.
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping where it can be, and
+ *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param start ISO PlainDate string for the interval start, optionally calendar-annotated
  * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
  * @param unit duration unit string — `"years" | "months" | "weeks" | "days"` (time units are ignored by PlainDate and return [])
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
@@ -27,54 +46,68 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-01", "day", 2) // [{ start: "2024-01-01", end: "2024-01-01" }]
  * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 0) // []
  * @example splitIntervalByUnitDate("invalid", "2024-01-10", "day", 2) // []
- * @example splitIntervalByUnitDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ * @example splitIntervalByUnitDate("2023-09-16[u-ca=hebrew]", "2024-10-03[u-ca=hebrew]", "month", 1) // 13 slices, tiling the Hebrew leap year (including Adar I)
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2, { maxPieces: 4 }) // [] (5 slices exceed the limit)
+ * @example splitIntervalByUnitDate("2024-01-01", "2024-01-10", "day", 2, { maxPieces: 5 }) // [{ start: "2024-01-01", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-05" }, { start: "2024-01-05", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-09" }, { start: "2024-01-09", end: "2024-01-10" }]
  */
-export function splitIntervalByUnitDate(start, end, unit, amount) {
-    if (typeof start !== "string" || typeof end !== "string") {
-        return [];
-    }
-    if (!isValidCalendarDate(start) || !isValidCalendarDate(end)) {
-        return [];
-    }
-    if (typeof unit !== "string") {
-        return [];
-    }
-    const resolvedUnit = resolveDurationUnit(unit);
-    if (!resolvedUnit) {
-        return [];
-    }
-    if (!Number.isFinite(amount) || amount <= 0) {
-        return [];
-    }
+export function splitIntervalByUnitDate(start, end, unit, amount, options) {
     try {
-        const { calendar, a: startVal, b: endVal } = parseCalendarDatePairForArithmetic(start, end);
-        if (Temporal.PlainDate.compare(startVal, endVal) > 0) {
+        if (typeof start !== "string" || typeof end !== "string") {
+            return [];
+        }
+        if (!isValidCalendarDate(start) || !isValidCalendarDate(end)) {
             return [];
         }
-        if (Temporal.PlainDate.compare(startVal, endVal) === 0) {
-            return [
-                {
-                    start: formatDateInCalendar(startVal, calendar),
-                    end: formatDateInCalendar(endVal, calendar),
-                },
-            ];
+        if (typeof unit !== "string") {
+            return [];
+        }
+        const resolvedUnit = resolveDurationUnit(unit);
+        // An unknown unit is invalid whatever the span, a zero-length one included.
+        if (!isValidDateDurationUnit(resolvedUnit)) {
+            return [];
+        }
+        if (!Number.isFinite(amount) || amount <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null) {
+            return [];
         }
-        const result = [];
-        for (let current = startVal; Temporal.PlainDate.compare(current, endVal) < 0;) {
-            const next = current.add({ [resolvedUnit]: amount });
-            if (Temporal.PlainDate.compare(next, current) === 0) {
+        try {
+            const { calendar, a: startVal, b: endVal, } = parseCalendarDatePairForArithmetic(start, end);
+            if (Temporal.PlainDate.compare(startVal, endVal) > 0) {
+                return [];
+            }
+            if (Temporal.PlainDate.compare(startVal, endVal) === 0) {
+                return [
+                    {
+                        start: formatDateInCalendar(startVal, calendar),
+                        end: formatDateInCalendar(endVal, calendar),
+                    },
+                ];
+            }
+            // Counted on the ISO dates: a day count is calendar-independent, and ISO `until` stays clear
+            // of the non-ISO polyfill arithmetic that the compat layer routes around near the range edges.
+            const spanNs = startVal
+                .withCalendar("iso8601")
+                .until(endVal.withCalendar("iso8601"), { largestUnit: "days" }).days *
+                NANOSECONDS_PER_DAY_NUMBER;
+            if (exceedsPieceLimit(minSlicesForSpan(spanNs, resolvedUnit, amount, false), maxPieces)) {
                 return [];
             }
-            const sliceEnd = Temporal.PlainDate.compare(next, endVal) > 0 ? endVal : next;
-            result.push({
-                start: formatDateInCalendar(current, calendar),
+            const slices = tileByUnit(startVal, endVal, Temporal.PlainDate.compare, resolvedUnit, amount, maxPieces, (value, duration) => plainDateAdd(value, duration, "constrain"));
+            return (slices ?? []).map(([sliceStart, sliceEnd]) => ({
+                start: formatDateInCalendar(sliceStart, calendar),
                 end: formatDateInCalendar(sliceEnd, calendar),
-            });
-            current = next;
+            }));
+        }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/plain/interval/splitIntervalByUnitDateTime.d.ts

@@ -1,15 +1,31 @@
 /**
  * Split a date-time interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Calendar-unit boundaries (years, months, weeks, days) are computed from `start`
+ *   (`start + k × amount`, as Temporal and Luxon's `Interval.splitBy` do), so month-end starts
+ *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
+ *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
+ *   `Number.MAX_SAFE_INTEGER`.
+ * - A step that resolves to the same value as the previous boundary is skipped, so no empty
+ *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping where it can be, and
+ *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param unit duration unit string — any `DateTimeDurationUnit`
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
@@ -17,8 +33,12 @@
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T12:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" }]
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 0) // []
  * @example splitIntervalByUnitDateTime("invalid", "2024-01-01T14:00:00", "hour", 1) // []
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1, { maxPieces: 1 }) // [] (2 slices exceed the limit)
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1, { maxPieces: 2 }) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
  */
-export declare function splitIntervalByUnitDateTime(start: string, end: string, unit: string, amount: number): Array<{
+export declare function splitIntervalByUnitDateTime(start: string, end: string, unit: string, amount: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/splitIntervalByUnitDateTime.js

@@ -1,19 +1,37 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
-import { isValidDateTime } from "../validate/index.js";
-import { resolveDurationUnit } from "../../internal/index.js";
+import { isValidDateTime, isValidDateTimeDurationUnit } from "../validate/index.js";
+import { resolveDurationUnit, tileByUnit } from "../../internal/index.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
+import { minSlicesForSpan } from "../../internal/splitStep.js";
 /**
  * Split a date-time interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Calendar-unit boundaries (years, months, weeks, days) are computed from `start`
+ *   (`start + k × amount`, as Temporal and Luxon's `Interval.splitBy` do), so month-end starts
+ *   don't drift: a monthly split from January 31 lands on February 29, March 31, April 30.
+ * - Exact-unit boundaries (hours and smaller) step from the previous boundary. Exact units never
+ *   clamp, and stepping keeps nanosecond precision where `k × amount` would pass
+ *   `Number.MAX_SAFE_INTEGER`.
+ * - A step that resolves to the same value as the previous boundary is skipped, so no empty
+ *   slice is produced. A step that goes backwards returns `[]`.
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping where it can be, and
+ *   otherwise as soon as slice `maxPieces + 1` is due. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param unit duration unit string — any `DateTimeDurationUnit`
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
@@ -21,52 +39,60 @@ import { resolveDurationUnit } from "../../internal/index.js";
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T12:00:00", "hour", 1) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" }]
  * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 0) // []
  * @example splitIntervalByUnitDateTime("invalid", "2024-01-01T14:00:00", "hour", 1) // []
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1, { maxPieces: 1 }) // [] (2 slices exceed the limit)
+ * @example splitIntervalByUnitDateTime("2024-01-01T12:00:00", "2024-01-01T14:00:00", "hour", 1, { maxPieces: 2 }) // [{ start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }, { start: "2024-01-01T13:00:00", end: "2024-01-01T14:00:00" }]
  */
-export function splitIntervalByUnitDateTime(start, end, unit, amount) {
-    if (typeof start !== "string" || typeof end !== "string") {
-        return [];
-    }
-    if (!plainDateTime.test(start) || !plainDateTime.test(end)) {
-        return [];
-    }
-    if (!isValidDateTime(start) || !isValidDateTime(end)) {
-        return [];
-    }
-    if (typeof unit !== "string") {
-        return [];
-    }
-    const resolvedUnit = resolveDurationUnit(unit);
-    if (!resolvedUnit) {
-        return [];
-    }
-    if (!Number.isFinite(amount) || amount <= 0) {
-        return [];
-    }
+export function splitIntervalByUnitDateTime(start, end, unit, amount, options) {
     try {
-        const startVal = Temporal.PlainDateTime.from(start);
-        const endVal = Temporal.PlainDateTime.from(end);
-        if (Temporal.PlainDateTime.compare(startVal, endVal) > 0) {
+        if (typeof start !== "string" || typeof end !== "string") {
+            return [];
+        }
+        if (!isValidDateTime(start) || !isValidDateTime(end)) {
+            return [];
+        }
+        if (typeof unit !== "string") {
             return [];
         }
-        if (Temporal.PlainDateTime.compare(startVal, endVal) === 0) {
-            return [{ start: startVal.toString(), end: endVal.toString() }];
+        const resolvedUnit = resolveDurationUnit(unit);
+        // An unknown unit is invalid whatever the span, a zero-length one included.
+        if (!isValidDateTimeDurationUnit(resolvedUnit)) {
+            return [];
         }
-        const result = [];
-        for (let current = startVal; Temporal.PlainDateTime.compare(current, endVal) < 0;) {
-            const next = current.add({ [resolvedUnit]: amount });
-            if (Temporal.PlainDateTime.compare(next, current) === 0) {
+        if (!Number.isFinite(amount) || amount <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null) {
+            return [];
+        }
+        try {
+            const startVal = Temporal.PlainDateTime.from(start);
+            const endVal = Temporal.PlainDateTime.from(end);
+            if (Temporal.PlainDateTime.compare(startVal, endVal) > 0) {
+                return [];
+            }
+            if (Temporal.PlainDateTime.compare(startVal, endVal) === 0) {
+                return [{ start: startVal.toString(), end: endVal.toString() }];
+            }
+            const spanNs = startVal
+                .until(endVal, { largestUnit: "hours" })
+                .total("nanoseconds");
+            if (exceedsPieceLimit(minSlicesForSpan(spanNs, resolvedUnit, amount, false), maxPieces)) {
                 return [];
             }
-            const sliceEnd = Temporal.PlainDateTime.compare(next, endVal) > 0 ? endVal : next;
-            result.push({
-                start: current.toString(),
+            const slices = tileByUnit(startVal, endVal, Temporal.PlainDateTime.compare, resolvedUnit, amount, maxPieces);
+            return (slices ?? []).map(([sliceStart, sliceEnd]) => ({
+                start: sliceStart.toString(),
                 end: sliceEnd.toString(),
-            });
-            current = next;
+            }));
+        }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/plain/interval/splitIntervalByUnitTime.d.ts

@@ -1,25 +1,41 @@
 /**
  * Split a time interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Boundaries lie on the one day between `start` and `end`: `PlainTime` arithmetic wraps at
+ *   midnight, but a step that reaches or passes midnight is past `end`, so that slice is trimmed
+ *   to `end` (`"12:00"` to `"23:00"` by 12 hours is one slice).
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping. An invalid
+ *   `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param unit duration unit string — `"hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds"` (calendar units are ignored by PlainTime and return [])
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }]
  * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
+ * @example splitIntervalByUnitTime("20:00:00", "23:00:00", "hour", 5) // [{ start: "20:00:00", end: "23:00:00" }] (20:00 + 5 hours is past midnight)
  * @example splitIntervalByUnitTime("12:00:00", "12:00:00", "hour", 1) // [{ start: "12:00:00", end: "12:00:00" }]
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 0) // []
  * @example splitIntervalByUnitTime("invalid", "14:00:00", "hour", 1) // []
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1, { maxPieces: 2 }) // [] (3 slices exceed the limit)
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1, { maxPieces: 3 }) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
  */
-export declare function splitIntervalByUnitTime(start: string, end: string, unit: string, amount: number): Array<{
+export declare function splitIntervalByUnitTime(start: string, end: string, unit: string, amount: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/splitIntervalByUnitTime.js

@@ -1,73 +1,110 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
-import { plainTime } from "../../regex/index.js";
-import { isValidTime } from "../validate/index.js";
+import { isValidTime, isValidTimeDurationUnit } from "../validate/index.js";
 import { resolveDurationUnit } from "../../internal/index.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
+import { isExactDurationUnit, minSlicesForSpan, } from "../../internal/splitStep.js";
 /**
  * Split a time interval into sub-intervals of `amount × unit`.
  *
- * - Returns an array of `{ start, end }` records that tile the interval.
+ * - Returns an array of `{ start, end }` records that tile the interval, each record's `end`
+ *   equal to the next record's `start`.
+ * - Every piece is half-open `[start, end)`: a boundary belongs only to the piece that starts
+ *   there, so the pieces share no value and together cover the interval exactly once (the rule
+ *   CORE-6's `splitIntervalAt` uses).
  * - The final sub-interval is trimmed so its `end` never exceeds the original `end`.
+ * - Boundaries lie on the one day between `start` and `end`: `PlainTime` arithmetic wraps at
+ *   midnight, but a step that reaches or passes midnight is past `end`, so that slice is trimmed
+ *   to `end` (`"12:00"` to `"23:00"` by 12 hours is one slice).
  * - Returns `[{ start, end }]` when `start === end` (zero-length interval).
  * - Returns `[]` on invalid input (unparseable start/end, unsupported unit, non-positive amount,
  *   or a unit that has no effect on `PlainTime`, e.g. `"days"`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: a split
+ *   into more slices returns `[]`, decided from the span before stepping. An invalid
+ *   `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param unit duration unit string — `"hours" | "minutes" | "seconds" | "milliseconds" | "microseconds" | "nanoseconds"` (calendar units are ignored by PlainTime and return [])
  * @param amount positive number of units per step
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `{ start, end }` records, or [] on invalid input
  *
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }]
  * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
+ * @example splitIntervalByUnitTime("20:00:00", "23:00:00", "hour", 5) // [{ start: "20:00:00", end: "23:00:00" }] (20:00 + 5 hours is past midnight)
  * @example splitIntervalByUnitTime("12:00:00", "12:00:00", "hour", 1) // [{ start: "12:00:00", end: "12:00:00" }]
  * @example splitIntervalByUnitTime("12:00:00", "14:00:00", "hour", 0) // []
  * @example splitIntervalByUnitTime("invalid", "14:00:00", "hour", 1) // []
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1, { maxPieces: 2 }) // [] (3 slices exceed the limit)
+ * @example splitIntervalByUnitTime("12:00:00", "14:30:00", "hour", 1, { maxPieces: 3 }) // [{ start: "12:00:00", end: "13:00:00" }, { start: "13:00:00", end: "14:00:00" }, { start: "14:00:00", end: "14:30:00" }]
  */
-export function splitIntervalByUnitTime(start, end, unit, amount) {
-    if (typeof start !== "string" || typeof end !== "string") {
-        return [];
-    }
-    if (!plainTime.test(start) || !plainTime.test(end)) {
-        return [];
-    }
-    if (!isValidTime(start) || !isValidTime(end)) {
-        return [];
-    }
-    if (typeof unit !== "string") {
-        return [];
-    }
-    const resolvedUnit = resolveDurationUnit(unit);
-    if (!resolvedUnit) {
-        return [];
-    }
-    if (!Number.isFinite(amount) || amount <= 0) {
-        return [];
-    }
+export function splitIntervalByUnitTime(start, end, unit, amount, options) {
     try {
-        const startVal = Temporal.PlainTime.from(start);
-        const endVal = Temporal.PlainTime.from(end);
-        if (Temporal.PlainTime.compare(startVal, endVal) > 0) {
+        if (typeof start !== "string" || typeof end !== "string") {
             return [];
         }
-        if (Temporal.PlainTime.compare(startVal, endVal) === 0) {
-            return [{ start: startVal.toString(), end: endVal.toString() }];
+        if (!isValidTime(start) || !isValidTime(end)) {
+            return [];
+        }
+        if (typeof unit !== "string") {
+            return [];
         }
-        const result = [];
-        for (let current = startVal; Temporal.PlainTime.compare(current, endVal) < 0;) {
-            const next = current.add({ [resolvedUnit]: amount });
-            if (Temporal.PlainTime.compare(next, current) === 0) {
+        const resolvedUnit = resolveDurationUnit(unit);
+        // An unknown unit is invalid whatever the span, a zero-length one included.
+        if (!isValidTimeDurationUnit(resolvedUnit)) {
+            return [];
+        }
+        if (!Number.isFinite(amount) || amount <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null) {
+            return [];
+        }
+        try {
+            const startVal = Temporal.PlainTime.from(start);
+            const endVal = Temporal.PlainTime.from(end);
+            if (Temporal.PlainTime.compare(startVal, endVal) > 0) {
+                return [];
+            }
+            if (Temporal.PlainTime.compare(startVal, endVal) === 0) {
+                return [{ start: startVal.toString(), end: endVal.toString() }];
+            }
+            // PlainTime.add ignores calendar units, so no step would advance.
+            if (!isExactDurationUnit(resolvedUnit)) {
+                return [];
+            }
+            const spanNs = startVal.until(endVal).total("nanoseconds");
+            const stepNs = Temporal.Duration.from({ [resolvedUnit]: amount }).total("nanoseconds");
+            if (exceedsPieceLimit(minSlicesForSpan(spanNs, resolvedUnit, amount, false), maxPieces)) {
                 return [];
             }
-            const sliceEnd = Temporal.PlainTime.compare(next, endVal) > 0 ? endVal : next;
-            result.push({
-                start: current.toString(),
-                end: sliceEnd.toString(),
-            });
-            current = next;
+            const result = [];
+            // Progress is measured in elapsed nanoseconds, not by comparing times: PlainTime.add wraps at
+            // midnight, and a step that reaches or passes midnight is past `end`, so it ends the split.
+            for (let elapsedNs = stepNs, current = startVal; elapsedNs - stepNs < spanNs; elapsedNs += stepNs) {
+                const sliceEnd = elapsedNs >= spanNs
+                    ? endVal
+                    : current.add({ [resolvedUnit]: amount });
+                if (result.length === maxPieces) {
+                    return [];
+                }
+                result.push({
+                    start: current.toString(),
+                    end: sliceEnd.toString(),
+                });
+                current = sliceEnd;
+            }
+            return result;
+        }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/plain/interval/validate/isValidDateInterval.d.ts

@@ -5,8 +5,10 @@
  * - Both inputs must be ISO 8601 date strings (e.g. `"2024-01-01"`).
  * - Equal `start === end` is valid.
  * - Invalid input, malformed strings, or leap-second strings return `false`.
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Ordering is
  *   calendar-independent, so `start`/`end` may carry different or no calendar tags (D4).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param start ISO 8601 date string (interval start), optionally calendar-annotated
  * @param end ISO 8601 date string (interval end), optionally calendar-annotated
@@ -16,6 +18,6 @@
  * @example isValidDateInterval("2024-01-01", "2024-01-01") // true
  * @example isValidDateInterval("2024-12-31", "2024-01-01") // false
  * @example isValidDateInterval("invalid", "2024-12-31") // false
- * @example isValidDateInterval("5785-01-01[u-ca=hebrew]", "2024-12-31") // true (mixed calendars — ordering is calendar-independent)
+ * @example isValidDateInterval("2024-10-03[u-ca=hebrew]", "2024-12-31") // true (mixed calendars — ordering is calendar-independent)
  */
 export declare function isValidDateInterval(start: string, end: string): boolean;