@northguild/gmt 1.15.0 → 1.17.0

package/dist/utc/interval/intervalXorAllUtc.js

@@ -1,14 +1,17 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { halfOpenXor } from "../../internal/index.js";
 import { isValidUtcInterval } from "./validate/index.js";
 /**
  * Return the symmetric difference across a list of UTC intervals — the set of instants covered
  * by an odd number of the input intervals.
  *
  * - List-form generalization of `intervalXorUtc`, which is pairwise only.
- * - Implemented as a coverage sweep: each interval contributes a `+1` at its start and a `-1`
- *   one nanosecond after its end; the result is every maximal run where the running coverage
- *   count is odd. For two intervals this reduces to exactly `intervalXorUtc`'s pairwise result.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered an odd number of times, computed as a coverage-parity sweep over the start and
+ *   end boundaries. Runs end exactly at a boundary; no boundary is ever stepped by one unit, so
+ *   an interval may end on the type's last value without overflow or midnight wrap.
+ * - Touching odd runs join into one run; an empty interval (`start === end`) contributes nothing.
+ *   For two intervals this is exactly `intervalXorUtc`'s pairwise result.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list, and `[]` when every instant is covered an even number of
  *   times (e.g. two identical intervals cancel out).
@@ -19,63 +22,38 @@ import { isValidUtcInterval } from "./validate/index.js";
  * @param intervals array of `{ start, end }` records
  * @returns array of `{ start, end }` records covered an odd number of times, or `[]` on invalid input
  *
- * @example intervalXorAllUtc([{ start: "2024-01-01T00:00:00Z", end: "2024-01-10T00:00:00Z" }, { start: "2024-01-05T00:00:00Z", end: "2024-01-15T00:00:00Z" }]) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-04T23:59:59.999999999Z" }, { start: "2024-01-10T00:00:00.000000001Z", end: "2024-01-15T00:00:00Z" }]
+ * @example intervalXorAllUtc([{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T13:00:00Z" }, { start: "2024-01-01T12:00:00Z", end: "2024-01-01T17:00:00Z" }]) // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T13:00:00Z", end: "2024-01-01T17:00:00Z" }]
  * @example intervalXorAllUtc([]) // []
  */
 export function intervalXorAllUtc(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        typeof interval.start === "string" &&
-        typeof interval.end === "string" &&
-        !isLeapSecond(interval.start) &&
-        !isLeapSecond(interval.end) &&
-        isValidUtcInterval(interval.start, interval.end))) {
-        return [];
-    }
     try {
-        const events = [];
-        for (const interval of intervals) {
-            const start = Temporal.Instant.from(interval.start);
-            const closesAfter = Temporal.Instant.from(interval.end).add({
-                nanoseconds: 1,
-            });
-            events.push({ point: start, delta: 1 });
-            events.push({ point: closesAfter, delta: -1 });
+        if (!Array.isArray(intervals) || intervals.length === 0) {
+            return [];
+        }
+        if (!intervals.every((interval) => interval &&
+            typeof interval === "object" &&
+            typeof interval.start === "string" &&
+            typeof interval.end === "string" &&
+            isValidUtcInterval(interval.start, interval.end))) {
+            return [];
         }
-        events.sort((a, b) => Temporal.Instant.compare(a.point, b.point));
-        const grouped = [];
-        for (const event of events) {
-            const last = grouped[grouped.length - 1];
-            if (last && last.point.equals(event.point)) {
-                last.delta += event.delta;
-            }
-            else {
-                grouped.push(event);
-            }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: Temporal.Instant.from(interval.start),
+                end: Temporal.Instant.from(interval.end),
+            }));
+            return halfOpenXor(parsed, Temporal.Instant.compare).map(({ start, end }) => ({
+                start: start.toString(),
+                end: end.toString(),
+            }));
         }
-        const result = [];
-        let coverage = 0;
-        let runStart = null;
-        for (const group of grouped) {
-            const previousCoverage = coverage;
-            coverage += group.delta;
-            if (previousCoverage % 2 === 0 && coverage % 2 === 1) {
-                runStart = group.point;
-            }
-            else if (previousCoverage % 2 === 1 && coverage % 2 === 0 && runStart) {
-                result.push({
-                    start: runStart.toString(),
-                    end: group.point.subtract({ nanoseconds: 1 }).toString(),
-                });
-                runStart = null;
-            }
+        catch {
+            return [];
         }
-        return result;
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/utc/interval/intervalXorUtc.d.ts

@@ -1,10 +1,12 @@
 /**
  * Return the symmetric difference of two UTC intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.Instant.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings, leap seconds).
  *
@@ -14,8 +16,8 @@
  * @param bEnd ISO 8601 UTC datetime string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-04-01T11:00:00Z", "2024-12-31T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-03-31T17:00:00Z" }, { start: "2024-06-30T12:00:01Z", end: "2024-12-31T17:00:00Z" }]
- * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z", "2024-04-01T11:00:00Z", "2024-06-30T12:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-03-31T17:00:00Z" }, { start: "2024-06-30T12:00:01Z", end: "2024-12-31T17:00:00Z" }]
+ * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-01-01T13:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T13:00:00Z", end: "2024-01-01T17:00:00Z" }]
+ * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T17:00:00Z" }] (touching)
  * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z", "2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z") // []
  * @example intervalXorUtc("invalid", "2024-06-30T12:00:00Z", "2024-07-01T13:00:00Z", "2024-12-31T17:00:00Z") // []
  */

package/dist/utc/interval/intervalXorUtc.js

@@ -1,13 +1,16 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
-import { utcDateTime } from "../../regex/utc-date-time.js";
+import { halfOpenXor } from "../../internal/index.js";
+import { isValidUtc } from "../validate/index.js";
 /**
  * Return the symmetric difference of two UTC intervals — time covered by exactly one interval.
  *
- * - Uses `Temporal.Instant.compare` for comparison.
- * - Returns `[]` when intervals are identical or both invalid.
- * - Returns `[{ start, end }]` when one interval fully contains the other.
- * - Returns `[{ start, end }, { start, end }]` when intervals partially overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The result is every maximal
+ *   run covered by exactly one of the two intervals, sorted by start — the same set as
+ *   CORE-6's `mergeIntervals([...subtractIntervals(a, [b]), ...subtractIntervals(b, [a])])`.
+ * - Pieces end exactly where the other interval starts; no piece is stepped by one nanosecond.
+ * - Touching intervals (`aEnd === bStart`) share nothing, so they return one combined run.
+ * - Returns `[]` when the intervals are identical. An empty interval contributes nothing.
  * - Returns `[]` if either interval is invalid (`start > end`).
  * - Returns `[]` on invalid input (wrong type, malformed strings, leap seconds).
  *
@@ -17,8 +20,8 @@ import { utcDateTime } from "../../regex/utc-date-time.js";
  * @param bEnd ISO 8601 UTC datetime string for the second interval end
  * @returns array of `{ start, end }` records representing the symmetric difference, or `[]` on invalid input
  *
- * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-06-30T12:00:00Z", "2024-04-01T11:00:00Z", "2024-12-31T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-03-31T17:00:00Z" }, { start: "2024-06-30T12:00:01Z", end: "2024-12-31T17:00:00Z" }]
- * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z", "2024-04-01T11:00:00Z", "2024-06-30T12:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-03-31T17:00:00Z" }, { start: "2024-06-30T12:00:01Z", end: "2024-12-31T17:00:00Z" }]
+ * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-01-01T13:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T13:00:00Z", end: "2024-01-01T17:00:00Z" }]
+ * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T17:00:00Z" }] (touching)
  * @example intervalXorUtc("2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z", "2024-01-01T09:00:00Z", "2024-12-31T17:00:00Z") // []
  * @example intervalXorUtc("invalid", "2024-06-30T12:00:00Z", "2024-07-01T13:00:00Z", "2024-12-31T17:00:00Z") // []
  */
@@ -29,16 +32,10 @@ export function intervalXorUtc(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return [];
     }
-    if (!utcDateTime.test(aStart) ||
-        !utcDateTime.test(aEnd) ||
-        !utcDateTime.test(bStart) ||
-        !utcDateTime.test(bEnd)) {
-        return [];
-    }
-    if (isLeapSecond(aStart) ||
-        isLeapSecond(aEnd) ||
-        isLeapSecond(bStart) ||
-        isLeapSecond(bEnd)) {
+    if (!isValidUtc(aStart) ||
+        !isValidUtc(aEnd) ||
+        !isValidUtc(bStart) ||
+        !isValidUtc(bEnd)) {
         return [];
     }
     try {
@@ -52,44 +49,13 @@ export function intervalXorUtc(aStart, aEnd, bStart, bEnd) {
         if (Temporal.Instant.compare(bS, bE) > 0) {
             return [];
         }
-        const result = [];
-        // If intervals don't overlap, return both as-is
-        if (Temporal.Instant.compare(aE, bS) < 0 ||
-            Temporal.Instant.compare(bE, aS) < 0) {
-            return [
-                { start: aS.toString(), end: aE.toString() },
-                { start: bS.toString(), end: bE.toString() },
-            ];
-        }
-        // Left piece: A before B starts
-        if (Temporal.Instant.compare(aS, bS) < 0) {
-            result.push({
-                start: aS.toString(),
-                end: bS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: A after B ends
-        if (Temporal.Instant.compare(aE, bE) > 0) {
-            result.push({
-                start: bE.add({ nanoseconds: 1 }).toString(),
-                end: aE.toString(),
-            });
-        }
-        // Left piece: B before A starts
-        if (Temporal.Instant.compare(bS, aS) < 0) {
-            result.push({
-                start: bS.toString(),
-                end: aS.subtract({ nanoseconds: 1 }).toString(),
-            });
-        }
-        // Right piece: B after A ends
-        if (Temporal.Instant.compare(bE, aE) > 0) {
-            result.push({
-                start: aE.add({ nanoseconds: 1 }).toString(),
-                end: bE.toString(),
-            });
-        }
-        return result;
+        return halfOpenXor([
+            { start: aS, end: aE },
+            { start: bS, end: bE },
+        ], Temporal.Instant.compare).map(({ start, end }) => ({
+            start: start.toString(),
+            end: end.toString(),
+        }));
     }
     catch {
         return [];

package/dist/utc/interval/intervalsOverlapUtc.d.ts

@@ -1,20 +1,26 @@
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open UTC intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one instant.
  *
- * - Uses `Temporal.Instant.compare` for comparison (same instant semantics).
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
+ * - Half-open: an interval holds every instant `t` with `start <= t < end`, so `end` itself is not
+ *   in it. The test is `aStart < bEnd && bStart < aEnd`.
+ * - Delegates to CORE-6's `intervalsOverlap` once the arguments pass the UTC-string gate, so the
+ *   answer always equals `intervalsOverlap({ start: aStart, end: aEnd }, { start: bStart, end: bEnd })`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no instant and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Returns `false` if either interval is invalid (`start > end`).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, non-`Z` strings, malformed strings, leap seconds).
  *
  * @param aStart ISO 8601 UTC datetime string for the first interval start
- * @param aEnd ISO 8601 UTC datetime string for the first interval end
+ * @param aEnd ISO 8601 UTC datetime string for the first interval end (excluded)
  * @param bStart ISO 8601 UTC datetime string for the second interval start
- * @param bEnd ISO 8601 UTC datetime string for the second interval end
+ * @param bEnd ISO 8601 UTC datetime string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-04-01T00:00:00Z", "2024-12-31T23:59:59Z") // true
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-07-01T00:00:00Z", "2024-12-31T23:59:59Z") // false (adjacent)
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-07-02T00:00:00Z", "2024-12-31T23:59:59Z") // false (disjoint)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T13:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // true
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // false (touching)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00.000000001Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // true (1 ns shared)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z") // false (empty interval at the end)
  * @example intervalsOverlapUtc("invalid", "2024-06-30T23:59:59Z", "2024-04-01T00:00:00Z", "2024-12-31T23:59:59Z") // false
  */
 export declare function intervalsOverlapUtc(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/utc/interval/intervalsOverlapUtc.js

@@ -1,23 +1,29 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
-import { utcDateTime } from "../../regex/utc-date-time.js";
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
+import { intervalsOverlap } from "../../interval/compare/index.js";
+import { isValidUtc } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open UTC intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one instant.
  *
- * - Uses `Temporal.Instant.compare` for comparison (same instant semantics).
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
+ * - Half-open: an interval holds every instant `t` with `start <= t < end`, so `end` itself is not
+ *   in it. The test is `aStart < bEnd && bStart < aEnd`.
+ * - Delegates to CORE-6's `intervalsOverlap` once the arguments pass the UTC-string gate, so the
+ *   answer always equals `intervalsOverlap({ start: aStart, end: aEnd }, { start: bStart, end: bEnd })`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no instant and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Returns `false` if either interval is invalid (`start > end`).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, non-`Z` strings, malformed strings, leap seconds).
  *
  * @param aStart ISO 8601 UTC datetime string for the first interval start
- * @param aEnd ISO 8601 UTC datetime string for the first interval end
+ * @param aEnd ISO 8601 UTC datetime string for the first interval end (excluded)
  * @param bStart ISO 8601 UTC datetime string for the second interval start
- * @param bEnd ISO 8601 UTC datetime string for the second interval end
+ * @param bEnd ISO 8601 UTC datetime string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-04-01T00:00:00Z", "2024-12-31T23:59:59Z") // true
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-07-01T00:00:00Z", "2024-12-31T23:59:59Z") // false (adjacent)
- * @example intervalsOverlapUtc("2024-01-01T00:00:00Z", "2024-06-30T23:59:59Z", "2024-07-02T00:00:00Z", "2024-12-31T23:59:59Z") // false (disjoint)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T13:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // true
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // false (touching)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00.000000001Z", "2024-01-01T12:00:00Z", "2024-01-01T17:00:00Z") // true (1 ns shared)
+ * @example intervalsOverlapUtc("2024-01-01T09:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z", "2024-01-01T12:00:00Z") // false (empty interval at the end)
  * @example intervalsOverlapUtc("invalid", "2024-06-30T23:59:59Z", "2024-04-01T00:00:00Z", "2024-12-31T23:59:59Z") // false
  */
 export function intervalsOverlapUtc(aStart, aEnd, bStart, bEnd) {
@@ -27,33 +33,11 @@ export function intervalsOverlapUtc(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!utcDateTime.test(aStart) ||
-        !utcDateTime.test(aEnd) ||
-        !utcDateTime.test(bStart) ||
-        !utcDateTime.test(bEnd)) {
-        return false;
-    }
-    if (isLeapSecond(aStart) ||
-        isLeapSecond(aEnd) ||
-        isLeapSecond(bStart) ||
-        isLeapSecond(bEnd)) {
-        return false;
-    }
-    try {
-        const aSI = Temporal.Instant.from(aStart);
-        const aEI = Temporal.Instant.from(aEnd);
-        const bSI = Temporal.Instant.from(bStart);
-        const bEI = Temporal.Instant.from(bEnd);
-        if (Temporal.Instant.compare(aSI, aEI) > 0) {
-            return false;
-        }
-        if (Temporal.Instant.compare(bSI, bEI) > 0) {
-            return false;
-        }
-        return (Temporal.Instant.compare(aEI, bSI) >= 0 &&
-            Temporal.Instant.compare(bEI, aSI) >= 0);
-    }
-    catch {
+    if (!isValidUtc(aStart) ||
+        !isValidUtc(aEnd) ||
+        !isValidUtc(bStart) ||
+        !isValidUtc(bEnd)) {
         return false;
     }
+    return intervalsOverlap({ start: aStart, end: aEnd }, { start: bStart, end: bEnd });
 }

package/dist/utc/interval/mergeIntervalsUtc.d.ts

@@ -2,8 +2,13 @@
  * Collapse a list of UTC intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionUtc`, which is pairwise only.
- * - Intervals are merged when they overlap or share an instant exactly (adjacent intervals
- *   ARE merged).
+ * - Half-open: an interval holds every `t` with `start <= t < end`. Overlapping intervals and
+ *   touching intervals (`aEnd === bStart`) join into one run; any gap, even one unit, keeps them
+ *   apart (CORE-6's `mergeIntervals`).
+ * - An empty interval (`start === end`) holds nothing: it is absorbed by a run it touches or lies
+ *   in, and dropped otherwise, so every returned interval is non-empty.
+ * - Delegates to CORE-6's `mergeIntervals` once every element passes the UTC-string gate, and
+ *   re-serialises the runs to canonical `Z` strings.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list.
  * - Returns `[]` when `intervals` is not an array, when any element is not a
@@ -14,6 +19,8 @@
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
  * @example mergeIntervalsUtc([{ start: "2024-01-01T00:00:00Z", end: "2024-01-10T00:00:00Z" }, { start: "2024-01-05T00:00:00Z", end: "2024-01-15T00:00:00Z" }]) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-15T00:00:00Z" }]
+ * @example mergeIntervalsUtc([{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T12:00:00Z", end: "2024-01-01T17:00:00Z" }]) // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T17:00:00Z" }] (touching)
+ * @example mergeIntervalsUtc([{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T09:00:00Z" }]) // [] (empty interval)
  * @example mergeIntervalsUtc([]) // []
  */
 export declare function mergeIntervalsUtc(intervals: Array<{

package/dist/utc/interval/mergeIntervalsUtc.js

@@ -1,12 +1,17 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { isLeapSecond } from "../../plain/validate/isLeapSecond.js";
+import { canonicalInstantIntervals } from "../../internal/index.js";
+import { mergeIntervals } from "../../interval/calculate/index.js";
 import { isValidUtcInterval } from "./validate/index.js";
 /**
  * Collapse a list of UTC intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionUtc`, which is pairwise only.
- * - Intervals are merged when they overlap or share an instant exactly (adjacent intervals
- *   ARE merged).
+ * - Half-open: an interval holds every `t` with `start <= t < end`. Overlapping intervals and
+ *   touching intervals (`aEnd === bStart`) join into one run; any gap, even one unit, keeps them
+ *   apart (CORE-6's `mergeIntervals`).
+ * - An empty interval (`start === end`) holds nothing: it is absorbed by a run it touches or lies
+ *   in, and dropped otherwise, so every returned interval is non-empty.
+ * - Delegates to CORE-6's `mergeIntervals` once every element passes the UTC-string gate, and
+ *   re-serialises the runs to canonical `Z` strings.
  * - Order of the input list does not matter; the result is sorted by start.
  * - Returns `[]` for an empty list.
  * - Returns `[]` when `intervals` is not an array, when any element is not a
@@ -17,45 +22,27 @@ import { isValidUtcInterval } from "./validate/index.js";
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
  * @example mergeIntervalsUtc([{ start: "2024-01-01T00:00:00Z", end: "2024-01-10T00:00:00Z" }, { start: "2024-01-05T00:00:00Z", end: "2024-01-15T00:00:00Z" }]) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-15T00:00:00Z" }]
+ * @example mergeIntervalsUtc([{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T12:00:00Z", end: "2024-01-01T17:00:00Z" }]) // [{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T17:00:00Z" }] (touching)
+ * @example mergeIntervalsUtc([{ start: "2024-01-01T09:00:00Z", end: "2024-01-01T09:00:00Z" }]) // [] (empty interval)
  * @example mergeIntervalsUtc([]) // []
  */
 export function mergeIntervalsUtc(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        typeof interval.start === "string" &&
-        typeof interval.end === "string" &&
-        !isLeapSecond(interval.start) &&
-        !isLeapSecond(interval.end) &&
-        isValidUtcInterval(interval.start, interval.end))) {
-        return [];
-    }
     try {
-        const parsed = intervals.map((interval) => ({
-            start: Temporal.Instant.from(interval.start),
-            end: Temporal.Instant.from(interval.end),
-        }));
-        parsed.sort((a, b) => Temporal.Instant.compare(a.start, b.start));
-        const merged = [];
-        for (const interval of parsed) {
-            const last = merged[merged.length - 1];
-            if (last && Temporal.Instant.compare(interval.start, last.end) <= 0) {
-                if (Temporal.Instant.compare(interval.end, last.end) > 0) {
-                    last.end = interval.end;
-                }
-            }
-            else {
-                merged.push({ start: interval.start, end: interval.end });
-            }
+        if (!Array.isArray(intervals) || intervals.length === 0) {
+            return [];
+        }
+        if (!intervals.every((interval) => interval &&
+            typeof interval === "object" &&
+            typeof interval.start === "string" &&
+            typeof interval.end === "string" &&
+            isValidUtcInterval(interval.start, interval.end))) {
+            return [];
         }
-        return merged.map((interval) => ({
-            start: interval.start.toString(),
-            end: interval.end.toString(),
-        }));
+        return canonicalInstantIntervals(mergeIntervals(intervals)) ?? [];
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

package/dist/utc/interval/splitIntervalByUnitUtc.d.ts

@@ -1,16 +1,32 @@
 /**
  * Split a UTC 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 instant 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,
  *   leap-second strings).
+ * - `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 UTC datetime string for the interval start
  * @param end ISO UTC datetime 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 splitIntervalByUnitUtc("2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", "hour", 6) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T06:00:00Z" }, { start: "2024-01-01T06:00:00Z", end: "2024-01-01T12:00:00Z" }, { start: "2024-01-01T12:00:00Z", end: "2024-01-01T18:00:00Z" }, { start: "2024-01-01T18:00:00Z", end: "2024-01-02T00:00:00Z" }]
@@ -18,8 +34,13 @@
  * @example splitIntervalByUnitUtc("2024-01-01T00:00:00Z", "2024-01-01T00:00:00Z", "hour", 1) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T00:00:00Z" }]
  * @example splitIntervalByUnitUtc("2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", "hour", 0) // []
  * @example splitIntervalByUnitUtc("invalid", "2024-01-02T00:00:00Z", "hour", 1) // []
+ * @example splitIntervalByUnitUtc("2024-01-01T00:00:00Z", "2024-01-01T01:30:00Z", "hour", 1, { maxPieces: 1 }) // [] (2 slices exceed the limit)
+ * @example splitIntervalByUnitUtc("2024-01-01T00:00:00Z", "2024-01-01T01:30:00Z", "hour", 1, { maxPieces: 2 }) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T01:00:00Z" }, { start: "2024-01-01T01:00:00Z", end: "2024-01-01T01:30:00Z" }]
+ * @example splitIntervalByUnitUtc("+275760-09-12T23:00:00Z", "+275760-09-13T00:00:00Z", "hour", 2) // [{ start: "+275760-09-12T23:00:00Z", end: "+275760-09-13T00:00:00Z" }] (the step past the last instant is trimmed to `end`)
  */
-export declare function splitIntervalByUnitUtc(start: string, end: string, unit: string, amount: number): Array<{
+export declare function splitIntervalByUnitUtc(start: string, end: string, unit: string, amount: number, options?: {
+    maxPieces?: number;
+}): Array<{
     start: string;
     end: string;
 }>;