@northguild/gmt 1.15.0 → 1.17.0

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

@@ -1,24 +1,31 @@
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every day of B is also in A.
  *
- * - Uses `Temporal.PlainDate.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsDate(aStart, aEnd, bStart, bEnd)`.
+ * - Uses `Temporal.PlainDate.compare` for comparison.
  * - 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 outer interval start, optionally calendar-annotated
- * @param aEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param aEnd ISO 8601 date string for the outer interval end (excluded), optionally calendar-annotated
  * @param bStart ISO 8601 date string for the inner interval start, optionally calendar-annotated
- * @param bEnd ISO 8601 date string for the inner interval end, optionally calendar-annotated
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 date string for the inner interval end (excluded), optionally calendar-annotated
+ * @returns true if B lies within A, or false on invalid input
  *
  * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-07-01") // true
  * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-01-01", "2024-12-31") // true (equal intervals)
- * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-12-31") // true
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-12-31") // true (same end)
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-06-01") // true (empty interval strictly inside)
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
  * @example intervalEngulfsDate("2024-06-01", "2024-07-01", "2024-01-01", "2024-12-31") // false
- * @example intervalEngulfsDate("invalid", "2024-12-31", "2024-06-01", "2024-07-01") // false
  */
 export declare function intervalEngulfsDate(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalEngulfsDate.js

@@ -1,28 +1,36 @@
+// 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 { halfOpenContainsSpan, parseCalendarDateValue } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every day of B is also in A.
  *
- * - Uses `Temporal.PlainDate.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsDate(aStart, aEnd, bStart, bEnd)`.
+ * - Uses `Temporal.PlainDate.compare` for comparison.
  * - 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 outer interval start, optionally calendar-annotated
- * @param aEnd ISO 8601 date string for the outer interval end, optionally calendar-annotated
+ * @param aEnd ISO 8601 date string for the outer interval end (excluded), optionally calendar-annotated
  * @param bStart ISO 8601 date string for the inner interval start, optionally calendar-annotated
- * @param bEnd ISO 8601 date string for the inner interval end, optionally calendar-annotated
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 date string for the inner interval end (excluded), optionally calendar-annotated
+ * @returns true if B lies within A, or false on invalid input
  *
  * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-07-01") // true
  * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-01-01", "2024-12-31") // true (equal intervals)
- * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-12-31") // true
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-12-31") // true (same end)
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-06-01", "2024-06-01") // true (empty interval strictly inside)
+ * @example intervalEngulfsDate("2024-01-01", "2024-12-31", "2024-12-31", "2024-12-31") // false (empty interval at the edge)
  * @example intervalEngulfsDate("2024-06-01", "2024-07-01", "2024-01-01", "2024-12-31") // false
- * @example intervalEngulfsDate("invalid", "2024-12-31", "2024-06-01", "2024-07-01") // false
  */
 export function intervalEngulfsDate(aStart, aEnd, bStart, bEnd) {
     if (typeof aStart !== "string" ||
@@ -48,8 +56,7 @@ export function intervalEngulfsDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDate.compare(aS, bS) <= 0 &&
-            Temporal.PlainDate.compare(bE, aE) <= 0);
+        return halfOpenContainsSpan({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
     }
     catch {
         return false;

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

@@ -1,22 +1,27 @@
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every moment of B is also in A.
  *
- * - Uses `Temporal.PlainDateTime.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsDateTime(aStart, aEnd, bStart, bEnd)`.
+ * - Uses `Temporal.PlainDateTime.compare` for comparison.
  * - 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 outer interval start
- * @param aEnd ISO 8601 datetime string for the outer interval end
+ * @param aEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @param bStart ISO 8601 datetime string for the inner interval start
- * @param bEnd ISO 8601 datetime string for the inner interval end
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 datetime string for the inner interval end (excluded)
+ * @returns true if B lies within A, or false on invalid input
  *
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-06-01T12:00:00", "2024-07-01T13:00:00") // true
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // true (equal intervals)
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-06-30T12:00:00") // true
- * @example intervalEngulfsDateTime("2024-06-01T12:00:00", "2024-07-01T13:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // false
- * @example intervalEngulfsDateTime("invalid", "2024-12-31T17:00:00", "2024-06-01T12:00:00", "2024-07-01T13:00:00") // false
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T13:00:00") // true
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // true (equal intervals)
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (same end)
+ * @example intervalEngulfsDateTime("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 intervalEngulfsDateTime("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 intervalEngulfsDateTime("2024-01-01T12:00:00", "2024-01-01T13:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // false
  */
 export declare function intervalEngulfsDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalEngulfsDateTime.js

@@ -1,25 +1,32 @@
+// 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 { halfOpenContainsSpan } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every moment of B is also in A.
  *
- * - Uses `Temporal.PlainDateTime.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsDateTime(aStart, aEnd, bStart, bEnd)`.
+ * - Uses `Temporal.PlainDateTime.compare` for comparison.
  * - 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 outer interval start
- * @param aEnd ISO 8601 datetime string for the outer interval end
+ * @param aEnd ISO 8601 datetime string for the outer interval end (excluded)
  * @param bStart ISO 8601 datetime string for the inner interval start
- * @param bEnd ISO 8601 datetime string for the inner interval end
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 datetime string for the inner interval end (excluded)
+ * @returns true if B lies within A, or false on invalid input
  *
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-06-01T12:00:00", "2024-07-01T13:00:00") // true
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // true (equal intervals)
- * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-12-31T17:00:00", "2024-01-01T09:00:00", "2024-06-30T12:00:00") // true
- * @example intervalEngulfsDateTime("2024-06-01T12:00:00", "2024-07-01T13:00:00", "2024-01-01T09:00:00", "2024-12-31T17:00:00") // false
- * @example intervalEngulfsDateTime("invalid", "2024-12-31T17:00:00", "2024-06-01T12:00:00", "2024-07-01T13:00:00") // false
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T13:00:00") // true
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // true (equal intervals)
+ * @example intervalEngulfsDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // true (same end)
+ * @example intervalEngulfsDateTime("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 intervalEngulfsDateTime("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 intervalEngulfsDateTime("2024-01-01T12:00:00", "2024-01-01T13:00:00", "2024-01-01T09:00:00", "2024-01-01T17:00:00") // false
  */
 export function intervalEngulfsDateTime(aStart, aEnd, bStart, bEnd) {
     if (typeof aStart !== "string" ||
@@ -28,10 +35,10 @@ export function intervalEngulfsDateTime(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 {
@@ -45,8 +52,7 @@ export function intervalEngulfsDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainDateTime.compare(aS, bS) <= 0 &&
-            Temporal.PlainDateTime.compare(bE, aE) <= 0);
+        return halfOpenContainsSpan({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
     }
     catch {
         return false;

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

@@ -1,22 +1,32 @@
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every clock time of B is also in A.
  *
- * - Uses `Temporal.PlainTime.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsTime(aStart, aEnd, bStart, bEnd)`.
+ * - 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.
  * - 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 outer interval start
- * @param aEnd ISO 8601 time string for the outer interval end
+ * @param aEnd ISO 8601 time string for the outer interval end (excluded)
  * @param bStart ISO 8601 time string for the inner interval start
- * @param bEnd ISO 8601 time string for the inner interval end
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 time string for the inner interval end (excluded)
+ * @returns true if B lies within A, or false on invalid input
  *
  * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
  * @example intervalEngulfsTime("09:00:00", "17:00:00", "09:00:00", "17:00:00") // true (equal intervals)
- * @example intervalEngulfsTime("09:00:00", "17:00:00", "09:00:00", "12:00:00") // true
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // true (same end)
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "12:00:00") // true (empty interval strictly inside)
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "17:00:00", "17:00:00") // false (empty interval at the edge)
  * @example intervalEngulfsTime("12:00:00", "13:00:00", "09:00:00", "17:00:00") // false
- * @example intervalEngulfsTime("invalid", "17:00:00", "12:00:00", "13:00:00") // false
  */
 export declare function intervalEngulfsTime(aStart: string, aEnd: string, bStart: string, bEnd: string): boolean;

package/dist/plain/interval/intervalEngulfsTime.js

@@ -1,25 +1,37 @@
+// 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 { halfOpenContainsSpan } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
- * Return true when interval B is fully contained within interval A — every instant of B
- * falls within A.
+ * Return true when the half-open interval B `[bStart, bEnd)` lies within the half-open interval
+ * A `[aStart, aEnd)` — every clock time of B is also in A.
  *
- * - Uses `Temporal.PlainTime.compare` for comparison.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. B may start at A's start and
+ *   end at A's end, because neither end is part of either interval.
+ * - B must also overlap A, so an empty B (`bStart === bEnd`) counts only strictly inside A, never
+ *   at an edge (CORE-6's `clampInterval` clamps it away there).
  * - Equivalent to 4-argument `intervalContainsTime(aStart, aEnd, bStart, bEnd)`.
+ * - 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.
  * - 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 outer interval start
- * @param aEnd ISO 8601 time string for the outer interval end
+ * @param aEnd ISO 8601 time string for the outer interval end (excluded)
  * @param bStart ISO 8601 time string for the inner interval start
- * @param bEnd ISO 8601 time string for the inner interval end
- * @returns true if B is fully contained in A, or false on invalid input
+ * @param bEnd ISO 8601 time string for the inner interval end (excluded)
+ * @returns true if B lies within A, or false on invalid input
  *
  * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "13:00:00") // true
  * @example intervalEngulfsTime("09:00:00", "17:00:00", "09:00:00", "17:00:00") // true (equal intervals)
- * @example intervalEngulfsTime("09:00:00", "17:00:00", "09:00:00", "12:00:00") // true
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "17:00:00") // true (same end)
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "12:00:00", "12:00:00") // true (empty interval strictly inside)
+ * @example intervalEngulfsTime("09:00:00", "17:00:00", "17:00:00", "17:00:00") // false (empty interval at the edge)
  * @example intervalEngulfsTime("12:00:00", "13:00:00", "09:00:00", "17:00:00") // false
- * @example intervalEngulfsTime("invalid", "17:00:00", "12:00:00", "13:00:00") // false
  */
 export function intervalEngulfsTime(aStart, aEnd, bStart, bEnd) {
     if (typeof aStart !== "string" ||
@@ -28,10 +40,10 @@ export function intervalEngulfsTime(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,8 +57,7 @@ export function intervalEngulfsTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return false;
         }
-        return (Temporal.PlainTime.compare(aS, bS) <= 0 &&
-            Temporal.PlainTime.compare(bE, aE) <= 0);
+        return halfOpenContainsSpan({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
     }
     catch {
         return false;

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

@@ -4,13 +4,14 @@ import type { Overflow } from "../../types/index.js";
  *
  * - `anchor: "start"` treats `value` as the interval start and adds `duration` to get the end.
  * - `anchor: "end"` treats `value` as the interval end and subtracts `duration` to get the start.
- * - Uses `Temporal.PlainDate.prototype.add`/`.subtract`, so calendar units (years/months/weeks)
- *   resolve against `value` itself — no separate `relativeTo` is needed, unlike `addDuration`.
+ * - Uses `Temporal.PlainDate.prototype.add`/`.subtract` semantics, so calendar units
+ *   (years/months/weeks) resolve against `value` itself — no separate `relativeTo` is needed,
+ *   unlike `addDuration`. Time units count as whole 24-hour days, as Temporal's do.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDate`'s `start > end` rejection.
  * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
  *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
- * - Accepts a GMT calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
+ * - Accepts a RFC 9557 calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
  *   is resolved in `value`'s own calendar (no `relativeTo`/pair-matching question, since there
  *   is only one calendar-tagged input) and both endpoints are re-formatted in that calendar,
  *   re-derived from the actual result rather than copied from `value`'s tag (a leap-month or
@@ -29,7 +30,7 @@ import type { Overflow } from "../../types/index.js";
  * @example intervalFromDurationDate("2024-01-31", "P1M", "start", { overflow: "reject" }) // null
  * @example intervalFromDurationDate("2024-01-05", "-P10D", "start") // null (inverted span)
  * @example intervalFromDurationDate("invalid", "P1M", "start") // null
- * @example intervalFromDurationDate("5784-06-15[u-ca=hebrew]", "P1M", "start") // { start: "5784-06-15[u-ca=hebrew]", end: "5784-07-15[u-ca=hebrew]" } (Adar I -> Adar)
+ * @example intervalFromDurationDate("2024-02-24[u-ca=hebrew]", "P1M", "start") // { start: "2024-02-24[u-ca=hebrew]", end: "2024-03-25[u-ca=hebrew]" } (Adar I -> Adar)
  */
 export declare function intervalFromDurationDate(value: string, duration: string, anchor: "start" | "end", options?: {
     overflow?: Overflow;

package/dist/plain/interval/intervalFromDurationDate.js

@@ -1,19 +1,21 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidDuration } from "../../duration/validate/index.js";
-import { calendarSystemOfDateValue, formatDateInCalendar, parseCalendarDateValue, resolveOverflow, } from "../../internal/index.js";
+import { calendarSystemOfDateValue, formatDateInCalendar, parseCalendarDateValue, plainDateAdd, resolveOverflow, } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Construct a date interval from a single point plus an ISO 8601 duration, anchored at either end.
  *
  * - `anchor: "start"` treats `value` as the interval start and adds `duration` to get the end.
  * - `anchor: "end"` treats `value` as the interval end and subtracts `duration` to get the start.
- * - Uses `Temporal.PlainDate.prototype.add`/`.subtract`, so calendar units (years/months/weeks)
- *   resolve against `value` itself — no separate `relativeTo` is needed, unlike `addDuration`.
+ * - Uses `Temporal.PlainDate.prototype.add`/`.subtract` semantics, so calendar units
+ *   (years/months/weeks) resolve against `value` itself — no separate `relativeTo` is needed,
+ *   unlike `addDuration`. Time units count as whole 24-hour days, as Temporal's do.
  * - A negative `duration` (e.g. `"-P1D"`) can invert the computed span; returns null when that
  *   happens, mirroring `intervalIntersectionDate`'s `start > end` rejection.
  * - `overflow` ("constrain" (default) | "reject") controls out-of-range results, e.g. adding 1 month
  *   to Jan 31: "constrain" clamps to Feb 29/28, "reject" returns null.
- * - Accepts a GMT calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
+ * - Accepts a RFC 9557 calendar-annotated PlainDate string — E5 (issue #78). The computed endpoint
  *   is resolved in `value`'s own calendar (no `relativeTo`/pair-matching question, since there
  *   is only one calendar-tagged input) and both endpoints are re-formatted in that calendar,
  *   re-derived from the actual result rather than copied from `value`'s tag (a leap-month or
@@ -32,9 +34,12 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @example intervalFromDurationDate("2024-01-31", "P1M", "start", { overflow: "reject" }) // null
  * @example intervalFromDurationDate("2024-01-05", "-P10D", "start") // null (inverted span)
  * @example intervalFromDurationDate("invalid", "P1M", "start") // null
- * @example intervalFromDurationDate("5784-06-15[u-ca=hebrew]", "P1M", "start") // { start: "5784-06-15[u-ca=hebrew]", end: "5784-07-15[u-ca=hebrew]" } (Adar I -> Adar)
+ * @example intervalFromDurationDate("2024-02-24[u-ca=hebrew]", "P1M", "start") // { start: "2024-02-24[u-ca=hebrew]", end: "2024-03-25[u-ca=hebrew]" } (Adar I -> Adar)
  */
 export function intervalFromDurationDate(value, duration, anchor, options) {
+    if (!isOptionsArgument(options)) {
+        return null;
+    }
     if (typeof value !== "string" || !isValidCalendarDate(value)) {
         return null;
     }
@@ -52,9 +57,7 @@ export function intervalFromDurationDate(value, duration, anchor, options) {
         const point = parseCalendarDateValue(value);
         const dur = Temporal.Duration.from(duration);
         const overflow = resolveOverflow(options?.overflow);
-        const other = anchor === "start"
-            ? point.add(dur, { overflow })
-            : point.subtract(dur, { overflow });
+        const other = plainDateAdd(point, anchor === "start" ? dur : dur.negated(), overflow);
         const start = anchor === "start" ? point : other;
         const end = anchor === "start" ? other : point;
         if (Temporal.PlainDate.compare(start, end) > 0) {

package/dist/plain/interval/intervalFromDurationDateTime.js

@@ -2,6 +2,7 @@ import { Temporal } from "@js-temporal/polyfill";
 import { isValidDuration } from "../../duration/validate/index.js";
 import { resolveOverflow } from "../../internal/index.js";
 import { isValidDateTime } from "../validate/index.js";
+import { isOptionsArgument } from "../../internal/isObject.js";
 /**
  * Construct a datetime interval from a single point plus an ISO 8601 duration, anchored at either end.
  *
@@ -29,6 +30,9 @@ import { isValidDateTime } from "../validate/index.js";
  * @example intervalFromDurationDateTime("invalid", "P1D", "start") // null
  */
 export function intervalFromDurationDateTime(value, duration, anchor, options) {
+    if (!isOptionsArgument(options)) {
+        return null;
+    }
     if (typeof value !== "string" || !isValidDateTime(value)) {
         return null;
     }

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

@@ -1,4 +1,3 @@
-import type { Overflow } from "../../types/index.js";
 /**
  * Construct a time interval from a single point plus an ISO 8601 duration, anchored at either end.
  *
@@ -8,31 +7,30 @@ import type { Overflow } from "../../types/index.js";
  *   cannot be resolved against a bare clock time — there is no `relativeTo` to supply (mirrors
  *   A2/A3's documented `relativeTo` gap). `Temporal.PlainTime.prototype.add` silently discards
  *   those fields rather than throwing, so this is checked explicitly and returns null.
- * - A `duration` that wraps past midnight (e.g. `"23:00:00"` + `"PT2H"`) produces a span PlainTime
- *   can't represent (no date component for the day rollover) and returns null, same as any other
- *   inverted span.
- * - `overflow` ("constrain" (default) | "reject") is accepted for API consistency with sibling
- *   `intervalFromDuration*` functions, but `PlainTime` arithmetic always wraps around the clock
- *   rather than producing an out-of-range value, so it has no observable effect here (mirrors
- *   `addTime`'s own documented no-op).
+ * - The span must fit inside one day in the anchored direction. A `duration` that crosses
+ *   midnight (e.g. `"23:00:00"` + `"PT2H"`), any `duration` of 24 hours or more (e.g. `"PT24H"`,
+ *   even though the wrapped clock time looks valid), and any negative `duration` return null —
+ *   PlainTime has no date component for the day rollover. The span is measured exactly in
+ *   nanoseconds, not by comparing wrapped clock times.
+ * - There is no options argument (its only member, `overflow`, was removed in 1.16.0): Temporal
+ *   `PlainTime#add`/`#subtract` take no options.
  * - Returns null on invalid input (unparseable `value`, invalid `duration`, or an `anchor` other
  *   than `"start"`/`"end"`).
  *
  * @param value ISO PlainTime string
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject" — accepted but inert, see above)
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationTime("12:00:00", "PT1H", "start") // { start: "12:00:00", end: "13:00:00" }
  * @example intervalFromDurationTime("13:00:00", "PT1H", "end") // { start: "12:00:00", end: "13:00:00" }
  * @example intervalFromDurationTime("12:00:00", "P1D", "start") // null (date units need relativeTo, unsupported)
  * @example intervalFromDurationTime("23:00:00", "PT2H", "start") // null (wraps past midnight, inverted span)
+ * @example intervalFromDurationTime("10:00:00", "PT24H", "start") // null (24 hours or more never fits one day)
+ * @example intervalFromDurationTime("12:00:00", "-PT23H", "start") // null (negative duration)
  * @example intervalFromDurationTime("invalid", "PT1H", "start") // null
  */
-export declare function intervalFromDurationTime(value: string, duration: string, anchor: "start" | "end", options?: {
-    overflow?: Overflow;
-}): {
+export declare function intervalFromDurationTime(value: string, duration: string, anchor: "start" | "end"): {
     start: string;
     end: string;
 } | null;

package/dist/plain/interval/intervalFromDurationTime.js

@@ -1,7 +1,15 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { isValidDuration } from "../../duration/validate/index.js";
-import { resolveOverflow } from "../../internal/index.js";
 import { isValidTime } from "../validate/index.js";
+const NANOSECONDS_PER_DAY = 86400000000000n;
+function clockNanoseconds(hours, minutes, seconds, milliseconds, microseconds, nanoseconds) {
+    return (BigInt(hours) * 3600000000000n +
+        BigInt(minutes) * 60000000000n +
+        BigInt(seconds) * 1000000000n +
+        BigInt(milliseconds) * 1000000n +
+        BigInt(microseconds) * 1000n +
+        BigInt(nanoseconds));
+}
 /**
  * Construct a time interval from a single point plus an ISO 8601 duration, anchored at either end.
  *
@@ -11,29 +19,30 @@ import { isValidTime } from "../validate/index.js";
  *   cannot be resolved against a bare clock time — there is no `relativeTo` to supply (mirrors
  *   A2/A3's documented `relativeTo` gap). `Temporal.PlainTime.prototype.add` silently discards
  *   those fields rather than throwing, so this is checked explicitly and returns null.
- * - A `duration` that wraps past midnight (e.g. `"23:00:00"` + `"PT2H"`) produces a span PlainTime
- *   can't represent (no date component for the day rollover) and returns null, same as any other
- *   inverted span.
- * - `overflow` ("constrain" (default) | "reject") is accepted for API consistency with sibling
- *   `intervalFromDuration*` functions, but `PlainTime` arithmetic always wraps around the clock
- *   rather than producing an out-of-range value, so it has no observable effect here (mirrors
- *   `addTime`'s own documented no-op).
+ * - The span must fit inside one day in the anchored direction. A `duration` that crosses
+ *   midnight (e.g. `"23:00:00"` + `"PT2H"`), any `duration` of 24 hours or more (e.g. `"PT24H"`,
+ *   even though the wrapped clock time looks valid), and any negative `duration` return null —
+ *   PlainTime has no date component for the day rollover. The span is measured exactly in
+ *   nanoseconds, not by comparing wrapped clock times.
+ * - There is no options argument (its only member, `overflow`, was removed in 1.16.0): Temporal
+ *   `PlainTime#add`/`#subtract` take no options.
  * - Returns null on invalid input (unparseable `value`, invalid `duration`, or an `anchor` other
  *   than `"start"`/`"end"`).
  *
  * @param value ISO PlainTime string
  * @param duration ISO 8601 duration string
  * @param anchor "start" | "end" — which endpoint `value` represents
- * @param options optional: overflow ("constrain" | "reject" — accepted but inert, see above)
  * @returns `{ start, end }` with the constructed span, or null on invalid input
  *
  * @example intervalFromDurationTime("12:00:00", "PT1H", "start") // { start: "12:00:00", end: "13:00:00" }
  * @example intervalFromDurationTime("13:00:00", "PT1H", "end") // { start: "12:00:00", end: "13:00:00" }
  * @example intervalFromDurationTime("12:00:00", "P1D", "start") // null (date units need relativeTo, unsupported)
  * @example intervalFromDurationTime("23:00:00", "PT2H", "start") // null (wraps past midnight, inverted span)
+ * @example intervalFromDurationTime("10:00:00", "PT24H", "start") // null (24 hours or more never fits one day)
+ * @example intervalFromDurationTime("12:00:00", "-PT23H", "start") // null (negative duration)
  * @example intervalFromDurationTime("invalid", "PT1H", "start") // null
  */
-export function intervalFromDurationTime(value, duration, anchor, options) {
+export function intervalFromDurationTime(value, duration, anchor) {
     if (typeof value !== "string" || !isValidTime(value)) {
         return null;
     }
@@ -52,15 +61,17 @@ export function intervalFromDurationTime(value, duration, anchor, options) {
             return null;
         }
         const point = Temporal.PlainTime.from(value);
-        const overflow = resolveOverflow(options?.overflow);
-        const other = anchor === "start"
-            ? point.add(dur, { overflow })
-            : point.subtract(dur, { overflow });
-        const start = anchor === "start" ? point : other;
-        const end = anchor === "start" ? other : point;
-        if (Temporal.PlainTime.compare(start, end) > 0) {
+        // Measure the span exactly: PlainTime.add wraps modulo 24 h, so comparing the wrapped
+        // endpoints misses a span of 24 h or more and a negative duration that wraps.
+        const spanNs = clockNanoseconds(dur.hours, dur.minutes, dur.seconds, dur.milliseconds, dur.microseconds, dur.nanoseconds);
+        const pointNs = clockNanoseconds(point.hour, point.minute, point.second, point.millisecond, point.microsecond, point.nanosecond);
+        const otherNs = anchor === "start" ? pointNs + spanNs : pointNs - spanNs;
+        if (spanNs < 0n || otherNs < 0n || otherNs >= NANOSECONDS_PER_DAY) {
             return null;
         }
+        const other = anchor === "start" ? point.add(dur) : point.subtract(dur);
+        const start = anchor === "start" ? point : other;
+        const end = anchor === "start" ? other : point;
         return { start: start.toString(), end: end.toString() };
     }
     catch {

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

@@ -2,10 +2,15 @@
  * Return the overlapping span of two date intervals, or null when they do not overlap.
  *
  * - Uses `Temporal.PlainDate.compare` for comparison.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one instant and DO overlap.
+ * - Half-open: an interval holds every `t` with `start <= t < end`. The intersection is
+ *   `[max(aStart, bStart), min(aEnd, bEnd))` when `aStart < bEnd && bStart < aEnd` (CORE-6's
+ *   `intersectIntervals`), otherwise `null`.
+ * - Touching intervals (`aEnd === bStart`) share no day and return `null`.
+ * - An empty interval (`start === end`) intersects only an interval it lies strictly inside, and
+ *   then returns itself.
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). Since the result is a
  *   date *value*, all four arguments must carry the *same* calendar tag (or all be bare ISO);
  *   a mismatch returns `null` (E5 decision of record D4). The output's tag is re-derived from
  *   the intersection span, never copied from an input.
@@ -17,8 +22,8 @@
  * @returns `{ start, end }` with the overlapping span, or null on invalid input / no overlap / mismatched calendars
  *
  * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // { start: "2024-04-01", end: "2024-06-30" }
- * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // { start: "2024-06-30", end: "2024-06-30" }
- * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // null
+ * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-06-29", "2024-12-31") // { start: "2024-06-29", end: "2024-06-30" } (one shared day)
+ * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // null (touching)
  * @example intervalIntersectionDate("2024-01-01", "2024-06-30", "2024-02-01", "2024-03-01") // { start: "2024-02-01", end: "2024-03-01" }
  * @example intervalIntersectionDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // null
  */