@northguild/gmt 1.14.2 → 1.16.0

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
  */

package/dist/plain/interval/intervalIntersectionDate.js

@@ -1,14 +1,20 @@
+// fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
 import { Temporal } from "@js-temporal/polyfill";
-import { calendarOfAllDateValues, formatDateInCalendar, parseCalendarDateValue, } from "../../internal/index.js";
+import { calendarOfAllDateValues, formatDateInCalendar, halfOpenIntersection, parseCalendarDateValue, } from "../../internal/index.js";
 import { isValidCalendarDate } from "../validate/index.js";
 /**
  * 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.
@@ -20,8 +26,8 @@ import { isValidCalendarDate } from "../validate/index.js";
  * @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
  */
@@ -53,12 +59,11 @@ export function intervalIntersectionDate(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDate.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainDate.compare(aE, bS) < 0 ||
-            Temporal.PlainDate.compare(bE, aS) < 0) {
+        const shared = halfOpenIntersection({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDate.compare);
+        if (shared === null) {
             return null;
         }
-        const start = Temporal.PlainDate.compare(aS, bS) >= 0 ? aS : bS;
-        const end = Temporal.PlainDate.compare(aE, bE) <= 0 ? aE : bE;
+        const { start, end } = shared;
         return {
             start: formatDateInCalendar(start, calendar),
             end: formatDateInCalendar(end, calendar),

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

@@ -2,7 +2,12 @@
  * Return the overlapping span of two datetime intervals, or null when they do not overlap.
  *
  * - Uses `Temporal.PlainDateTime.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 moment 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).
  *
@@ -12,9 +17,9 @@
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns `{ start, end }` with the overlapping span, or null on invalid input / no overlap
  *
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // { start: "2024-04-01T00:00:00", end: "2024-06-30T23:59:59" }
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // null
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-02T00:00:00", "2024-12-31T23:59:59") // null
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // null (touching)
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // { start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" } (empty interval strictly inside)
  * @example intervalIntersectionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export declare function intervalIntersectionDateTime(aStart: string, aEnd: string, bStart: string, bEnd: string): {

package/dist/plain/interval/intervalIntersectionDateTime.js

@@ -1,10 +1,17 @@
+// 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 { halfOpenIntersection } from "../../internal/index.js";
+import { isValidDateTime } from "../validate/index.js";
 /**
  * Return the overlapping span of two datetime intervals, or null when they do not overlap.
  *
  * - Uses `Temporal.PlainDateTime.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 moment 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).
  *
@@ -14,9 +21,9 @@ import { plainDateTime } from "../../regex/index.js";
  * @param bEnd ISO 8601 datetime string for the second interval end
  * @returns `{ start, end }` with the overlapping span, or null on invalid input / no overlap
  *
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // { start: "2024-04-01T00:00:00", end: "2024-06-30T23:59:59" }
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-01T00:00:00", "2024-12-31T23:59:59") // null
- * @example intervalIntersectionDateTime("2024-01-01T10:00:00", "2024-06-30T23:59:59", "2024-07-02T00:00:00", "2024-12-31T23:59:59") // null
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T13:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // { start: "2024-01-01T12:00:00", end: "2024-01-01T13:00:00" }
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00", "2024-01-01T17:00:00") // null (touching)
+ * @example intervalIntersectionDateTime("2024-01-01T09:00:00", "2024-01-01T17:00:00", "2024-01-01T12:00:00", "2024-01-01T12:00:00") // { start: "2024-01-01T12:00:00", end: "2024-01-01T12:00:00" } (empty interval strictly inside)
  * @example intervalIntersectionDateTime("invalid", "2024-06-30T23:59:59", "2024-04-01T00:00:00", "2024-12-31T23:59:59") // null
  */
 export function intervalIntersectionDateTime(aStart, aEnd, bStart, bEnd) {
@@ -26,10 +33,10 @@ export function intervalIntersectionDateTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return null;
     }
-    if (!plainDateTime.test(aStart) ||
-        !plainDateTime.test(aEnd) ||
-        !plainDateTime.test(bStart) ||
-        !plainDateTime.test(bEnd)) {
+    if (!isValidDateTime(aStart) ||
+        !isValidDateTime(aEnd) ||
+        !isValidDateTime(bStart) ||
+        !isValidDateTime(bEnd)) {
         return null;
     }
     try {
@@ -43,12 +50,11 @@ export function intervalIntersectionDateTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainDateTime.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainDateTime.compare(aE, bS) < 0 ||
-            Temporal.PlainDateTime.compare(bE, aS) < 0) {
+        const shared = halfOpenIntersection({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainDateTime.compare);
+        if (shared === null) {
             return null;
         }
-        const start = Temporal.PlainDateTime.compare(aS, bS) >= 0 ? aS : bS;
-        const end = Temporal.PlainDateTime.compare(aE, bE) <= 0 ? aE : bE;
+        const { start, end } = shared;
         return { start: start.toString(), end: end.toString() };
     }
     catch {

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

@@ -2,7 +2,12 @@
  * Return the overlapping span of two time intervals, or null when they do not overlap.
  *
  * - Uses `Temporal.PlainTime.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 clock time 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).
  *
@@ -13,8 +18,7 @@
  * @returns `{ start, end }` with the overlapping span, or null on invalid input / no overlap
  *
  * @example intervalIntersectionTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // { start: "12:00:00", end: "17:00:00" }
- * @example intervalIntersectionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "17:00:00", end: "17:00:00" }
- * @example intervalIntersectionTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // null
+ * @example intervalIntersectionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // null (touching)
  * @example intervalIntersectionTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // { start: "10:00:00", end: "11:00:00" }
  * @example intervalIntersectionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */

package/dist/plain/interval/intervalIntersectionTime.js

@@ -1,10 +1,17 @@
+// 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 { halfOpenIntersection } from "../../internal/index.js";
+import { isValidTime } from "../validate/index.js";
 /**
  * Return the overlapping span of two time intervals, or null when they do not overlap.
  *
  * - Uses `Temporal.PlainTime.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 clock time 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).
  *
@@ -15,8 +22,7 @@ import { plainTime } from "../../regex/index.js";
  * @returns `{ start, end }` with the overlapping span, or null on invalid input / no overlap
  *
  * @example intervalIntersectionTime("09:00:00", "17:00:00", "12:00:00", "18:00:00") // { start: "12:00:00", end: "17:00:00" }
- * @example intervalIntersectionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // { start: "17:00:00", end: "17:00:00" }
- * @example intervalIntersectionTime("09:00:00", "17:00:00", "18:00:00", "20:00:00") // null
+ * @example intervalIntersectionTime("09:00:00", "17:00:00", "17:00:00", "18:00:00") // null (touching)
  * @example intervalIntersectionTime("09:00:00", "17:00:00", "10:00:00", "11:00:00") // { start: "10:00:00", end: "11:00:00" }
  * @example intervalIntersectionTime("invalid", "17:00:00", "12:00:00", "18:00:00") // null
  */
@@ -27,10 +33,10 @@ export function intervalIntersectionTime(aStart, aEnd, bStart, bEnd) {
         typeof bEnd !== "string") {
         return null;
     }
-    if (!plainTime.test(aStart) ||
-        !plainTime.test(aEnd) ||
-        !plainTime.test(bStart) ||
-        !plainTime.test(bEnd)) {
+    if (!isValidTime(aStart) ||
+        !isValidTime(aEnd) ||
+        !isValidTime(bStart) ||
+        !isValidTime(bEnd)) {
         return null;
     }
     try {
@@ -44,12 +50,11 @@ export function intervalIntersectionTime(aStart, aEnd, bStart, bEnd) {
         if (Temporal.PlainTime.compare(bS, bE) > 0) {
             return null;
         }
-        if (Temporal.PlainTime.compare(aE, bS) < 0 ||
-            Temporal.PlainTime.compare(bE, aS) < 0) {
+        const shared = halfOpenIntersection({ start: aS, end: aE }, { start: bS, end: bE }, Temporal.PlainTime.compare);
+        if (shared === null) {
             return null;
         }
-        const start = Temporal.PlainTime.compare(aS, bS) >= 0 ? aS : bS;
-        const end = Temporal.PlainTime.compare(aE, bE) <= 0 ? aE : bE;
+        const { start, end } = shared;
         return { start: start.toString(), end: end.toString() };
     }
     catch {

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

@@ -5,16 +5,19 @@
  *   than measuring exact duration — see `intervalCountDate`'s JSDoc for the canonical
  *   11:59pm→12:01am example of the two diverging. `intervalLengthDate` answers "how long is
  *   this interval", `intervalCountDate` answers "how many boundaries does it touch".
- * - Uses `Temporal.Duration.prototype.total`, which resolves calendar units (month, year)
+ * - Uses `Temporal.Duration.prototype.total` semantics, which resolve calendar units (month, year)
  *   against the interval's own start so a partial month is expressed as a true fraction rather
- *   than truncated.
+ *   than truncated (non-ISO calendars follow the same TC39 NudgeToCalendarUnit steps over
+ *   calendar-correct arithmetic).
  * - Returns `0` for a zero-length interval (`start === end`).
  * - 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`
- *   carry the *same* calendar tag, the length is measured in that calendar; otherwise (or if
- *   either is bare ISO) it falls back to Gregorian — same shared-calendar rule as
- *   `intervalCountDate` (E5 decision of record D5).
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ *   carry the *same* calendar tag, the length is measured in that calendar; when they name
+ *   different calendars the result is `null` — same calendar rule as `intervalCountDate` (TC39
+ *   `CalendarEquals`; before 1.16.0 measured 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

package/dist/plain/interval/intervalLengthDate.js

@@ -1,6 +1,32 @@
-import { parseCalendarDatePairForArithmetic, resolveDateTimeUnit, } from "../../internal/index.js";
+import { durationTotal, parseCalendarDatePairForArithmetic, resolveDateTimeUnit, } from "../../internal/index.js";
+import { calendarDateAdd, calendarDateUntil, } from "../../internal/temporalCompat/index.js";
 import { isValidDateUnit } from "../validate/index.js";
 import { isValidDateInterval } from "./validate/index.js";
+const UNIT_FIELD = {
+    year: "years",
+    month: "months",
+    week: "weeks",
+    day: "days",
+};
+function daysBetween(from, to) {
+    return from
+        .withCalendar("iso8601")
+        .until(to.withCalendar("iso8601"), { largestUnit: "days" }).days;
+}
+/**
+ * `Duration.total({ unit, relativeTo: start })` of a non-ISO calendar difference, computed as TC39
+ * `TotalRelativeDuration` → `NudgeToCalendarUnit` does, over the Temporal compat layer's calendar
+ * add and until (CORE-6: the polyfill's own `total` runs its D1/D6/D7-affected arithmetic):
+ * `r1` whole units from `CalendarDateUntil`, plus the days from `start + r1` to `end` over the days
+ * from `start + r1` to `start + (r1 + 1)`, both added with `constrain`. `start <= end`.
+ */
+function calendarLength(start, end, unit) {
+    const field = UNIT_FIELD[unit];
+    const whole = calendarDateUntil(start, end, unit)[field];
+    const lower = calendarDateAdd(start, { [field]: whole }, "constrain");
+    const upper = calendarDateAdd(start, { [field]: whole + 1 }, "constrain");
+    return whole + daysBetween(lower, end) / daysBetween(lower, upper);
+}
 /**
  * Return the exact length of a date interval in `unit`, as a real (possibly fractional) number.
  *
@@ -8,16 +34,19 @@ import { isValidDateInterval } from "./validate/index.js";
  *   than measuring exact duration — see `intervalCountDate`'s JSDoc for the canonical
  *   11:59pm→12:01am example of the two diverging. `intervalLengthDate` answers "how long is
  *   this interval", `intervalCountDate` answers "how many boundaries does it touch".
- * - Uses `Temporal.Duration.prototype.total`, which resolves calendar units (month, year)
+ * - Uses `Temporal.Duration.prototype.total` semantics, which resolve calendar units (month, year)
  *   against the interval's own start so a partial month is expressed as a true fraction rather
- *   than truncated.
+ *   than truncated (non-ISO calendars follow the same TC39 NudgeToCalendarUnit steps over
+ *   calendar-correct arithmetic).
  * - Returns `0` for a zero-length interval (`start === end`).
  * - 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`
- *   carry the *same* calendar tag, the length is measured in that calendar; otherwise (or if
- *   either is bare ISO) it falls back to Gregorian — same shared-calendar rule as
- *   `intervalCountDate` (E5 decision of record D5).
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). When `start` and `end`
+ *   carry the *same* calendar tag, the length is measured in that calendar; when they name
+ *   different calendars the result is `null` — same calendar rule as `intervalCountDate` (TC39
+ *   `CalendarEquals`; before 1.16.0 measured 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
@@ -44,11 +73,14 @@ export function intervalLengthDate(start, end, unit) {
     }
     try {
         const { a: startVal, b: endVal } = parseCalendarDatePairForArithmetic(start, end);
+        if (startVal.calendarId !== "iso8601") {
+            return calendarLength(startVal, endVal, resolvedUnit);
+        }
         const duration = startVal.until(endVal, { largestUnit: resolvedUnit });
         // total() gives the exact (possibly fractional) length, unlike intervalCountDate's
         // boundary-crossing count — e.g. Jan 31 -> Feb 1 is 1 month boundary via intervalCountDate
         // but only a fraction of a month via total().
-        return duration.total({ unit: resolvedUnit, relativeTo: startVal });
+        return durationTotal(duration, resolvedUnit, startVal);
     }
     catch {
         return null;

package/dist/plain/interval/intervalLengthDateTime.js

@@ -1,5 +1,5 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { resolveDateTimeUnit } from "../../internal/index.js";
+import { durationTotal, resolveDateTimeUnit } from "../../internal/index.js";
 import { isValidDateTimeUnit } from "../validate/index.js";
 import { isValidDateTimeInterval } from "./validate/index.js";
 /**
@@ -42,7 +42,7 @@ export function intervalLengthDateTime(start, end, unit) {
         const duration = startVal.until(endVal, { largestUnit: resolvedUnit });
         // total() gives the exact elapsed length, unlike intervalCountDateTime's boundary-crossing
         // count — 23:59 -> 00:01 is 2 day boundaries via intervalCountDateTime but ~0.0014 days here.
-        return duration.total({ unit: resolvedUnit, relativeTo: startVal });
+        return durationTotal(duration, resolvedUnit, startVal);
     }
     catch {
         return null;

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

@@ -1,22 +1,20 @@
 /**
  * Return how many distinct calendar dates two date intervals share.
  *
- * - Counts the number of dates touched by the closed intersection
- *   `[max(aStart, bStart), min(aEnd, bEnd)]` — inclusive of both endpoints.
- * - Adjacent intervals (e.g. `aEnd === bStart`) share one date and count as `1`.
- * - Returns `0` when the intervals do not overlap at all (a well-defined answer, not
- *   invalid input).
+ * - Half-open: an interval holds every date `d` with `start <= d < end`. The count is the number
+ *   of days in the intersection `[max(aStart, bStart), min(aEnd, bEnd))`, that is
+ *   `min(aEnd, bEnd) - max(aStart, bStart)` in days.
+ * - Touching intervals (`aEnd === bStart`) share no day and count `0`; so does an empty interval.
+ * - Returns `0` when the intervals share no day (a well-defined answer, not invalid input).
  * - Returns `null` if either interval is invalid (`start > end`).
  * - Returns `null` on invalid input (wrong type, malformed strings).
- * - Diverges from date-fns's `getOverlappingDaysInIntervals`, which rounds up elapsed
- *   24-hour periods instead of counting calendar dates (its own doc example — Jan 10-20 vs
- *   Jan 17-21 — returns 3 there, 4 here). To reproduce date-fns's number, compose
- *   `intervalIntersectionDate` with `intervalCountDate`:
- *   `const span = intervalIntersectionDate(aStart, aEnd, bStart, bEnd); span ? intervalCountDate(span.start, span.end, "day") : 0;`
  *
- * - Accepts GMT calendar-annotated PlainDate strings — E5 (issue #78). A day is a day in every
- *   supported calendar, so this returns the same count whether or not the endpoints are
- *   calendar-tagged, and arguments may carry different or no tags (D4).
+ * - Accepts RFC 9557 calendar-annotated PlainDate strings — E5 (issue #78). All four arguments
+ *   must name the same calendar (a bare ISO string names `iso8601`); different calendars return
+ *   `null`, as Temporal's `until` throws when `CalendarEquals` is false.
+ * - Compatibility: before 1.16.0 arguments could name different calendars. 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
@@ -24,10 +22,11 @@
  * @param bEnd ISO 8601 date string for the second interval end, optionally calendar-annotated
  * @returns number of shared calendar dates, `0` when disjoint, or null on invalid input
  *
- * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // 91
- * @example intervalOverlappingDaysDate("2024-01-01", "2024-12-31", "2024-02-01", "2024-02-29") // 29
- * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // 1 (adjacent)
- * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-07-01", "2024-12-31") // 0 (disjoint)
+ * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-04-01", "2024-12-31") // 90 (04-01 up to, not including, 06-30)
+ * @example intervalOverlappingDaysDate("2024-01-01", "2024-12-31", "2024-02-01", "2024-02-29") // 28
+ * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-06-29", "2024-12-31") // 1
+ * @example intervalOverlappingDaysDate("2024-01-01", "2024-06-30", "2024-06-30", "2024-12-31") // 0 (touching)
+ * @example intervalOverlappingDaysDate("2024-10-01", "2024-10-31", "2024-10-03[u-ca=hebrew]", "2024-11-15") // null (different calendars)
  * @example intervalOverlappingDaysDate("invalid", "2024-06-30", "2024-04-01", "2024-12-31") // null
  */
 export declare function intervalOverlappingDaysDate(aStart: string, aEnd: string, bStart: string, bEnd: string): number | null;