@northguild/gmt 1.18.0 → 1.19.0

package/dist/zoned/validate/hasDaylightSaving.d.ts

@@ -17,9 +17,10 @@
  *   2016 on, although its clocks went forward in March 2016.
  * - Read from the runtime's time zone data, so the answer can change when that data does.
  * - Returns false for an invalid timeZone, an invalid `at`, an options argument that is not an
- *   object, and a fixed offset.
+ *   object, and a fixed UTC offset, with or without seconds (`"+05:30"`, `"-00:44:30"`).
  *
- * @param timeZone timeZone identifier to check
+ * @param timeZone IANA name or UTC offset: a time zone identifier (`+05:30`, `+0530`, `-08`) or a
+ *   stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param options optional setting for the reference instant
  * @returns boolean indicating whether the timeZone observes DST, or false on invalid input
  *
@@ -34,6 +35,7 @@
  * @example hasDaylightSaving("+05:00", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Invalid/Zone", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("America/New_York", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("-00:44:30", { at: "1970-01-01T12:00:00Z" }) // false (a fixed offset)
  */
 export declare function hasDaylightSaving(timeZone: string, options?: {
     /**

package/dist/zoned/validate/hasDaylightSaving.js

@@ -1,6 +1,5 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { isOptionsArgument, observesDaylightTime, parseInstantNanoseconds, } from "../../internal/index.js";
-import { isValidTimeZone } from "./isValidTimeZone.js";
+import { isOptionsArgument, observesDaylightTime, parseInstantNanoseconds, zoneFrame, } from "../../internal/index.js";
 /**
  * Check whether a timeZone observes daylight saving time at a reference instant.
  *
@@ -20,9 +19,10 @@ import { isValidTimeZone } from "./isValidTimeZone.js";
  *   2016 on, although its clocks went forward in March 2016.
  * - Read from the runtime's time zone data, so the answer can change when that data does.
  * - Returns false for an invalid timeZone, an invalid `at`, an options argument that is not an
- *   object, and a fixed offset.
+ *   object, and a fixed UTC offset, with or without seconds (`"+05:30"`, `"-00:44:30"`).
  *
- * @param timeZone timeZone identifier to check
+ * @param timeZone IANA name or UTC offset: a time zone identifier (`+05:30`, `+0530`, `-08`) or a
+ *   stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param options optional setting for the reference instant
  * @returns boolean indicating whether the timeZone observes DST, or false on invalid input
  *
@@ -37,21 +37,27 @@ import { isValidTimeZone } from "./isValidTimeZone.js";
  * @example hasDaylightSaving("+05:00", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("Invalid/Zone", { at: "2024-01-15T12:00:00Z" }) // false
  * @example hasDaylightSaving("America/New_York", { at: "2024-01-15" }) // false (not an instant)
+ * @example hasDaylightSaving("-00:44:30", { at: "1970-01-01T12:00:00Z" }) // false (a fixed offset)
  */
 export function hasDaylightSaving(timeZone, options) {
-    if (!isValidTimeZone(timeZone) || !isOptionsArgument(options)) {
+    const frame = zoneFrame(timeZone);
+    // A stored offset with seconds is a fixed offset: it observes no daylight time, as "-00:45"
+    // observes none.
+    if (frame === null ||
+        frame.shiftNanoseconds !== 0n ||
+        !isOptionsArgument(options)) {
         return false;
     }
     try {
         const at = options?.at;
         if (at === undefined) {
-            return observesDaylightTime(Temporal.Now.zonedDateTimeISO(timeZone));
+            return observesDaylightTime(Temporal.Now.zonedDateTimeISO(frame.timeZone));
         }
         const epochNanoseconds = parseInstantNanoseconds(at);
         if (epochNanoseconds === null) {
             return false;
         }
-        return observesDaylightTime(Temporal.Instant.fromEpochNanoseconds(epochNanoseconds).toZonedDateTimeISO(timeZone));
+        return observesDaylightTime(Temporal.Instant.fromEpochNanoseconds(epochNanoseconds).toZonedDateTimeISO(frame.timeZone));
     }
     catch {
         return false;

package/dist/zoned/validate/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./hasDaylightSaving.js";
 export * from "./isValidCalendarZonedDateTime.js";
+export * from "./isValidRfc2822DateTime.js";
+export * from "./isValidRfc3339DateTime.js";
 export * from "./isValidTimeZone.js";
 export * from "./isValidZonedDateTime.js";
 export * from "./isValidZonedRange.js";

package/dist/zoned/validate/index.js

@@ -1,5 +1,7 @@
 export * from "./hasDaylightSaving.js";
 export * from "./isValidCalendarZonedDateTime.js";
+export * from "./isValidRfc2822DateTime.js";
+export * from "./isValidRfc3339DateTime.js";
 export * from "./isValidTimeZone.js";
 export * from "./isValidZonedDateTime.js";
 export * from "./isValidZonedRange.js";

package/dist/zoned/validate/isValidRfc2822DateTime.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Return true when `value` is a real RFC 5322 (RFC 2822) date-time: the date an email `Date:`
+ * header carries, such as `Fri, 15 Mar 2024 14:30:00 -0400`.
+ *
+ * - True exactly when `parseRfc2822` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Reads what a conformant receiver must**, which is more than the strict `rfc2822DateTime`
+ *   pattern matches: RFC 5322 §3.3 folding white space, comments, names in any case and a year of
+ *   more than four digits, and the §4 obsolete syntax (2- and 3-digit years, military and other
+ *   alphabetic zones). `parseRfc2822` lists each form.
+ * - Checks the calendar as well as the shape. The pattern matches a day that does not exist:
+ *   `31 Feb`, `29 Feb 2023` and `31 Jun` are false here.
+ * - **The day-of-week must match the date.** RFC 5322 §3.3: "the day-of-week (if included) MUST be
+ *   the day implied by the date". The pattern does not check it.
+ * - False for an hour above 23, a minute above 59, zone minutes above 59 and an offset of 24
+ *   hours or more, all of which the pattern matches. False for a second of 60: GMT rejects leap
+ *   seconds.
+ * - False for a non-string. Read the value with `parseRfc2822`; write one with `formatRfc2822`.
+ *
+ * @param value candidate RFC 5322 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0400") // true
+ * @example isValidRfc2822DateTime("5 Jan 2024 09:00:00 GMT") // true (no day-of-week, 1-digit day)
+ * @example isValidRfc2822DateTime("fri,15 Mar 24 14:30 -0400 (EDT)") // true (obsolete 2-digit year, comment; the rfc2822DateTime pattern does not match it)
+ * @example isValidRfc2822DateTime("Sat, 15 Mar 2024 14:30:00 -0400") // false (15 Mar 2024 was a Friday; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Wed, 29 Feb 2023 14:30:00 -0400") // false (2023 has no 29 February; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0460") // false (zone minutes above 59; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00") // false (no zone)
+ * @example isValidRfc2822DateTime("not a date") // false
+ */
+export declare function isValidRfc2822DateTime(value: string): boolean;

package/dist/zoned/validate/isValidRfc2822DateTime.js

@@ -0,0 +1,35 @@
+import { parseRfc2822 } from "../parse/parseRfc2822.js";
+/**
+ * Return true when `value` is a real RFC 5322 (RFC 2822) date-time: the date an email `Date:`
+ * header carries, such as `Fri, 15 Mar 2024 14:30:00 -0400`.
+ *
+ * - True exactly when `parseRfc2822` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - **Reads what a conformant receiver must**, which is more than the strict `rfc2822DateTime`
+ *   pattern matches: RFC 5322 §3.3 folding white space, comments, names in any case and a year of
+ *   more than four digits, and the §4 obsolete syntax (2- and 3-digit years, military and other
+ *   alphabetic zones). `parseRfc2822` lists each form.
+ * - Checks the calendar as well as the shape. The pattern matches a day that does not exist:
+ *   `31 Feb`, `29 Feb 2023` and `31 Jun` are false here.
+ * - **The day-of-week must match the date.** RFC 5322 §3.3: "the day-of-week (if included) MUST be
+ *   the day implied by the date". The pattern does not check it.
+ * - False for an hour above 23, a minute above 59, zone minutes above 59 and an offset of 24
+ *   hours or more, all of which the pattern matches. False for a second of 60: GMT rejects leap
+ *   seconds.
+ * - False for a non-string. Read the value with `parseRfc2822`; write one with `formatRfc2822`.
+ *
+ * @param value candidate RFC 5322 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0400") // true
+ * @example isValidRfc2822DateTime("5 Jan 2024 09:00:00 GMT") // true (no day-of-week, 1-digit day)
+ * @example isValidRfc2822DateTime("fri,15 Mar 24 14:30 -0400 (EDT)") // true (obsolete 2-digit year, comment; the rfc2822DateTime pattern does not match it)
+ * @example isValidRfc2822DateTime("Sat, 15 Mar 2024 14:30:00 -0400") // false (15 Mar 2024 was a Friday; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Wed, 29 Feb 2023 14:30:00 -0400") // false (2023 has no 29 February; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00 -0460") // false (zone minutes above 59; the rfc2822DateTime pattern matches it)
+ * @example isValidRfc2822DateTime("Fri, 15 Mar 2024 14:30:00") // false (no zone)
+ * @example isValidRfc2822DateTime("not a date") // false
+ */
+export function isValidRfc2822DateTime(value) {
+    return parseRfc2822(value) !== "";
+}

package/dist/zoned/validate/isValidRfc3339DateTime.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Return true when `value` is a real RFC 3339 date-time: an ISO 8601 date and time that always
+ * states its UTC offset, as `Z` or `±HH:MM` (RFC 3339 §5.6).
+ *
+ * - True exactly when `parseRfc3339` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - Checks the calendar as well as the shape. The `rfc3339DateTime` pattern proves the shape
+ *   alone, so it matches a day that does not exist: 29 February in a common year and 31 June are
+ *   false here.
+ * - Accepts `T`, `t` or a single space between the date and the time, `Z` or `z`, a numeric
+ *   offset from `-23:59` to `+23:59`, and up to nine fraction digits.
+ * - False for a leap second (`:60`), although §5.6 `time-second` admits it: GMT rejects leap
+ *   seconds because Temporal would read one as `:59`.
+ * - False for GMT's own zoned strings, which carry a bracketed zone (`...+00:00[UTC]`): that
+ *   annotation is not RFC 3339. Check those with `isValidZonedDateTime`.
+ * - False for a non-string. Read the value with `parseRfc3339`; write one with `formatRfc3339`.
+ *
+ * @param value candidate RFC 3339 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00-04:00") // true
+ * @example isValidRfc3339DateTime("2024-03-15t14:30:00z") // true (lower-case t and z)
+ * @example isValidRfc3339DateTime("2024-03-15 14:30:00.5Z") // true (space separator, fraction)
+ * @example isValidRfc3339DateTime("2023-02-29T10:00:00Z") // false (2023 has no 29 February; the rfc3339DateTime pattern matches it)
+ * @example isValidRfc3339DateTime("2024-06-31T10:00:00Z") // false (June has 30 days; the rfc3339DateTime pattern matches it)
+ * @example isValidRfc3339DateTime("2016-12-31T23:59:60Z") // false (leap second)
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00") // false (no offset)
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00+00:00[UTC]") // false (bracketed zone: use isValidZonedDateTime)
+ * @example isValidRfc3339DateTime("not a date") // false
+ */
+export declare function isValidRfc3339DateTime(value: string): boolean;

package/dist/zoned/validate/isValidRfc3339DateTime.js

@@ -0,0 +1,34 @@
+import { parseRfc3339 } from "../parse/parseRfc3339.js";
+/**
+ * Return true when `value` is a real RFC 3339 date-time: an ISO 8601 date and time that always
+ * states its UTC offset, as `Z` or `±HH:MM` (RFC 3339 §5.6).
+ *
+ * - True exactly when `parseRfc3339` returns a zoned string for the same value: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - Checks the calendar as well as the shape. The `rfc3339DateTime` pattern proves the shape
+ *   alone, so it matches a day that does not exist: 29 February in a common year and 31 June are
+ *   false here.
+ * - Accepts `T`, `t` or a single space between the date and the time, `Z` or `z`, a numeric
+ *   offset from `-23:59` to `+23:59`, and up to nine fraction digits.
+ * - False for a leap second (`:60`), although §5.6 `time-second` admits it: GMT rejects leap
+ *   seconds because Temporal would read one as `:59`.
+ * - False for GMT's own zoned strings, which carry a bracketed zone (`...+00:00[UTC]`): that
+ *   annotation is not RFC 3339. Check those with `isValidZonedDateTime`.
+ * - False for a non-string. Read the value with `parseRfc3339`; write one with `formatRfc3339`.
+ *
+ * @param value candidate RFC 3339 date-time string
+ * @returns boolean indicating validity
+ *
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00-04:00") // true
+ * @example isValidRfc3339DateTime("2024-03-15t14:30:00z") // true (lower-case t and z)
+ * @example isValidRfc3339DateTime("2024-03-15 14:30:00.5Z") // true (space separator, fraction)
+ * @example isValidRfc3339DateTime("2023-02-29T10:00:00Z") // false (2023 has no 29 February; the rfc3339DateTime pattern matches it)
+ * @example isValidRfc3339DateTime("2024-06-31T10:00:00Z") // false (June has 30 days; the rfc3339DateTime pattern matches it)
+ * @example isValidRfc3339DateTime("2016-12-31T23:59:60Z") // false (leap second)
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00") // false (no offset)
+ * @example isValidRfc3339DateTime("2024-03-15T14:30:00+00:00[UTC]") // false (bracketed zone: use isValidZonedDateTime)
+ * @example isValidRfc3339DateTime("not a date") // false
+ */
+export function isValidRfc3339DateTime(value) {
+    return parseRfc3339(value) !== "";
+}

package/dist/zoned/validate/isValidTimeZone.d.ts

@@ -3,7 +3,7 @@
  *
  * - Uses Temporal.ZonedDateTime.from to test timezone validity.
  * - Uses the `timeZoneLike` regex to check the identifier's shape: Temporal's
- *   `TimeZoneIdentifier` grammar (§14.6.2).
+ *   `TimeZoneIdentifier` grammar (§13.31).
  * - Accepts every IANA Zone and Link name the runtime accepts, including single-component names
  *   (`UTC`, `Japan`, `Zulu`, `EST5EDT`, `GMT+0`), in any letter case (ECMA-402 matches
  *   identifiers ASCII-case-insensitively, so `utc` is as valid as `america/new_york`).
@@ -12,6 +12,9 @@
  * - Returns false for invalid timezone formats.
  * - Compatibility: earlier releases required a `/` in every name except `UTC` and `GMT`. To keep
  *   that narrower rule, also require `timeZone.includes("/")` or `"UTC"`/`"GMT"`.
+ * - A stored offset with seconds (`-00:44:30`) is false here and true for `isValidUtcOffset`. To
+ *   check what a function with a zoneless result accepts, use
+ *   `isValidTimeZone(x) || isValidUtcOffset(x)`.
  *
  * @param timeZone timeZone identifier to validate
  * @returns boolean indicating validity
@@ -23,6 +26,7 @@
  * @example isValidTimeZone("utc") // true (case-insensitive)
  * @example isValidTimeZone("+05:00") // true (an offset identifier)
  * @example isValidTimeZone("+05:00:00") // false (no seconds in an offset identifier)
+ * @example isValidTimeZone("-00:44:30") // false (a stored offset with seconds; `isValidUtcOffset` accepts it)
  * @example "Japan".includes("/") // false (the earlier slash-only rule)
  */
 export declare function isValidTimeZone(timeZone: string): boolean;

package/dist/zoned/validate/isValidTimeZone.js

@@ -1,11 +1,11 @@
 import { timeZoneLike } from "../../regex/index.js";
-import { zonedDateTimeFrom } from "../../internal/index.js";
+import { zonedDateTimeFrom } from "../../internal/zonedWallClock.js";
 /**
  * Validate whether a string is a valid time zone identifier: an IANA name or a UTC offset.
  *
  * - Uses Temporal.ZonedDateTime.from to test timezone validity.
  * - Uses the `timeZoneLike` regex to check the identifier's shape: Temporal's
- *   `TimeZoneIdentifier` grammar (§14.6.2).
+ *   `TimeZoneIdentifier` grammar (§13.31).
  * - Accepts every IANA Zone and Link name the runtime accepts, including single-component names
  *   (`UTC`, `Japan`, `Zulu`, `EST5EDT`, `GMT+0`), in any letter case (ECMA-402 matches
  *   identifiers ASCII-case-insensitively, so `utc` is as valid as `america/new_york`).
@@ -14,6 +14,9 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * - Returns false for invalid timezone formats.
  * - Compatibility: earlier releases required a `/` in every name except `UTC` and `GMT`. To keep
  *   that narrower rule, also require `timeZone.includes("/")` or `"UTC"`/`"GMT"`.
+ * - A stored offset with seconds (`-00:44:30`) is false here and true for `isValidUtcOffset`. To
+ *   check what a function with a zoneless result accepts, use
+ *   `isValidTimeZone(x) || isValidUtcOffset(x)`.
  *
  * @param timeZone timeZone identifier to validate
  * @returns boolean indicating validity
@@ -25,6 +28,7 @@ import { zonedDateTimeFrom } from "../../internal/index.js";
  * @example isValidTimeZone("utc") // true (case-insensitive)
  * @example isValidTimeZone("+05:00") // true (an offset identifier)
  * @example isValidTimeZone("+05:00:00") // false (no seconds in an offset identifier)
+ * @example isValidTimeZone("-00:44:30") // false (a stored offset with seconds; `isValidUtcOffset` accepts it)
  * @example "Japan".includes("/") // false (the earlier slash-only rule)
  */
 export function isValidTimeZone(timeZone) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@northguild/gmt",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Temporal-based date and time utilities with timezone support and polyfill integration",
   "keywords": [
     "date",
@@ -81,18 +81,39 @@
       "duration/validate": [
         "./dist/duration/validate/index.d.ts"
       ],
+      "duty": [
+        "./dist/duty/index.d.ts"
+      ],
+      "duty/calculate": [
+        "./dist/duty/calculate/index.d.ts"
+      ],
+      "duty/validate": [
+        "./dist/duty/validate/index.d.ts"
+      ],
       "instant": [
         "./dist/instant/index.d.ts"
       ],
       "instant/convert": [
         "./dist/instant/convert/index.d.ts"
       ],
+      "instant/validate": [
+        "./dist/instant/validate/index.d.ts"
+      ],
       "intermodal": [
         "./dist/intermodal/index.d.ts"
       ],
       "intermodal/calculate": [
         "./dist/intermodal/calculate/index.d.ts"
       ],
+      "intermodal/format": [
+        "./dist/intermodal/format/index.d.ts"
+      ],
+      "intermodal/parse": [
+        "./dist/intermodal/parse/index.d.ts"
+      ],
+      "intermodal/validate": [
+        "./dist/intermodal/validate/index.d.ts"
+      ],
       "interval": [
         "./dist/interval/index.d.ts"
       ],
@@ -331,6 +352,18 @@
       "types": "./dist/duration/validate/index.d.ts",
       "default": "./dist/duration/validate/index.js"
     },
+    "./duty": {
+      "types": "./dist/duty/index.d.ts",
+      "default": "./dist/duty/index.js"
+    },
+    "./duty/calculate": {
+      "types": "./dist/duty/calculate/index.d.ts",
+      "default": "./dist/duty/calculate/index.js"
+    },
+    "./duty/validate": {
+      "types": "./dist/duty/validate/index.d.ts",
+      "default": "./dist/duty/validate/index.js"
+    },
     "./instant": {
       "types": "./dist/instant/index.d.ts",
       "default": "./dist/instant/index.js"
@@ -339,6 +372,10 @@
       "types": "./dist/instant/convert/index.d.ts",
       "default": "./dist/instant/convert/index.js"
     },
+    "./instant/validate": {
+      "types": "./dist/instant/validate/index.d.ts",
+      "default": "./dist/instant/validate/index.js"
+    },
     "./intermodal": {
       "types": "./dist/intermodal/index.d.ts",
       "default": "./dist/intermodal/index.js"
@@ -347,6 +384,18 @@
       "types": "./dist/intermodal/calculate/index.d.ts",
       "default": "./dist/intermodal/calculate/index.js"
     },
+    "./intermodal/format": {
+      "types": "./dist/intermodal/format/index.d.ts",
+      "default": "./dist/intermodal/format/index.js"
+    },
+    "./intermodal/parse": {
+      "types": "./dist/intermodal/parse/index.d.ts",
+      "default": "./dist/intermodal/parse/index.js"
+    },
+    "./intermodal/validate": {
+      "types": "./dist/intermodal/validate/index.d.ts",
+      "default": "./dist/intermodal/validate/index.js"
+    },
     "./interval": {
       "types": "./dist/interval/index.d.ts",
       "default": "./dist/interval/index.js"

package/skills/gmt-arithmetic/SKILL.md

@@ -11,12 +11,18 @@ description: >
   (BusinessCalendar, RollConvention, isBusinessDay, addBusinessDays,
   subtractBusinessDays, businessDaysBetween, nextBusinessDay,
   previousBusinessDay, rollDate, mergeCalendars), overflow "constrain" month-end
-  clamping, splitIntervalByUnit* stepping from the anchor, maxPieces limits,
+  clamping, splitIntervalByUnit* anchor stepping, maxPieces limits,
   intervalCount* matching bucketRange, RFC 9557 calendar strings, and the
-  correct-at-the-edges guarantees at the first and last representable instant. A
-  routing pointer, not an API dump.
+  correct-at-the-edges guarantees at the representable limits, and hours-of-work
+  rules over a duty log (evaluateDutyLog, dutyViolations, dutyDayFor).
 sources:
-  - 'northguild/gmt:README.md'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/core-date-operations/plain-arithmetic.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/core-date-operations/durations.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/core-date-operations/spans.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/core-date-operations/business-calendars.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/core-date-operations/calendar-systems.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/intervals/*.mdx'
+  - 'northguild/gmt:apps/dox/src/content/docs/guides/concepts/correct-at-the-edges.mdx'
   - 'northguild/gmt:packages/gmt/src/plain/calculate/index.ts'
   - 'northguild/gmt:packages/gmt/src/duration/index.ts'
   - 'northguild/gmt:packages/gmt/src/interval/index.ts'
@@ -29,10 +35,12 @@ sources:
   - 'northguild/gmt:packages/gmt/src/calendar/business/index.ts'
   - 'northguild/gmt:packages/gmt/src/types/business-calendar.ts'
   - 'northguild/gmt:packages/gmt/src/types/roll-convention.ts'
+  - 'northguild/gmt:packages/gmt/src/duty/index.ts'
+  - 'northguild/gmt:packages/gmt/src/types/duty.ts'
 metadata:
   type: core
   library: '@northguild/gmt'
-  library_version: '1.18.0'
+  library_version: '1.19.0'
 ---
 
 # GMT Arithmetic
@@ -53,12 +61,40 @@ and full interval set operations.
   these windows?".
 - The user is measuring elapsed time — a profile, a trace span, a sensor
   interval — and wants milliseconds or nanoseconds rather than a `Duration`.
+- The user checks hours of work against rules: driving or duty caps, rest in
+  every 24 hours, a free day in seven, a monthly record of violations.
 
 ## Core rules
 
 1. **`add*` takes a `{ unit: number }` object, not an ISO duration string.**
    `addDate("2024-03-15", { days: 5 })` works; `addDate("2024-03-15", "P5D")`
    returns `""`. Use `diffDateAsDuration` / `addDuration` for duration strings.
+   An amount has those two shapes, and each function takes one of them:
+   - **A unit object is checked the same way everywhere.** A unit outside the
+     function's set returns the sentinel: `addDate` takes years to days,
+     `addTime` hours to nanoseconds. So does an own key that is no unit name,
+     and an amount that is not a whole finite number. A unit set to `undefined`
+     is absent, as Temporal reads it.
+   - **`durationFromUnits` is the bridge from the object to the string.** It
+     takes all ten units and carries nothing into a larger unit. Seconds and
+     smaller are written as one decimal number of seconds. Pass its result to
+     any function that takes a duration string.
+   - **`totalUnits` totals the object in one call.** It takes exact units only:
+     days down to nanoseconds, a day being 24 hours. A year, a month or a week
+     returns `null`, as a key and as the unit asked for.
+   - **`totalDuration` totals a duration string**, and takes `relativeTo` for a
+     calendar amount. To total `{ months: 1 }`, build the string with
+     `durationFromUnits` and pass it here.
+
+   ```typescript
+   durationFromUnits({ minutes: 15 }); // "PT15M"
+   durationFromUnits({ minutes: 90 }); // "PT90M" — not carried into hours
+   totalUnits({ minutes: 15 }, "seconds"); // 900
+   totalUnits({ weeks: 1 }, "days"); // null — write { days: 7 }
+   totalUnits("PT15M", "seconds"); // null — a duration string goes to totalDuration
+   totalDuration("PT36H", "days"); // 1.5
+   totalDuration(durationFromUnits({ months: 1 }), "days", { relativeTo: "2024-02-01" }); // 29
+   ```
 2. **Arithmetic clamps; parsers reject.** `overflow` defaults to `"constrain"`,
    Temporal's default: January 31 plus one month is February 29, and
    `addDate("2024-02-29", { years: 1 })` is `"2025-02-28"`. Pass
@@ -96,9 +132,10 @@ and full interval set operations.
    hour on its spring-forward counts 2 hours, and a range over `Pacific/Apia`'s
    deleted 30 December 2011 does not count that day. `intervalCountUnix` counts
    in `options.timeZone`, UTC by default (`"local"` for the system zone).
-5. **Calendar units need `relativeTo`.** `durationAs`, `normalizeDuration`, and
+5. **Calendar units need `relativeTo`.** `totalDuration`, `normalizeDuration`, and
    `compareDurations` return `null`/`""` for year/month/week arithmetic without
-   a `relativeTo` anchor — a month is not a fixed length. A calendar-annotated
+   a `relativeTo` anchor — a month is not a fixed length. `totalUnits` takes no
+   `relativeTo`, so it always returns `null` for those units. A calendar-annotated
    `relativeTo` is read as Temporal reads it: zoned when it has a time zone
    annotation, otherwise a date, and its calendar must be a `CalendarSystem`.
    - `round*` accept singular or plural `smallestUnit` names (`"hour"` or
@@ -213,9 +250,45 @@ and full interval set operations.
     survives only if it is a working day in every input, and returns `null` for an
     empty list. Narrow inputs with `isValidBusinessCalendar` /
     `isValidRollConvention`.
-13. **Read the README.** This skill is a routing pointer. For full option shapes,
-   locale matrices, and code examples, read the installed package's `README.md`
-   and the source JSDoc of the function you intend to call.
+13. **Hours of work are rules over a duty log, and every number is the
+    caller's.** A log is `{ status, start, end }[]` in the caller's own status
+    words, ordered and non-overlapping (`isValidDutyLog`). A rule is one of 13
+    `DutyRule` kinds (`cumulativeCap`, `elapsedWindow`, `requiredInterruption`,
+    `rollingCap`, `fixedPeriodCap`, `restRequirement`, `freePeriod`,
+    `restBeforeDuty`, `quota`, `dueBy`, `pattern`, `occurrenceCap`,
+    `usageLookback`) with no default limit; GMT names no regulation.
+    `evaluateDutyLog(log, at, rules, { timeZone, dayStartTime?, disambiguation? })`
+    reports every rule at one instant; `dutyViolations` lists each violation in a
+    range once, by its worst window, in the range it began in.
+
+    ```typescript
+    evaluateDutyLog(log, "2024-01-01T21:30:00Z", [{ label: "11 driving", kind: "cumulativeCap",
+      statuses: ["driving"], cap: "PT11H", since: { statuses: ["off"], consecutive: "PT10H" } }],
+      { timeZone: "UTC" }).violations; // [{ label: "11 driving", used: "PT11H30M", limit: "PT11H", … }]
+    ```
+
+    - `{ elapsed: "PT24H" }` slides; `{ operatorDays }`, `{ calendarDays }`,
+      `{ isoWeeks }`, `{ calendarMonths }`, `{ calendarYears }` are whole local
+      periods in `timeZone` (28 calendar days across a fall-back are 673 hours).
+    - The operator day is `dutyDayFor(instant, { timeZone, dayStartTime })`,
+      never local midnight; a rule counting `operatorDays` needs `dayStartTime`.
+    - The log is read up to `at`; unlogged time is neither work nor rest. To
+      check a roster, append the plan and set `at` to its end.
+    - A paired rest is three floors (`PairSpec`), not two integers:
+      `qualifyingRestPairs`.
+    - A count of periods is 10,000 at most, alone or times `adjacent`,
+      `lookback` or `periods`. `fixedPeriodCap.period` and `occurrenceCap.per`
+      are a `LocalPeriod`: a count, never `elapsed`.
+    - `dutyViolations` reads only the time the log covers, and each check reads
+      the log as it stood then, so a record only grows as the log does.
+    - Nested caps are separate rules, reported separately.
+14. **Read the docs site.** This skill is a routing pointer. For full option
+    shapes, locale matrices, and code examples, read these:
+    - `https://gmt-dox.northguild.workers.dev/llms.txt` is the map of every docs page.
+    - Each page has a `.md` twin that holds its text, for example
+      `https://gmt-dox.northguild.workers.dev/guides/core-date-operations/plain-arithmetic.md`.
+    - The JSDoc of the function you intend to call ships in the installed
+      package: `node_modules/@northguild/gmt/dist/**/*.d.ts`.
 
 ## Key functions
 
@@ -231,9 +304,12 @@ and full interval set operations.
   `startOfQuarterForDate`, `getLocaleStartOfWeek` (zoned boundaries: see the
   `gmt-timezone` skill)
 - **Durations (ISO 8601)**: `isValidDuration`, `parseDuration`, `addDuration`,
-  `subtractDuration`, `normalizeDuration`, `durationAs`, `formatDuration`,
+  `subtractDuration`, `normalizeDuration`, `totalDuration`, `formatDuration`,
   `negateDuration`, `absDuration`, `compareDurations`, `getDurationUnit`,
   `getDurationSign`
+- **Unit objects (`{ unit: number }`)**: `durationFromUnits` (object to
+  duration string), `totalUnits` (object to one total), type
+  `ExactDurationUnit`
 - **Diff-to-duration bridge**: `diffDateAsDuration`,
   `diffZonedAsDuration`, `diffUnixAsDuration`, `diffUtcAsDuration`
 - **Interval algebra (half-open, instants)**: `isValidInterval`,
@@ -247,6 +323,11 @@ and full interval set operations.
   `intervalLengthDate`, `intervalDivideEquallyDate`, `mergeIntervalsDate` (each
   with `DateTime`/`Zoned`/`Unix`/`Utc` variants where the type supports it)
 
+- **Hours of work**: `evaluateDutyLog`, `dutyViolations`, `dutyDayFor`,
+  `dutyTotals`, `longestRun`, `qualifyingRests`, `qualifyingRestPairs`,
+  `isValidDutyLog`, types `DutyEntry`, `DutyRule`, `Period`, `LocalPeriod`,
+  `DutyReport`
+
 ## Namespace selection
 
 - `plain/*` — timezone-free dates, times, datetimes
@@ -256,9 +337,15 @@ and full interval set operations.
 - `duration/*` — ISO 8601 duration strings
 - `span/*` — elapsed and wall-clock spans as raw numbers
 - `interval/*` — half-open interval algebra over instant strings
+- `duty/*` — hours-of-work rules over a duty log
 
 ## References
 
-- [README — Quick Start](README.md)
+- [Docs map for agents (llms.txt)](https://gmt-dox.northguild.workers.dev/llms.txt)
+- [Plain arithmetic guide](https://gmt-dox.northguild.workers.dev/guides/core-date-operations/plain-arithmetic/)
+- [Durations guide](https://gmt-dox.northguild.workers.dev/guides/core-date-operations/durations/)
+- [Spans guide](https://gmt-dox.northguild.workers.dev/guides/core-date-operations/spans/)
+- [Business calendars guide](https://gmt-dox.northguild.workers.dev/guides/core-date-operations/business-calendars/)
 - [Interval algebra reference](/reference/interval/calculate/intersectIntervals)
 - [Interval guides](/guides/intervals/interval-basics/)
+- [Hours of work guide](https://gmt-dox.northguild.workers.dev/guides/intervals/hours-of-work/)