@northguild/gmt 1.15.0 → 1.16.0

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

@@ -1,9 +1,14 @@
 /**
- * Return true when two time intervals are exactly adjacent — one's end equals the other's start
- * with zero gap and zero overlap.
+ * Return true when two half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
+ * - PlainTime has no day rollover: an interval ending at `23:59:59.999999999` never abuts one
+ *   starting at `00:00:00`.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Returns `true` when `aEnd + 1 nanosecond === bStart` or `bEnd + 1 nanosecond === aStart`.
  * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
@@ -13,10 +18,11 @@
  * @param bEnd ISO 8601 time string for the second interval end
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
- * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00.000000001", "17:00:00") // true
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00", "17:00:00") // true
  * @example intervalAbutsTime("12:00:00", "17:00:00", "09:00:00", "12:00:00") // true
- * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:01", "17:00:00") // false (gap)
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00.000000001", "17:00:00") // false (1 ns gap)
  * @example intervalAbutsTime("09:00:00", "13:00:00", "12:00:00", "17:00:00") // false (overlap)
+ * @example intervalAbutsTime("22:00:00", "23:59:59.999999999", "00:00:00", "01:00:00") // false (no midnight wrap)
  * @example intervalAbutsTime("invalid", "12:00:00", "12:00:00", "17:00:00") // false
  */
 export declare function intervalAbutsTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalAbutsTime.js

@@ -1,11 +1,18 @@
+// 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 { halfOpenAbuts } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
- * Return true when two time intervals are exactly adjacent — one's end equals the other's start
- * with zero gap and zero overlap.
+ * Return true when two half-open time intervals `[aStart, aEnd)` and `[bStart, bEnd)` are exactly
+ * adjacent — one ends where the other starts, so they share nothing and leave no gap.
  *
+ * - Half-open: an interval holds every `t` with `start <= t < end`, so an interval's `end` is the
+ *   first value after it. Returns `true` when `aEnd === bStart` or `bEnd === aStart` (Allen's
+ *   "meets"). There is no one-nanosecond step: a one-nanosecond gap is a gap.
+ * - An empty interval (`start === end`) abuts nothing.
+ * - PlainTime has no day rollover: an interval ending at `23:59:59.999999999` never abuts one
+ *   starting at `00:00:00`.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Returns `true` when `aEnd + 1 nanosecond === bStart` or `bEnd + 1 nanosecond === aStart`.
  * - Returns `false` when intervals overlap, are disjoint with a gap, or are invalid.
  * - Returns `false` on invalid input (wrong type, malformed strings).
  *
@@ -15,10 +22,11 @@ import { plainTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 time string for the second interval end
  * @returns true if intervals are exactly adjacent, or false on invalid input
  *
- * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00.000000001", "17:00:00") // true
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00", "17:00:00") // true
  * @example intervalAbutsTime("12:00:00", "17:00:00", "09:00:00", "12:00:00") // true
- * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:01", "17:00:00") // false (gap)
+ * @example intervalAbutsTime("09:00:00", "12:00:00", "12:00:00.000000001", "17:00:00") // false (1 ns gap)
  * @example intervalAbutsTime("09:00:00", "13:00:00", "12:00:00", "17:00:00") // false (overlap)
+ * @example intervalAbutsTime("22:00:00", "23:59:59.999999999", "00:00:00", "01:00:00") // false (no midnight wrap)
  * @example intervalAbutsTime("invalid", "12:00:00", "12:00:00", "17:00:00") // false
  */
 export function intervalAbutsTime(aStart, aEnd, bStart, bEnd) {
@@ -28,10 +36,10 @@ export function intervalAbutsTime(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 {
@@ -45,17 +53,7 @@ export function intervalAbutsTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return false;
         }
-        // aEnd + 1 nanosecond === bStart
-        const aEndPlusOne = aE.add({ nanoseconds: 1 });
-        if (Temporal.PlainTime.compare(aEndPlusOne, bS) === 0) {
-            return true;
-        }
-        // bEnd + 1 nanosecond === aStart
-        const bEndPlusOne = bE.add({ nanoseconds: 1 });
-        if (Temporal.PlainTime.compare(bEndPlusOne, aS) === 0) {
-            return true;
-        }
-        return false;
+        return halfOpenAbuts({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
     }
     catch {
         return false;

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

@@ -1,26 +1,33 @@
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every day `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
  * - 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 intervalStart ISO 8601 date string for the outer interval start, optionally calendar-annotated
- * @param intervalEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param intervalEnd ISO 8601 date string for the outer interval end (excluded), optionally calendar-annotated
  * @param pointOrStart ISO 8601 date string for the point (3-arg) or inner start (4-arg), optionally calendar-annotated
  * @param pointEnd optional ISO 8601 date string for the inner interval end (4-arg mode), optionally calendar-annotated
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
  * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15") // true
- * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-07-15") // true
- * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false
- * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-06-10") // false
- * @example intervalContainsDate("invalid", "2024-12-31", "2024-06-15") // false
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-30") // true (last value before the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31") // false (end is excluded)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-12-31") // true (inner shares the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false (reversed interval)
  */
 export declare function intervalContainsDate(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDate.js

@@ -1,30 +1,37 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { parseCalendarDateValue } from "../../internal/index.js";
+import { halfOpenContainsPoint, halfOpenContainsSpan, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every day `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
  * - 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 intervalStart ISO 8601 date string for the outer interval start, optionally calendar-annotated
- * @param intervalEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param intervalEnd ISO 8601 date string for the outer interval end (excluded), optionally calendar-annotated
  * @param pointOrStart ISO 8601 date string for the point (3-arg) or inner start (4-arg), optionally calendar-annotated
  * @param pointEnd optional ISO 8601 date string for the inner interval end (4-arg mode), optionally calendar-annotated
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
  * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15") // true
- * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-07-15") // true
- * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false
- * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-06-10") // false
- * @example intervalContainsDate("invalid", "2024-12-31", "2024-06-15") // false
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-30") // true (last value before the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31") // false (end is excluded)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-06-15", "2024-12-31") // true (inner shares the end)
+ * @example intervalContainsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
+ * @example intervalContainsDate("2024-12-31", "2024-01-01", "2024-06-15") // false (reversed interval)
  */
 export function intervalContainsDate(intervalStart, intervalEnd, pointOrStart, pointEnd) {
     if (typeof intervalStart !== "string" ||
@@ -47,15 +54,13 @@ export function intervalContainsDate(intervalStart, intervalEnd, pointOrStart, p
             return false;
         }
         if (pointEnd === undefined) {
-            return (Temporal.PlainDate.compare(s, p) <= 0 &&
-                Temporal.PlainDate.compare(p, e) <= 0);
+            return halfOpenContainsPoint({ start: s, end: e }, p, Temporal.PlainDate.compare);
         }
         const pe = parseCalendarDateValue(pointEnd);
         if (Temporal.PlainDate.compare(p, pe) > 0) {
             return false;
         }
-        return (Temporal.PlainDate.compare(s, p) <= 0 &&
-            Temporal.PlainDate.compare(pe, e) <= 0);
+        return halfOpenContainsSpan({ start: s, end: e }, { start: p, end: pe }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

@@ -1,24 +1,29 @@
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every moment `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 datetime string for the outer interval start
- * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @param pointOrStart ISO 8601 datetime string for the point (3-arg) or inner start (4-arg)
  * @param pointEnd optional ISO 8601 datetime string for the inner interval end (4-arg mode)
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // true
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-07-15T12:00:00") // true
- * @example intervalContainsDateTime("2024-12-31T23:59:59", "2024-01-01T10:00:00", "2024-06-15T12:00:00") // false
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-06-10T12:00:00") // false
- * @example intervalContainsDateTime("invalid", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // false
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (end is excluded)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (inner shares the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsDateTime("2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T12:00:00") // false (reversed interval)
  */
 export declare function intervalContainsDateTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsDateTime.js

@@ -1,27 +1,33 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { plainDateTime } from "../../regex/index.js";
+import { halfOpenContainsPoint, halfOpenContainsSpan } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every moment `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Uses `Temporal.PlainDateTime.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 datetime string for the outer interval start
- * @param intervalEnd ISO 8601 datetime string for the outer interval end
+ * @param intervalEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @param pointOrStart ISO 8601 datetime string for the point (3-arg) or inner start (4-arg)
  * @param pointEnd optional ISO 8601 datetime string for the inner interval end (4-arg mode)
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // true
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-07-15T12:00:00") // true
- * @example intervalContainsDateTime("2024-12-31T23:59:59", "2024-01-01T10:00:00", "2024-06-15T12:00:00") // false
- * @example intervalContainsDateTime("2024-01-01T10:00:00", "2024-12-31T23:59:59", "2024-06-15T12:00:00", "2024-06-10T12:00:00") // false
- * @example intervalContainsDateTime("invalid", "2024-12-31T23:59:59", "2024-06-15T12:00:00") // false
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00") // true
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (end is excluded)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (inner shares the end)
+ * @example intervalContainsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00", "2024-01-01T17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsDateTime("2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T12:00:00") // false (reversed interval)
  */
 export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStart, pointEnd) {
     if (typeof intervalStart !== "string" ||
@@ -30,10 +36,10 @@ export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStar
         (pointEnd !== undefined && typeof pointEnd !== "string")) {
         return false;
     }
-    if (!plainDateTime.test(intervalStart) ||
-        !plainDateTime.test(intervalEnd) ||
-        !plainDateTime.test(pointOrStart) ||
-        (pointEnd !== undefined && !plainDateTime.test(pointEnd))) {
+    if (!isValidDateTime(intervalStart) ||
+        !isValidDateTime(intervalEnd) ||
+        !isValidDateTime(pointOrStart) ||
+        (pointEnd !== undefined && !isValidDateTime(pointEnd))) {
         return false;
     }
     try {
@@ -44,15 +50,13 @@ export function intervalContainsDateTime(intervalStart, intervalEnd, pointOrStar
             return false;
         }
         if (pointEnd === undefined) {
-            return (Temporal.PlainDateTime.compare(s, p) <= 0 &&
-                Temporal.PlainDateTime.compare(p, e) <= 0);
+            return halfOpenContainsPoint({ start: s, end: e }, p, Temporal.PlainDateTime.compare);
         }
         const pe = Temporal.PlainDateTime.from(pointEnd);
         if (Temporal.PlainDateTime.compare(p, pe) > 0) {
             return false;
         }
-        return (Temporal.PlainDateTime.compare(s, p) <= 0 &&
-            Temporal.PlainDateTime.compare(pe, e) <= 0);
+        return halfOpenContainsSpan({ start: s, end: e }, { start: p, end: pe }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;

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

@@ -1,24 +1,34 @@
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every clock time `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
+ * - PlainTime has no day rollover: an interval never wraps past midnight. And because `end` is
+ *   excluded, no interval *contains* `23:59:59.999999999` — containing it would need an `end`
+ *   greater than it, and no PlainTime is. An interval may still *have* it as its `end`:
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:00:00")` is `true`, while
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:59:59.999999999")` is `false`.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 time string for the outer interval start
- * @param intervalEnd ISO 8601 time string for the outer interval end
+ * @param intervalEnd ISO 8601 time string for the outer interval end (excluded)
  * @param pointOrStart ISO 8601 time string for the point (3-arg) or inner start (4-arg)
  * @param pointEnd optional ISO 8601 time string for the inner interval end (4-arg mode)
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
  * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00") // true
- * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
- * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false
- * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "11:00:00") // false
- * @example intervalContainsTime("invalid", "17:00:00", "12:00:00") // false
+ * @example intervalContainsTime("09:00:00", "17:00:00", "16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00") // false (end is excluded)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // true (inner shares the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00", "17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false (reversed interval)
  */
 export declare function intervalContainsTime(intervalStart: string, intervalEnd: string, pointOrStart: string, pointEnd?: string): boolean;

package/dist/plain/interval/intervalContainsTime.js

@@ -1,27 +1,38 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { plainTime } from "../../regex/index.js";
+import { halfOpenContainsPoint, halfOpenContainsSpan } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
- * Return true when `pointOrStart` falls within the interval `[intervalStart, intervalEnd]`
- * (3-arg), or when the inner interval `[innerStart, innerEnd]` is fully contained within
- * the outer interval `[intervalStart, intervalEnd]` (4-arg).
+ * Return true when `pointOrStart` lies in the half-open interval `[intervalStart, intervalEnd)`
+ * (3-arg), or when the inner interval `[innerStart, innerEnd)` lies within it (4-arg).
  *
+ * - Half-open: an interval holds every clock time `t` with `start <= t < end`, so `intervalEnd` itself is
+ *   outside (the rule CORE-6's `intervalContains` uses). An empty interval (`start === end`)
+ *   contains no point.
+ * - 4-arg: the inner interval must start at or after `intervalStart`, end at or before
+ *   `intervalEnd`, and overlap the outer interval. An empty inner interval therefore counts only
+ *   strictly inside, never at an edge (CORE-6's `clampInterval` clamps it away there).
+ * - PlainTime has no day rollover: an interval never wraps past midnight. And because `end` is
+ *   excluded, no interval *contains* `23:59:59.999999999` — containing it would need an `end`
+ *   greater than it, and no PlainTime is. An interval may still *have* it as its `end`:
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:00:00")` is `true`, while
+ *   `intervalContainsTime("09:00:00", "23:59:59.999999999", "23:59:59.999999999")` is `false`.
  * - Uses `Temporal.PlainTime.compare` for comparison.
- * - Always-inclusive boundaries: `start <= point <= end`.
  * - Returns `false` if `intervalStart > intervalEnd` (invalid outer interval).
  * - Returns `false` if `innerStart > innerEnd` in 4-arg mode (invalid inner interval).
- * - Returns `false` on invalid input (wrong type, malformed strings, leap seconds).
+ * - Returns `false` on invalid input (wrong type, malformed strings).
  *
  * @param intervalStart ISO 8601 time string for the outer interval start
- * @param intervalEnd ISO 8601 time string for the outer interval end
+ * @param intervalEnd ISO 8601 time string for the outer interval end (excluded)
  * @param pointOrStart ISO 8601 time string for the point (3-arg) or inner start (4-arg)
  * @param pointEnd optional ISO 8601 time string for the inner interval end (4-arg mode)
  * @returns true if the point or inner interval is contained, or false on invalid input
  *
  * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00") // true
- * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
- * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false
- * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "11:00:00") // false
- * @example intervalContainsTime("invalid", "17:00:00", "12:00:00") // false
+ * @example intervalContainsTime("09:00:00", "17:00:00", "16:59:59.999999999") // true (last value before the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00") // false (end is excluded)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // true (inner shares the end)
+ * @example intervalContainsTime("09:00:00", "17:00:00", "17:00:00", "17:00:00") // false (empty interval at the edge)
+ * @example intervalContainsTime("17:00:00", "09:00:00", "12:00:00") // false (reversed interval)
  */
 export function intervalContainsTime(intervalStart, intervalEnd, pointOrStart, pointEnd) {
     if (typeof intervalStart !== "string" ||
@@ -30,10 +41,10 @@ export function intervalContainsTime(intervalStart, intervalEnd, pointOrStart, p
         (pointEnd !== undefined && typeof pointEnd !== "string")) {
         return false;
     }
-    if (!plainTime.test(intervalStart) ||
-        !plainTime.test(intervalEnd) ||
-        !plainTime.test(pointOrStart) ||
-        (pointEnd !== undefined && !plainTime.test(pointEnd))) {
+    if (!isValidTime(intervalStart) ||
+        !isValidTime(intervalEnd) ||
+        !isValidTime(pointOrStart) ||
+        (pointEnd !== undefined && !isValidTime(pointEnd))) {
         return false;
     }
     try {
@@ -44,15 +55,13 @@ export function intervalContainsTime(intervalStart, intervalEnd, pointOrStart, p
             return false;
         }
         if (pointEnd === undefined) {
-            return (Temporal.PlainTime.compare(s, p) <= 0 &&
-                Temporal.PlainTime.compare(p, e) <= 0);
+            return halfOpenContainsPoint({ start: s, end: e }, p, Temporal.PlainTime.compare);
         }
         const pe = Temporal.PlainTime.from(pointEnd);
         if (Temporal.PlainTime.compare(p, pe) > 0) {
             return false;
         }
-        return (Temporal.PlainTime.compare(s, p) <= 0 &&
-            Temporal.PlainTime.compare(pe, e) <= 0);
+        return halfOpenContainsSpan({ start: s, end: e }, { start: p, end: pe }, Temporal.PlainTime.compare);
     }
     catch {
         return false;

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

@@ -4,16 +4,21 @@
  * - Counts calendar boundaries touched by the half-open interval `[start, end)` — distinct
  *   from `diffDate`, which measures exact elapsed duration.
  * - `"2024-01-01"` to `"2024-01-03"` counted in days is 2: the end boundary is excluded.
- * - A zero-length interval counts 1 when it sits mid-unit and 0 when it sits exactly on a
- *   unit boundary (e.g. `"2024-01-15"` counts 1 month but 0 days).
+ * - A zero-length interval (`start === end`) returns `0`: the empty `[start, start)` holds no instant,
+ *   so it touches no unit (before 1.16.0 it counted 1 when mid-unit).
  * - Weeks start on Monday (ISO 8601).
+ * - A unit that began before the first representable date (`-271821-04-19`) is still counted:
+ *   whole units are measured from the unit after `start`'s, never from `start`'s own start.
  * - Accepts singular or plural units (`"day"` and `"days"` behave identically).
  * - Returns `null` on invalid input (unparseable start/end, `start > end`, unsupported unit,
  *   or a unit that has no effect on `PlainDate`, e.g. `"hours"`).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
  *   carry the *same* calendar tag, boundaries are counted in that calendar (a Hebrew leap year
- *   crosses 13 month boundaries, not 12 — see the roadmap's E5 decisions of record, D5). When
- *   they carry different tags (or either is bare ISO), counting falls back to Gregorian.
+ *   crosses 13 month boundaries, not 12). When they name different calendars (a bare ISO string
+ *   names `iso8601`) the result is `null`, as Temporal's `until` throws when `CalendarEquals` is
+ *   false (before 1.16.0 it counted in ISO).
+ * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, `[u-ca=<id>]`, canonical
+ *   calendar ids); see `isValidCalendarDate`.
  *
  * @param start ISO PlainDate string for the interval start, optionally calendar-annotated
  * @param end ISO PlainDate string for the interval end, optionally calendar-annotated
@@ -22,10 +27,10 @@
  *
  * @example intervalCountDate("2024-01-01", "2024-01-03", "day") // 2
  * @example intervalCountDate("2024-01-15", "2024-03-10", "month") // 3
- * @example intervalCountDate("2024-01-15", "2024-01-15", "month") // 1 (zero-length, mid-month)
- * @example intervalCountDate("2024-01-01", "2024-01-01", "month") // 0 (zero-length, on the boundary)
+ * @example intervalCountDate("2024-01-15", "2024-01-15", "month") // 0 (zero-length: holds no instant)
  * @example intervalCountDate("2024-01-01", "2024-01-10", "hour") // null
  * @example intervalCountDate("invalid", "2024-01-10", "day") // null
- * @example intervalCountDate("5784-01-01[u-ca=hebrew]", "5785-01-01[u-ca=hebrew]", "month") // 13 (Hebrew leap year, measured in Hebrew)
+ * @example intervalCountDate("2023-09-16[u-ca=hebrew]", "2024-10-03[u-ca=hebrew]", "month") // 13 (Hebrew leap year, measured in Hebrew)
+ * @example intervalCountDate("2024-10-03[u-ca=hebrew]", "2024-11-03", "month") // null (different calendars)
  */
 export declare function intervalCountDate(start: string, end: string, unit: string): number | null;