@northguild/gmt 1.15.0 → 1.16.0

package/dist/plain/interval/intervalDifferenceTime.js

@@ -1,12 +1,20 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainTime } from "../../regex/index.js";
+import { halfOpenDifference } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
  * Return the portion(s) of interval A not covered by interval B.
  *
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Returns `[]` when B fully covers A.
- * - Returns `[{ start, end }]` when B overlaps one edge of A (or equals A).
+ * - Half-open: an interval holds every `t` with `start <= t < end`. A returned piece ends exactly
+ *   where B starts, or starts exactly where B ends, because B's `end` is not in B (CORE-6's
+ *   `subtractIntervals`). No piece is stepped by one unit.
+ * - B touching A (`bStart === aEnd` or `bEnd === aStart`), or empty, removes nothing.
+ * - An empty A (`aStart === aEnd`) has nothing left: returns `[]`. Every returned piece is non-empty.
+ * - Returns `[]` when B fully covers A, which includes B equal to A.
+ * - Returns `[{ start, end }]` when B overlaps exactly one edge of A, leaving one piece.
  * - Returns `[{ start, end }, { start, end }]` when B is fully inside A with gaps on both sides.
+ * - Returns A unchanged when B lies entirely before or after it.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings).
  *
@@ -16,9 +24,10 @@ import { plainTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 time string for the second interval end
  * @returns array of `{ start, end }` records representing A minus B, or `[]` on invalid input
  *
- * @example intervalDifferenceTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // [{ start: "09:00:00", end: "11:59:59" }, { start: "13:00:01", end: "17:00:00" }]
+ * @example intervalDifferenceTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // [{ start: "09:00:00", end: "12:00:00" }, { start: "13:00:00", end: "17:00:00" }]
  * @example intervalDifferenceTime("09:00:00", "17:00:00", "09:00:00", "17:00:00") // []
- * @example intervalDifferenceTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // [{ start: "09:00:00", end: "11:59:59" }]
+ * @example intervalDifferenceTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // [{ start: "09:00:00", end: "12:00:00" }]
+ * @example intervalDifferenceTime("12:00:00", "17:00:00", "09:00:00", "12:00:00") // [{ start: "12:00:00", end: "17:00:00" }] (touching B removes nothing)
  * @example intervalDifferenceTime("invalid", "17:00:00", "12:00:00", "13:00:00") // []
  */
 export function intervalDifferenceTime(aStart, aEnd, bStart, bEnd) {
@@ -28,10 +37,10 @@ export function intervalDifferenceTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return [];
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return [];
     }
     try {
@@ -45,24 +54,10 @@ export function intervalDifferenceTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return [];
         }
-        const result = [];
-        // Left piece: A before B starts
-        if (Temporal.PlainTime.compare(aS, bS) < 0) {
-            const leftEnd = Temporal.PlainTime.compare(aE, bS) < 0
-                ? aE
-                : bS.subtract({ nanoseconds: 1 });
-            if (Temporal.PlainTime.compare(leftEnd, aS) >= 0) {
-                result.push({ start: aS.toString(), end: leftEnd.toString() });
-            }
-        }
-        // Right piece: A after B ends
-        if (Temporal.PlainTime.compare(aE, bE) > 0) {
-            result.push({
-                start: bE.add({ nanoseconds: 1 }).toString(),
-                end: aE.toString(),
-            });
-        }
-        return result;
+        return halfOpenDifference({ start: aS, end: aE }, [{ start: bS, end: bE }], Temporal.PlainTime.compare).map(({ start, end }) => ({
+            start: start.toString(),
+            end: end.toString(),
+        }));
     }
     catch {
         return [];

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

@@ -3,21 +3,29 @@
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original 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).
  * - `PlainDate` has no fractional-day representation, so each internal boundary is rounded to
- *   the nearest whole day — when `totalDays` isn't evenly divisible by `n`, the resulting
- *   sub-intervals differ by at most one day rather than being mathematically exact.
+ *   the nearest whole day (`round(totalDays · i / n)`, computed exactly in `bigint`, an exact half
+ *   rounding up) — when `totalDays` isn't evenly divisible by `n`, the resulting sub-intervals
+ *   differ by at most one day rather than being mathematically exact.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). `start` and `end` must
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). `start` and `end` must
  *   carry the *same* calendar tag (or both be bare ISO); a mismatch returns `[]` (E5 decision
  *   of record D4). Internal boundaries are computed in whole days (calendar-independent), then
  *   re-formatted in the shared calendar.
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @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 n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input / mismatched calendars
  *
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-05", 4) // [{ start: "2024-01-01", end: "2024-01-02" }, { start: "2024-01-02", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-05" }]
@@ -26,8 +34,12 @@
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-01", 3) // [{ start: "2024-01-01", end: "2024-01-01" }, { start: "2024-01-01", end: "2024-01-01" }, { start: "2024-01-01", end: "2024-01-01" }]
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 0) // []
  * @example intervalDivideEquallyDate("invalid", "2024-01-10", 3) // []
+ * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 3, { maxPieces: 3 }) // [{ start: "2024-01-01", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-10" }]
  */
-export declare function intervalDivideEquallyDate(start: string, end: string, n: number): Array<{
+export declare function intervalDivideEquallyDate(start: string, end: string, n: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyDate.js

@@ -1,25 +1,36 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidDateInterval } from "./validate/index.js";
+import { divisionBoundary } from "../../internal/divisionBoundary.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
 /**
  * Split a date interval into `n` equal-length sub-intervals.
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original 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).
  * - `PlainDate` has no fractional-day representation, so each internal boundary is rounded to
- *   the nearest whole day — when `totalDays` isn't evenly divisible by `n`, the resulting
- *   sub-intervals differ by at most one day rather than being mathematically exact.
+ *   the nearest whole day (`round(totalDays · i / n)`, computed exactly in `bigint`, an exact half
+ *   rounding up) — when `totalDays` isn't evenly divisible by `n`, the resulting sub-intervals
+ *   differ by at most one day rather than being mathematically exact.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). `start` and `end` must
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). `start` and `end` must
  *   carry the *same* calendar tag (or both be bare ISO); a mismatch returns `[]` (E5 decision
  *   of record D4). Internal boundaries are computed in whole days (calendar-independent), then
  *   re-formatted in the shared calendar.
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @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 n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input / mismatched calendars
  *
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-05", 4) // [{ start: "2024-01-01", end: "2024-01-02" }, { start: "2024-01-02", end: "2024-01-03" }, { start: "2024-01-03", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-05" }]
@@ -28,43 +39,56 @@ import { isValidDateInterval } from "./validate/index.js";
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-01", 3) // [{ start: "2024-01-01", end: "2024-01-01" }, { start: "2024-01-01", end: "2024-01-01" }, { start: "2024-01-01", end: "2024-01-01" }]
  * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 0) // []
  * @example intervalDivideEquallyDate("invalid", "2024-01-10", 3) // []
+ * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyDate("2024-01-01", "2024-01-10", 3, { maxPieces: 3 }) // [{ start: "2024-01-01", end: "2024-01-04" }, { start: "2024-01-04", end: "2024-01-07" }, { start: "2024-01-07", end: "2024-01-10" }]
  */
-export function intervalDivideEquallyDate(start, end, n) {
-    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
-        return [];
-    }
-    if (!isValidDateInterval(start, end)) {
-        return [];
-    }
-    const calendar = calendarOfAllDateValues([start, end]);
-    if (!calendar) {
-        return [];
-    }
+export function intervalDivideEquallyDate(start, end, n, options) {
     try {
-        const startVal = parseCalendarDateValue(start);
-        const endVal = parseCalendarDateValue(end);
-        if (startVal.equals(endVal)) {
-            return Array.from({ length: n }, () => ({
-                start: formatDateInCalendar(startVal, calendar),
-                end: formatDateInCalendar(endVal, calendar),
-            }));
+        if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null || exceedsPieceLimit(n, maxPieces)) {
+            return [];
+        }
+        if (!isValidDateInterval(start, end)) {
+            return [];
+        }
+        const calendar = calendarOfAllDateValues([start, end]);
+        if (!calendar) {
+            return [];
         }
-        const totalDays = startVal.until(endVal, { largestUnit: "day" }).days;
-        const boundaries = [startVal];
-        for (let i = 1; i < n; i++) {
-            boundaries.push(startVal.add({ days: Math.round((totalDays * i) / n) }));
+        try {
+            const startVal = parseCalendarDateValue(start);
+            const endVal = parseCalendarDateValue(end);
+            if (startVal.equals(endVal)) {
+                return Array.from({ length: n }, () => ({
+                    start: formatDateInCalendar(startVal, calendar),
+                    end: formatDateInCalendar(endVal, calendar),
+                }));
+            }
+            const totalDays = BigInt(startVal.until(endVal, { largestUnit: "day" }).days);
+            const boundaries = [startVal];
+            for (let i = 1; i < n; i++) {
+                boundaries.push(startVal.add({ days: Number(divisionBoundary(totalDays, i, n)) }));
+            }
+            boundaries.push(endVal);
+            const result = [];
+            for (let i = 0; i < boundaries.length - 1; i++) {
+                result.push({
+                    start: formatDateInCalendar(boundaries[i], calendar),
+                    end: formatDateInCalendar(boundaries[i + 1], calendar),
+                });
+            }
+            return result;
         }
-        boundaries.push(endVal);
-        const result = [];
-        for (let i = 0; i < boundaries.length - 1; i++) {
-            result.push({
-                start: formatDateInCalendar(boundaries[i], calendar),
-                end: formatDateInCalendar(boundaries[i + 1], calendar),
-            });
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

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

@@ -3,25 +3,37 @@
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
  *   record's `end` equal to the next record's `start`.
- * - Boundaries are computed from the total elapsed nanoseconds (via `Duration.prototype.total`
- *   with `relativeTo` set to `start`), so the split is exact whenever the total divides evenly
- *   by `n`, and off by at most one nanosecond otherwise.
+ * - 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).
+ * - Each boundary is `start + round((end - start) · i / n)` in integer nanoseconds, computed in
+ *   `bigint`: the split is exact whenever the total divides evenly by `n`, and within half a
+ *   nanosecond of the exact cut otherwise (an exact half rounds up), at any span length — the
+ *   whole PlainDateTime range included.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 1) // [{ start: "2024-01-01T00:00:00", end: "2024-01-04T00:00:00" }]
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 0) // []
  * @example intervalDivideEquallyDateTime("invalid", "2024-01-04T00:00:00", 3) // []
+ * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3, { maxPieces: 3 }) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
  */
-export declare function intervalDivideEquallyDateTime(start: string, end: string, n: number): Array<{
+export declare function intervalDivideEquallyDateTime(start: string, end: string, n: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyDateTime.js

@@ -1,62 +1,98 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidDateTimeInterval } from "./validate/index.js";
+import { divisionBoundary } from "../../internal/divisionBoundary.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
+const NANOSECONDS_PER_DAY = 86400000000000n;
 /**
  * Split a datetime interval into `n` equal-length sub-intervals.
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
  *   record's `end` equal to the next record's `start`.
- * - Boundaries are computed from the total elapsed nanoseconds (via `Duration.prototype.total`
- *   with `relativeTo` set to `start`), so the split is exact whenever the total divides evenly
- *   by `n`, and off by at most one nanosecond otherwise.
+ * - 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).
+ * - Each boundary is `start + round((end - start) · i / n)` in integer nanoseconds, computed in
+ *   `bigint`: the split is exact whenever the total divides evenly by `n`, and within half a
+ *   nanosecond of the exact cut otherwise (an exact half rounds up), at any span length — the
+ *   whole PlainDateTime range included.
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainDateTime string for the interval start
  * @param end ISO PlainDateTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 1) // [{ start: "2024-01-01T00:00:00", end: "2024-01-04T00:00:00" }]
  * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 0) // []
  * @example intervalDivideEquallyDateTime("invalid", "2024-01-04T00:00:00", 3) // []
+ * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyDateTime("2024-01-01T00:00:00", "2024-01-04T00:00:00", 3, { maxPieces: 3 }) // [{ start: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }, { start: "2024-01-02T00:00:00", end: "2024-01-03T00:00:00" }, { start: "2024-01-03T00:00:00", end: "2024-01-04T00:00:00" }]
  */
-export function intervalDivideEquallyDateTime(start, end, n) {
-    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
-        return [];
-    }
-    if (!isValidDateTimeInterval(start, end)) {
-        return [];
-    }
+export function intervalDivideEquallyDateTime(start, end, n, options) {
     try {
-        const startVal = Temporal.PlainDateTime.from(start);
-        const endVal = Temporal.PlainDateTime.from(end);
-        if (startVal.equals(endVal)) {
-            return Array.from({ length: n }, () => ({
-                start: startVal.toString(),
-                end: endVal.toString(),
-            }));
+        if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null || exceedsPieceLimit(n, maxPieces)) {
+            return [];
+        }
+        if (!isValidDateTimeInterval(start, end)) {
+            return [];
         }
-        const totalNs = startVal
-            .until(endVal, { largestUnit: "nanosecond" })
-            .total({ unit: "nanosecond", relativeTo: startVal });
-        const boundaries = [startVal];
-        for (let i = 1; i < n; i++) {
-            boundaries.push(startVal.add({ nanoseconds: Math.round((totalNs * i) / n) }));
+        try {
+            const startVal = Temporal.PlainDateTime.from(start);
+            const endVal = Temporal.PlainDateTime.from(end);
+            if (startVal.equals(endVal)) {
+                return Array.from({ length: n }, () => ({
+                    start: startVal.toString(),
+                    end: endVal.toString(),
+                }));
+            }
+            // A PlainDateTime has no DST, so every day is 86,400 s. The span is read in whole fields
+            // (days, then time below a day), each an exact integer, and summed in bigint.
+            const span = startVal.until(endVal, { largestUnit: "day" });
+            const totalNs = BigInt(span.days) * NANOSECONDS_PER_DAY +
+                BigInt(span.hours) * 3600000000000n +
+                BigInt(span.minutes) * 60000000000n +
+                BigInt(span.seconds) * 1000000000n +
+                BigInt(span.milliseconds) * 1000000n +
+                BigInt(span.microseconds) * 1000n +
+                BigInt(span.nanoseconds);
+            const boundaries = [startVal];
+            for (let i = 1; i < n; i++) {
+                const offsetNs = divisionBoundary(totalNs, i, n);
+                boundaries.push(startVal.add({
+                    days: Number(offsetNs / NANOSECONDS_PER_DAY),
+                    nanoseconds: Number(offsetNs % NANOSECONDS_PER_DAY),
+                }));
+            }
+            boundaries.push(endVal);
+            const result = [];
+            for (let i = 0; i < boundaries.length - 1; i++) {
+                result.push({
+                    start: boundaries[i].toString(),
+                    end: boundaries[i + 1].toString(),
+                });
+            }
+            return result;
         }
-        boundaries.push(endVal);
-        const result = [];
-        for (let i = 0; i < boundaries.length - 1; i++) {
-            result.push({
-                start: boundaries[i].toString(),
-                end: boundaries[i + 1].toString(),
-            });
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

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

@@ -3,17 +3,25 @@
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
  *   record's `end` equal to the next record's `start`.
- * - Time units are fixed-length, so boundaries are computed to nanosecond precision — the split
- *   is exact whenever the total nanoseconds divides evenly by `n`, and off by at most one
- *   nanosecond otherwise.
+ * - 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).
+ * - Time units are fixed-length, so each boundary is `start + round((end - start) · i / n)` in
+ *   integer nanoseconds, computed in `bigint`: the split is exact whenever the total divides
+ *   evenly by `n`, and within half a nanosecond of the exact cut otherwise (an exact half rounds
+ *   up).
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 4) // [{ start: "09:00:00", end: "11:00:00" }, { start: "11:00:00", end: "13:00:00" }, { start: "13:00:00", end: "15:00:00" }, { start: "15:00:00", end: "17:00:00" }]
@@ -21,8 +29,12 @@
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 1) // [{ start: "09:00:00", end: "17:00:00" }]
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 0) // []
  * @example intervalDivideEquallyTime("invalid", "17:00:00", 3) // []
+ * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 3, { maxPieces: 3 }) // [{ start: "09:00:00", end: "11:40:00" }, { start: "11:40:00", end: "14:20:00" }, { start: "14:20:00", end: "17:00:00" }]
  */
-export declare function intervalDivideEquallyTime(start: string, end: string, n: number): Array<{
+export declare function intervalDivideEquallyTime(start: string, end: string, n: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;

package/dist/plain/interval/intervalDivideEquallyTime.js

@@ -1,21 +1,32 @@
+// fallow-ignore-file code-duplication -- cross-family Temporal type clone, by design (rule 5)
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidTimeInterval } from "./validate/index.js";
+import { divisionBoundary } from "../../internal/divisionBoundary.js";
+import { exceedsPieceLimit, resolveMaxPieces } from "../../internal/maxPieces.js";
 /**
  * Split a time interval into `n` equal-length sub-intervals.
  *
  * - Returns an array of `n` `{ start, end }` records that tile the original interval, each
  *   record's `end` equal to the next record's `start`.
- * - Time units are fixed-length, so boundaries are computed to nanosecond precision — the split
- *   is exact whenever the total nanoseconds divides evenly by `n`, and off by at most one
- *   nanosecond otherwise.
+ * - 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).
+ * - Time units are fixed-length, so each boundary is `start + round((end - start) · i / n)` in
+ *   integer nanoseconds, computed in `bigint`: the split is exact whenever the total divides
+ *   evenly by `n`, and within half a nanosecond of the exact cut otherwise (an exact half rounds
+ *   up).
  * - `n === 1` returns the original interval unchanged, as a single-element array.
  * - A zero-length interval (`start === end`) returns `n` identical zero-length sub-intervals.
  * - Returns `[]` when `n` is not a positive integer, or on invalid input (unparseable
  *   start/end, `start > end`).
+ * - `options.maxPieces` (positive safe integer, default `1_000_000`) bounds the output: when `n`
+ *   exceeds it, or exceeds the longest possible array (2^32 - 1), the function returns `[]`
+ *   before building any piece. An invalid `maxPieces` also returns `[]`.
  *
  * @param start ISO PlainTime string for the interval start
  * @param end ISO PlainTime string for the interval end
  * @param n number of equal sub-intervals to produce (positive integer)
+ * @param options optional: `maxPieces` (positive safe integer, default `1_000_000`)
  * @returns array of `n` `{ start, end }` records, or `[]` on invalid input
  *
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 4) // [{ start: "09:00:00", end: "11:00:00" }, { start: "11:00:00", end: "13:00:00" }, { start: "13:00:00", end: "15:00:00" }, { start: "15:00:00", end: "17:00:00" }]
@@ -23,41 +34,57 @@ import { isValidTimeInterval } from "./validate/index.js";
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 1) // [{ start: "09:00:00", end: "17:00:00" }]
  * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 0) // []
  * @example intervalDivideEquallyTime("invalid", "17:00:00", 3) // []
+ * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 3, { maxPieces: 2 }) // [] (3 pieces exceed the limit)
+ * @example intervalDivideEquallyTime("09:00:00", "17:00:00", 3, { maxPieces: 3 }) // [{ start: "09:00:00", end: "11:40:00" }, { start: "11:40:00", end: "14:20:00" }, { start: "14:20:00", end: "17:00:00" }]
  */
-export function intervalDivideEquallyTime(start, end, n) {
-    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
-        return [];
-    }
-    if (!isValidTimeInterval(start, end)) {
-        return [];
-    }
+export function intervalDivideEquallyTime(start, end, n, options) {
     try {
-        const startVal = Temporal.PlainTime.from(start);
-        const endVal = Temporal.PlainTime.from(end);
-        if (startVal.equals(endVal)) {
-            return Array.from({ length: n }, () => ({
-                start: startVal.toString(),
-                end: endVal.toString(),
-            }));
+        if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+            return [];
+        }
+        const maxPieces = resolveMaxPieces(options);
+        if (maxPieces === null || exceedsPieceLimit(n, maxPieces)) {
+            return [];
+        }
+        if (!isValidTimeInterval(start, end)) {
+            return [];
         }
-        const totalNs = startVal
-            .until(endVal, { largestUnit: "nanosecond" })
-            .total("nanosecond");
-        const boundaries = [startVal];
-        for (let i = 1; i < n; i++) {
-            boundaries.push(startVal.add({ nanoseconds: Math.round((totalNs * i) / n) }));
+        try {
+            const startVal = Temporal.PlainTime.from(start);
+            const endVal = Temporal.PlainTime.from(end);
+            if (startVal.equals(endVal)) {
+                return Array.from({ length: n }, () => ({
+                    start: startVal.toString(),
+                    end: endVal.toString(),
+                }));
+            }
+            // Under a day of nanoseconds (< 2^53), so the total itself is exact; the quotient is not.
+            const totalNs = BigInt(startVal
+                .until(endVal, { largestUnit: "nanosecond" })
+                .total("nanosecond"));
+            const boundaries = [startVal];
+            for (let i = 1; i < n; i++) {
+                boundaries.push(startVal.add({
+                    nanoseconds: Number(divisionBoundary(totalNs, i, n)),
+                }));
+            }
+            boundaries.push(endVal);
+            const result = [];
+            for (let i = 0; i < boundaries.length - 1; i++) {
+                result.push({
+                    start: boundaries[i].toString(),
+                    end: boundaries[i + 1].toString(),
+                });
+            }
+            return result;
         }
-        boundaries.push(endVal);
-        const result = [];
-        for (let i = 0; i < boundaries.length - 1; i++) {
-            result.push({
-                start: boundaries[i].toString(),
-                end: boundaries[i + 1].toString(),
-            });
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }