@northguild/gmt 1.14.2 → 1.16.0

package/dist/plain/interval/intervalsOverlapDate.js

@@ -1,26 +1,34 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { parseCalendarDateValue } from "../../internal/index.js";
+import { halfOpenOverlap, parseCalendarDateValue } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open date intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one day.
  *
+ * - Half-open: an interval holds every date `d` with `start <= d < end`, so `end` itself is not
+ *   in it (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no day and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
- * - 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 arguments 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 aStart ISO 8601 date string for the first interval start, optionally calendar-annotated
- * @param aEnd ISO 8601 date string for the first interval end, optionally calendar-annotated
+ * @param aEnd ISO 8601 date string for the first interval end (excluded), optionally calendar-annotated
  * @param bStart ISO 8601 date string for the second interval start, optionally calendar-annotated
- * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
+ * @param bEnd ISO 8601 date string for the second interval end (excluded), optionally calendar-annotated
  * @returns true if intervals overlap, or false on invalid input
  *
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // true
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // false (adjacent)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // false (touching: A ends before 06-30)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-29", "2024-07-01") // true (both hold 06-29)
  * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-07-02", "2024-12-31") // false (disjoint)
- * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-02-01", "2024-03-01") // true (partial)
+ * @example intervalsOverlapDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-06-30") // false (empty interval at the end)
  * @example intervalsOverlapDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // false
  */
 export function intervalsOverlapDate(aStart, aEnd, bStart, bEnd) {
@@ -47,8 +55,7 @@ export function intervalsOverlapDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDate.compare(aE, bS) >= 0 &&
-            Temporal.PlainDate.compare(bE, aS) >= 0);
+        return halfOpenOverlap({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

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

package/dist/plain/interval/intervalsOverlapDateTime.js

@@ -1,22 +1,29 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
+import { halfOpenOverlap } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open datetime intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one moment.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so `end` itself is not in it
+ *   (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no moment and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param aStart ISO 8601 datetime string for the first interval start
- * @param aEnd ISO 8601 datetime string for the first interval end
+ * @param aEnd ISO 8601 datetime string for the first interval end (excluded)
  * @param bStart ISO 8601 datetime string for the second interval start
- * @param bEnd ISO 8601 datetime string for the second interval end
+ * @param bEnd ISO 8601 datetime string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // true
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // false (adjacent)
- * @example intervalsOverlapDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-02T00:00:00", "2024-12-31T23:59:59") // false (disjoint)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // false (touching)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // true (empty interval strictly inside)
+ * @example intervalsOverlapDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // false (empty interval at the end)
  * @example intervalsOverlapDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // false
  */
 export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
@@ -26,10 +33,10 @@ export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return false;
     }
     try {
@@ -43,8 +50,7 @@ export function intervalsOverlapDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDateTime.compare(aE, bS) >= 0 &&
-            Temporal.PlainDateTime.compare(bE, aS) >= 0);
+        return halfOpenOverlap({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;

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

@@ -1,19 +1,24 @@
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one clock time.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so `end` itself is not in it
+ *   (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no time and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
+ * - PlainTime has no day rollover: an interval never wraps past midnight.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param aStart ISO 8601 time string for the first interval start
- * @param aEnd ISO 8601 time string for the first interval end
+ * @param aEnd ISO 8601 time string for the first interval end (excluded)
  * @param bStart ISO 8601 time string for the second interval start
- * @param bEnd ISO 8601 time string for the second interval end
+ * @param bEnd ISO 8601 time string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // true
- * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (adjacent)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (touching)
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // false (disjoint)
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // true (contained)
  * @example intervalsOverlapTime("invalid", "17:00:00", "12:00:00", "18:00:00") // false

package/dist/plain/interval/intervalsOverlapTime.js

@@ -1,21 +1,28 @@
+// 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 { halfOpenOverlap } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
- * Return true when intervals `[aStart, aEnd]` and `[bStart, bEnd]` share at least one instant.
+ * Return true when the half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` share at
+ * least one clock time.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so `end` itself is not in it
+ *   (the rule CORE-6's `intervalsOverlap` uses). The test is `aStart < bEnd && bStart < aEnd`.
+ * - Touching intervals (`aEnd` equal to `bStart`) share no time and do not overlap.
+ * - An empty interval (`start === end`) overlaps only an interval it lies strictly inside.
+ * - PlainTime has no day rollover: an interval never wraps past midnight.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) do NOT overlap — returns `false`.
  * - Returns `false` if either interval is invalid (`start > end`).
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param aStart ISO 8601 time string for the first interval start
- * @param aEnd ISO 8601 time string for the first interval end
+ * @param aEnd ISO 8601 time string for the first interval end (excluded)
  * @param bStart ISO 8601 time string for the second interval start
- * @param bEnd ISO 8601 time string for the second interval end
+ * @param bEnd ISO 8601 time string for the second interval end (excluded)
  * @returns true if intervals overlap, or false on invalid input
  *
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // true
- * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (adjacent)
+ * @example intervalsOverlapTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // false (touching)
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // false (disjoint)
  * @example intervalsOverlapTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // true (contained)
  * @example intervalsOverlapTime("invalid", "17:00:00", "12:00:00", "18:00:00") // false
@@ -27,10 +34,10 @@ export function intervalsOverlapTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return false;
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return false;
     }
     try {
@@ -44,8 +51,7 @@ export function intervalsOverlapTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainTime.compare(aE, bS) >= 0 &&
-            Temporal.PlainTime.compare(bE, aS) >= 0);
+        return halfOpenOverlap({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
     }
     catch {
         return false;

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

@@ -2,14 +2,17 @@
  * Collapse a list of date intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionDate`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals,
- *   e.g. `aEnd === bStart`, ARE merged — same rule as `intervalUnionDate`).
+ * - 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.
  * - 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
  *   `{ start, end }` record of valid ISO PlainDate strings, or when any element has
  *   `start > end`.
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
  *   date *values*, every `start`/`end` across the whole list must carry the *same* calendar tag
  *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4).
  *
@@ -17,8 +20,9 @@
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input / mismatched calendars
  *
  * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-15" }]
- * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (adjacent, merged)
- * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }] (disjoint)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (touching)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-06", end: "2024-01-10" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-06", end: "2024-01-10" }] (01-05 is in neither)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-01" }]) // [] (empty interval)
  * @example mergeIntervalsDate([]) // []
  * @example mergeIntervalsDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
  */

package/dist/plain/interval/mergeIntervalsDate.js

@@ -1,18 +1,21 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
+import { calendarOfAllDateValues, formatDateInCalendar, halfOpenMerge, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidDateInterval } from "./validate/index.js";
 /**
  * Collapse a list of date intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionDate`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint exactly (adjacent intervals,
- *   e.g. `aEnd === bStart`, ARE merged — same rule as `intervalUnionDate`).
+ * - 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.
  * - 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
  *   `{ start, end }` record of valid ISO PlainDate strings, or when any element has
  *   `start > end`.
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is
  *   date *values*, every `start`/`end` across the whole list must carry the *same* calendar tag
  *   (or all be bare ISO); any mismatch returns `[]` (E5 decision of record D4).
  *
@@ -20,48 +23,44 @@ import { isValidDateInterval } from "./validate/index.js";
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input / mismatched calendars
  *
  * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-05", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-15" }]
- * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (adjacent, merged)
- * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-10", end: "2024-01-15" }] (disjoint)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-10" }, { start: "2024-01-10", end: "2024-01-20" }]) // [{ start: "2024-01-01", end: "2024-01-20" }] (touching)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-06", end: "2024-01-10" }]) // [{ start: "2024-01-01", end: "2024-01-05" }, { start: "2024-01-06", end: "2024-01-10" }] (01-05 is in neither)
+ * @example mergeIntervalsDate([{ start: "2024-01-01", end: "2024-01-01" }]) // [] (empty interval)
  * @example mergeIntervalsDate([]) // []
  * @example mergeIntervalsDate([{ start: "2024-01-10", end: "2024-01-01" }]) // []
  */
 export function mergeIntervalsDate(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        isValidDateInterval(interval.start, interval.end))) {
-        return [];
-    }
-    const calendar = calendarOfAllDateValues(intervals.flatMap((interval) => [interval.start, interval.end]));
-    if (!calendar) {
-        return [];
-    }
     try {
-        const parsed = intervals.map((interval) => ({
-            start: parseCalendarDateValue(interval.start),
-            end: parseCalendarDateValue(interval.end),
-        }));
-        parsed.sort((a, b) => Temporal.PlainDate.compare(a.start, b.start));
-        const merged = [];
-        for (const interval of parsed) {
-            const last = merged[merged.length - 1];
-            if (last && Temporal.PlainDate.compare(interval.start, last.end) <= 0) {
-                if (Temporal.PlainDate.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" &&
+            isValidDateInterval(interval.start, interval.end))) {
+            return [];
+        }
+        const calendar = calendarOfAllDateValues(intervals.flatMap((interval) => [interval.start, interval.end]));
+        if (!calendar) {
+            return [];
+        }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: parseCalendarDateValue(interval.start),
+                end: parseCalendarDateValue(interval.end),
+            }));
+            const merged = halfOpenMerge(parsed, Temporal.PlainDate.compare);
+            return merged.map((interval) => ({
+                start: formatDateInCalendar(interval.start, calendar),
+                end: formatDateInCalendar(interval.end, calendar),
+            }));
+        }
+        catch {
+            return [];
         }
-        return merged.map((interval) => ({
-            start: formatDateInCalendar(interval.start, calendar),
-            end: formatDateInCalendar(interval.end, calendar),
-        }));
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

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

@@ -2,8 +2,11 @@
  * Collapse a list of datetime intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionDateTime`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint 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.
  * - 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
@@ -13,7 +16,8 @@
  * @param intervals array of `{ start, end }` records
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
- * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-15T00:00:00" }]
+ * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-10T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-15T00:00:00" }] (touching)
+ * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-01T00:00:00" }]) // [] (empty interval)
  * @example mergeIntervalsDateTime([]) // []
  * @example mergeIntervalsDateTime([{ start: "2024-01-10T00:00:00", end: "2024-01-01T00:00:00" }]) // []
  */

package/dist/plain/interval/mergeIntervalsDateTime.js

@@ -1,11 +1,15 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { halfOpenMerge } from "../../internal/index.js";
 import { isValidDateTimeInterval } from "./validate/index.js";
 /**
  * Collapse a list of datetime intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionDateTime`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint 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.
  * - 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
@@ -15,44 +19,39 @@ import { isValidDateTimeInterval } from "./validate/index.js";
  * @param intervals array of `{ start, end }` records
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
- * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-05T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-15T00:00:00" }]
+ * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-10T00:00:00" }, { start: "2024-01-10T00:00:00", end: "2024-01-15T00:00:00" }]) // [{ start: "2024-01-01T00:00:00", end: "2024-01-15T00:00:00" }] (touching)
+ * @example mergeIntervalsDateTime([{ start: "2024-01-01T00:00:00", end: "2024-01-01T00:00:00" }]) // [] (empty interval)
  * @example mergeIntervalsDateTime([]) // []
  * @example mergeIntervalsDateTime([{ start: "2024-01-10T00:00:00", end: "2024-01-01T00:00:00" }]) // []
  */
 export function mergeIntervalsDateTime(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        isValidDateTimeInterval(interval.start, interval.end))) {
-        return [];
-    }
     try {
-        const parsed = intervals.map((interval) => ({
-            start: Temporal.PlainDateTime.from(interval.start),
-            end: Temporal.PlainDateTime.from(interval.end),
-        }));
-        parsed.sort((a, b) => Temporal.PlainDateTime.compare(a.start, b.start));
-        const merged = [];
-        for (const interval of parsed) {
-            const last = merged[merged.length - 1];
-            if (last &&
-                Temporal.PlainDateTime.compare(interval.start, last.end) <= 0) {
-                if (Temporal.PlainDateTime.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" &&
+            isValidDateTimeInterval(interval.start, interval.end))) {
+            return [];
+        }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: Temporal.PlainDateTime.from(interval.start),
+                end: Temporal.PlainDateTime.from(interval.end),
+            }));
+            const merged = halfOpenMerge(parsed, Temporal.PlainDateTime.compare);
+            return merged.map((interval) => ({
+                start: interval.start.toString(),
+                end: interval.end.toString(),
+            }));
+        }
+        catch {
+            return [];
         }
-        return merged.map((interval) => ({
-            start: interval.start.toString(),
-            end: interval.end.toString(),
-        }));
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }

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

@@ -2,8 +2,11 @@
  * Collapse a list of time intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionTime`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint 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.
  * - 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
@@ -13,7 +16,8 @@
  * @param intervals array of `{ start, end }` records
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
- * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "11:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }]
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }] (touching)
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00.000000001", end: "15:00:00" }]) // [{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00.000000001", end: "15:00:00" }] (1 ns gap)
  * @example mergeIntervalsTime([]) // []
  * @example mergeIntervalsTime([{ start: "15:00:00", end: "09:00:00" }]) // []
  */

package/dist/plain/interval/mergeIntervalsTime.js

@@ -1,11 +1,15 @@
 import { Temporal } from "@js-temporal/polyfill";
+import { halfOpenMerge } from "../../internal/index.js";
 import { isValidTimeInterval } from "./validate/index.js";
 /**
  * Collapse a list of time intervals into the minimum set of non-overlapping intervals.
  *
  * - List-form generalization of `intervalUnionTime`, which is pairwise only.
- * - Intervals are merged when they overlap or share an endpoint 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.
  * - 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
@@ -15,43 +19,39 @@ import { isValidTimeInterval } from "./validate/index.js";
  * @param intervals array of `{ start, end }` records
  * @returns the minimum set of non-overlapping `{ start, end }` records, sorted by start, or `[]` on invalid input
  *
- * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "11:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }]
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00", end: "15:00:00" }]) // [{ start: "09:00:00", end: "15:00:00" }] (touching)
+ * @example mergeIntervalsTime([{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00.000000001", end: "15:00:00" }]) // [{ start: "09:00:00", end: "12:00:00" }, { start: "12:00:00.000000001", end: "15:00:00" }] (1 ns gap)
  * @example mergeIntervalsTime([]) // []
  * @example mergeIntervalsTime([{ start: "15:00:00", end: "09:00:00" }]) // []
  */
 export function mergeIntervalsTime(intervals) {
-    if (!Array.isArray(intervals) || intervals.length === 0) {
-        return [];
-    }
-    if (!intervals.every((interval) => interval &&
-        typeof interval === "object" &&
-        isValidTimeInterval(interval.start, interval.end))) {
-        return [];
-    }
     try {
-        const parsed = intervals.map((interval) => ({
-            start: Temporal.PlainTime.from(interval.start),
-            end: Temporal.PlainTime.from(interval.end),
-        }));
-        parsed.sort((a, b) => Temporal.PlainTime.compare(a.start, b.start));
-        const merged = [];
-        for (const interval of parsed) {
-            const last = merged[merged.length - 1];
-            if (last && Temporal.PlainTime.compare(interval.start, last.end) <= 0) {
-                if (Temporal.PlainTime.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" &&
+            isValidTimeInterval(interval.start, interval.end))) {
+            return [];
+        }
+        try {
+            const parsed = intervals.map((interval) => ({
+                start: Temporal.PlainTime.from(interval.start),
+                end: Temporal.PlainTime.from(interval.end),
+            }));
+            const merged = halfOpenMerge(parsed, Temporal.PlainTime.compare);
+            return merged.map((interval) => ({
+                start: interval.start.toString(),
+                end: interval.end.toString(),
+            }));
+        }
+        catch {
+            return [];
         }
-        return merged.map((interval) => ({
-            start: interval.start.toString(),
-            end: interval.end.toString(),
-        }));
     }
     catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
         return [];
     }
 }