@northguild/gmt 1.18.0 → 1.20.0

package/dist/workforce/calculate/evaluateDutyLog.js

@@ -0,0 +1,75 @@
+import { Temporal } from "../../internal/temporal.js";
+import { parseInstantNanoseconds } from "../../internal/index.js";
+import { evaluateDutyRules, prepareDutyCall } from "../../internal/dutyEngine.js";
+/**
+ * Evaluate every hours-of-work rule over a duty log at one instant, and report each one whether
+ * or not it binds.
+ *
+ * GMT implements no regulation: each rule is a shape, and every number in it is the caller's. A
+ * regime is the array of rules the caller assembles and labels. GMT reports totals, what is left
+ * and what failed; it does not decide dispatch, fitness or eligibility.
+ *
+ * - The log is read as it stands at `at`: later entries are ignored and one straddling `at` is cut
+ *   there. Time no entry covers is in no status, so it is neither work nor rest. That includes the
+ *   time before the log's first entry: give a log that reaches back as far as the longest rule
+ *   looks, or a rest rule fails for want of logged rest. A planned roster is the same call with
+ *   the plan appended and `at` set to its end.
+ * - This is the strict reading, for a check before dispatch. `dutyViolations` reads a record the
+ *   other way: it does not judge a rest rule on a window that starts before the log's first
+ *   entry, since the log cannot say what happened then. Both read the log's first entry as the
+ *   start of a stretch without rest for `maxGap`, as the end of a rest would be.
+ * - Every outcome carries `used`, `limit`, `remaining`, `window`, `dueBy` and `resetAt`, so the
+ *   second-tightest limit is visible before it binds. Failed rules are listed again under
+ *   `violations` or, with `severity: "advisory"`, under `advisories` only.
+ * - A duration in a `Period` is a sliding window ending at `at`; `operatorDays` are the days of
+ *   `dutyDayFor`; calendar days, ISO weeks, months and years are local periods in `timeZone`,
+ *   23 or 25 hours long across a one-hour clock change. Each outcome names its `periodBasis`.
+ * - The local periods are the ones holding the last instant before `at`, so at a boundary the
+ *   period just ended is judged: a roster ending at midnight is checked through its last day.
+ * - A window that runs past `at` (the rest of today, this week) has not failed a minimum while
+ *   the minimum could still be met with rest from `at` to its end; a cap fails as soon as it is
+ *   passed.
+ * - Endpoints are UTC instants ending in "Z"; durations are ISO 8601 with hours as the largest
+ *   unit (`"PT49H30M"`).
+ * - Returns `null` when the log fails `isValidDutyLog`, when `at` is not an ISO 8601 instant
+ *   string, when a rule is malformed (an unknown kind, a status list that is empty or holds a
+ *   non-string, a duration that is not positive exact time, a malformed period, a duplicate
+ *   label, a count of periods past 10,000 alone or times `adjacent`, `lookback` or `periods`, a
+ *   `containing.count` past 10,000), when `options.timeZone` is invalid, when a rule counts
+ *   `operatorDays` without `options.dayStartTime`, when a window, or a requirement `orFactor`
+ *   scales, falls outside Temporal's range, when a count of free periods passes
+ *   `Number.MAX_SAFE_INTEGER`, and when one run of rest in a `freePeriod` window holds more than
+ *   20,000 of its `containing` windows (about 54 years of a daily window).
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param at ISO 8601 instant string to evaluate at
+ * @param rules the rules, every number the caller's
+ * @param options the reference zone and the operator day
+ * @returns the report, or null on invalid input
+ *
+ * @example evaluateDutyLog([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "driving", start: "2024-01-01T10:00:00Z", end: "2024-01-01T21:00:00Z" }], "2024-01-01T21:00:00Z", [{ label: "11 driving", kind: "cumulativeCap", statuses: ["driving"], cap: "PT11H", since: { statuses: ["off"], consecutive: "PT10H" } }], { timeZone: "UTC" }) // { at: "2024-01-01T21:00:00Z", outcomes: [{ label: "11 driving", kind: "cumulativeCap", severity: "violation", satisfied: true, used: "PT11H", limit: "PT11H", remaining: "PT0S", window: { start: "2024-01-01T10:00:00Z", end: "2024-01-01T21:00:00Z" }, periodBasis: null, dueBy: null, resetAt: "2024-01-01T10:00:00Z" }], violations: [], advisories: [] }
+ * @example evaluateDutyLog([{ status: "driving", start: "2024-01-01T10:00:00Z", end: "2024-01-01T21:00:00Z" }], "2024-01-01T21:00:00Z", [{ label: "60 in 7", kind: "rollingCap", statuses: ["driving"], cap: "PT60H", window: { operatorDays: 7 } }], { timeZone: "UTC" }) // null — operator days without dayStartTime
+ * @example evaluateDutyLog([], "2024-01-01T00:00:00Z", [], { timeZone: "UTC" }) // { at: "2024-01-01T00:00:00Z", outcomes: [], violations: [], advisories: [] }
+ * @example evaluateDutyLog([{ status: "on", start: "2024-01-01T02:00:00Z", end: "2024-01-01T01:00:00Z" }], "2024-01-01T03:00:00Z", [], { timeZone: "UTC" }) // null — inverted entry
+ */
+export function evaluateDutyLog(log, at, rules, options) {
+    try {
+        const instant = typeof at === "string" ? parseInstantNanoseconds(at) : null;
+        const call = prepareDutyCall(log, rules, options);
+        if (instant === null || call === null) {
+            return null;
+        }
+        const outcomes = evaluateDutyRules(call.context, call.rules, instant);
+        return {
+            at: Temporal.Instant.fromEpochNanoseconds(instant).toString(),
+            outcomes,
+            violations: outcomes.filter((outcome) => !outcome.satisfied && outcome.severity === "violation"),
+            advisories: outcomes.filter((outcome) => !outcome.satisfied && outcome.severity === "advisory"),
+        };
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
+        return null;
+    }
+}

package/dist/workforce/calculate/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./dutyDayFor.js";
+export * from "./dutyTotals.js";
+export * from "./dutyViolations.js";
+export * from "./evaluateDutyLog.js";
+export * from "./longestRun.js";
+export * from "./qualifyingRestPairs.js";
+export * from "./qualifyingRests.js";

package/dist/workforce/calculate/index.js

@@ -0,0 +1,7 @@
+export * from "./dutyDayFor.js";
+export * from "./dutyTotals.js";
+export * from "./dutyViolations.js";
+export * from "./evaluateDutyLog.js";
+export * from "./longestRun.js";
+export * from "./qualifyingRestPairs.js";
+export * from "./qualifyingRests.js";

package/dist/workforce/calculate/longestRun.d.ts

@@ -0,0 +1,28 @@
+import type { DutyEntry, Interval } from "../../types/index.js";
+/**
+ * Return the longest unbroken stretch a duty log spends in any of `statuses` inside a window.
+ *
+ * - A stretch is a run of touching entries whose statuses are all in `statuses`; another status
+ *   or an unlogged gap ends it. Each run is cut to `window` (half-open) before it is measured.
+ * - On a tie the earlier stretch is returned.
+ * - `interval` is in UTC instants ending in "Z"; `duration` is an exact ISO 8601 duration with
+ *   hours as the largest unit.
+ * - Returns `null` when no stretch falls inside the window, which is also the sentinel: when the
+ *   log fails `isValidDutyLog`, when `window` is not a valid `Interval`, and when `statuses` is not
+ *   an array of strings.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param window `{ start, end }` record of ISO 8601 instant strings to search inside
+ * @param statuses the statuses a stretch is made of
+ * @returns `{ interval, duration }` of the longest stretch, or null when there is none or on invalid input
+ *
+ * @example longestRun([{ status: "driving", start: "2024-01-01T00:00:00Z", end: "2024-01-01T03:00:00Z" }, { status: "onDuty", start: "2024-01-01T03:00:00Z", end: "2024-01-01T04:00:00Z" }, { status: "driving", start: "2024-01-01T04:00:00Z", end: "2024-01-01T08:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving"]) // { interval: { start: "2024-01-01T04:00:00Z", end: "2024-01-01T08:00:00Z" }, duration: "PT4H" }
+ * @example longestRun([{ status: "driving", start: "2024-01-01T00:00:00Z", end: "2024-01-01T03:00:00Z" }, { status: "onDuty", start: "2024-01-01T03:00:00Z", end: "2024-01-01T04:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving", "onDuty"]) // { interval: { start: "2024-01-01T00:00:00Z", end: "2024-01-01T04:00:00Z" }, duration: "PT4H" } — touching entries join
+ * @example longestRun([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T08:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving"]) // null — none
+ */
+export declare function longestRun(log: DutyEntry[], window: Interval, statuses: string[]): {
+    /** The stretch, as UTC instants ending in "Z", cut to the window. */
+    interval: Interval;
+    /** Its length, an exact ISO 8601 duration with hours as the largest unit. */
+    duration: string;
+} | null;

package/dist/workforce/calculate/longestRun.js

@@ -0,0 +1,54 @@
+import { Temporal } from "../../internal/temporal.js";
+import { formatHourDuration, parseIntervalNanoseconds } from "../../internal/index.js";
+import { parseDutyLog } from "../../internal/dutyLog.js";
+import { clipRuns, readStatusList, runsOf } from "../../internal/dutyEngine.js";
+/**
+ * Return the longest unbroken stretch a duty log spends in any of `statuses` inside a window.
+ *
+ * - A stretch is a run of touching entries whose statuses are all in `statuses`; another status
+ *   or an unlogged gap ends it. Each run is cut to `window` (half-open) before it is measured.
+ * - On a tie the earlier stretch is returned.
+ * - `interval` is in UTC instants ending in "Z"; `duration` is an exact ISO 8601 duration with
+ *   hours as the largest unit.
+ * - Returns `null` when no stretch falls inside the window, which is also the sentinel: when the
+ *   log fails `isValidDutyLog`, when `window` is not a valid `Interval`, and when `statuses` is not
+ *   an array of strings.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param window `{ start, end }` record of ISO 8601 instant strings to search inside
+ * @param statuses the statuses a stretch is made of
+ * @returns `{ interval, duration }` of the longest stretch, or null when there is none or on invalid input
+ *
+ * @example longestRun([{ status: "driving", start: "2024-01-01T00:00:00Z", end: "2024-01-01T03:00:00Z" }, { status: "onDuty", start: "2024-01-01T03:00:00Z", end: "2024-01-01T04:00:00Z" }, { status: "driving", start: "2024-01-01T04:00:00Z", end: "2024-01-01T08:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving"]) // { interval: { start: "2024-01-01T04:00:00Z", end: "2024-01-01T08:00:00Z" }, duration: "PT4H" }
+ * @example longestRun([{ status: "driving", start: "2024-01-01T00:00:00Z", end: "2024-01-01T03:00:00Z" }, { status: "onDuty", start: "2024-01-01T03:00:00Z", end: "2024-01-01T04:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving", "onDuty"]) // { interval: { start: "2024-01-01T00:00:00Z", end: "2024-01-01T04:00:00Z" }, duration: "PT4H" } — touching entries join
+ * @example longestRun([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T08:00:00Z" }], { start: "2024-01-01T00:00:00Z", end: "2024-01-02T00:00:00Z" }, ["driving"]) // null — none
+ */
+export function longestRun(log, window, statuses) {
+    try {
+        const entries = parseDutyLog(log);
+        const bounds = parseIntervalNanoseconds(window);
+        const wanted = readStatusList(statuses);
+        if (entries === null || bounds === null || wanted === null) {
+            return null;
+        }
+        const runs = clipRuns(runsOf(entries, wanted), bounds.start, bounds.end);
+        const longest = runs.reduce((best, run) => best === undefined || run.end - run.start > best.end - best.start
+            ? run
+            : best, undefined);
+        if (longest === undefined) {
+            return null;
+        }
+        return {
+            interval: {
+                start: Temporal.Instant.fromEpochNanoseconds(longest.start).toString(),
+                end: Temporal.Instant.fromEpochNanoseconds(longest.end).toString(),
+            },
+            duration: formatHourDuration(longest.end - longest.start),
+        };
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
+        return null;
+    }
+}

package/dist/workforce/calculate/qualifyingRestPairs.d.ts

@@ -0,0 +1,37 @@
+import type { DutyEntry, PairSpec, RestPair } from "../../types/index.js";
+/**
+ * Return every paired rest in a duty log: two separate rests that together count as one, because
+ * they meet all three floors of `spec.pair`.
+ *
+ * A pair is three constraints, not two integers: with `{ eachAtLeast: "PT2H", oneAtLeast: "PT7H",
+ * combinedAtLeast: "PT10H" }`, 7.5 + 2.5 hours and 8 + 2 qualify, and 6 + 4 does not.
+ *
+ * - Rests are runs of touching entries in `spec.statuses`. Two rests in a row pair; either may be
+ *   the longer.
+ * - A rest of `spec.minimum` or more is a full rest on its own: it pairs with nothing, and no pair
+ *   spans it. A rest shorter than `eachAtLeast` is neither half of a pair nor a break between two.
+ * - Pairs chain: rests of 7, 3 and 7 hours give two pairs, (7, 3) and (3, 7).
+ * - Intervals are UTC instants ending in "Z", in log order.
+ * - `[]` is both a legitimate result and the sentinel: returned when the log fails
+ *   `isValidDutyLog`, when `spec` is not an object, when `statuses` is not an array of strings,
+ *   and when `minimum` or a floor of `pair` is not a positive ISO 8601 duration of exact time.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param spec the statuses a rest is made of, the length of a full rest, and the pair's floors
+ * @returns the pairs as `{ first, second }` records, or [] on invalid input
+ *
+ * @example qualifyingRestPairs([{ status: "sleeper", start: "2024-01-01T00:00:00Z", end: "2024-01-01T07:30:00Z" }, { status: "work", start: "2024-01-01T07:30:00Z", end: "2024-01-01T11:30:00Z" }, { status: "off", start: "2024-01-01T11:30:00Z", end: "2024-01-01T14:00:00Z" }], { statuses: ["off", "sleeper"], minimum: "PT10H", pair: { eachAtLeast: "PT2H", oneAtLeast: "PT7H", combinedAtLeast: "PT10H" } }) // [{ first: { start: "2024-01-01T00:00:00Z", end: "2024-01-01T07:30:00Z" }, second: { start: "2024-01-01T11:30:00Z", end: "2024-01-01T14:00:00Z" } }]
+ * @example qualifyingRestPairs([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T06:00:00Z" }, { status: "work", start: "2024-01-01T06:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "off", start: "2024-01-01T10:00:00Z", end: "2024-01-01T14:00:00Z" }], { statuses: ["off"], minimum: "PT10H", pair: { eachAtLeast: "PT2H", oneAtLeast: "PT7H", combinedAtLeast: "PT10H" } }) // [] — 6 + 4: neither is 7
+ * @example qualifyingRestPairs([], { statuses: ["off"], minimum: "PT10H" }) // [] — no pair
+ */
+export declare function qualifyingRestPairs(log: DutyEntry[], spec: {
+    /** The statuses a rest is made of. Touching entries in any of them are one rest. */
+    statuses: string[];
+    /**
+     * The length of a full rest, a positive ISO 8601 duration of exact time (`"PT10H"`). A rest
+     * this long or longer is not half of a pair.
+     */
+    minimum: string;
+    /** The three floors the two rests must meet. */
+    pair: PairSpec;
+}): RestPair[];

package/dist/workforce/calculate/qualifyingRestPairs.js

@@ -0,0 +1,58 @@
+import { Temporal } from "../../internal/temporal.js";
+import { isObject, nonNegativeExactDurationNanoseconds } from "../../internal/index.js";
+import { readStatusList, restPairs, runsOf } from "../../internal/dutyEngine.js";
+import { parseDutyLog } from "../../internal/dutyLog.js";
+import { parsePairSpec } from "../../internal/dutyRules.js";
+/**
+ * Return every paired rest in a duty log: two separate rests that together count as one, because
+ * they meet all three floors of `spec.pair`.
+ *
+ * A pair is three constraints, not two integers: with `{ eachAtLeast: "PT2H", oneAtLeast: "PT7H",
+ * combinedAtLeast: "PT10H" }`, 7.5 + 2.5 hours and 8 + 2 qualify, and 6 + 4 does not.
+ *
+ * - Rests are runs of touching entries in `spec.statuses`. Two rests in a row pair; either may be
+ *   the longer.
+ * - A rest of `spec.minimum` or more is a full rest on its own: it pairs with nothing, and no pair
+ *   spans it. A rest shorter than `eachAtLeast` is neither half of a pair nor a break between two.
+ * - Pairs chain: rests of 7, 3 and 7 hours give two pairs, (7, 3) and (3, 7).
+ * - Intervals are UTC instants ending in "Z", in log order.
+ * - `[]` is both a legitimate result and the sentinel: returned when the log fails
+ *   `isValidDutyLog`, when `spec` is not an object, when `statuses` is not an array of strings,
+ *   and when `minimum` or a floor of `pair` is not a positive ISO 8601 duration of exact time.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param spec the statuses a rest is made of, the length of a full rest, and the pair's floors
+ * @returns the pairs as `{ first, second }` records, or [] on invalid input
+ *
+ * @example qualifyingRestPairs([{ status: "sleeper", start: "2024-01-01T00:00:00Z", end: "2024-01-01T07:30:00Z" }, { status: "work", start: "2024-01-01T07:30:00Z", end: "2024-01-01T11:30:00Z" }, { status: "off", start: "2024-01-01T11:30:00Z", end: "2024-01-01T14:00:00Z" }], { statuses: ["off", "sleeper"], minimum: "PT10H", pair: { eachAtLeast: "PT2H", oneAtLeast: "PT7H", combinedAtLeast: "PT10H" } }) // [{ first: { start: "2024-01-01T00:00:00Z", end: "2024-01-01T07:30:00Z" }, second: { start: "2024-01-01T11:30:00Z", end: "2024-01-01T14:00:00Z" } }]
+ * @example qualifyingRestPairs([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T06:00:00Z" }, { status: "work", start: "2024-01-01T06:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "off", start: "2024-01-01T10:00:00Z", end: "2024-01-01T14:00:00Z" }], { statuses: ["off"], minimum: "PT10H", pair: { eachAtLeast: "PT2H", oneAtLeast: "PT7H", combinedAtLeast: "PT10H" } }) // [] — 6 + 4: neither is 7
+ * @example qualifyingRestPairs([], { statuses: ["off"], minimum: "PT10H" }) // [] — no pair
+ */
+export function qualifyingRestPairs(log, spec) {
+    try {
+        const entries = parseDutyLog(log);
+        if (entries === null || !isObject(spec)) {
+            return [];
+        }
+        const { statuses, minimum, pair } = spec;
+        const wanted = readStatusList(statuses);
+        const fullRest = nonNegativeExactDurationNanoseconds(minimum);
+        const floors = parsePairSpec(pair);
+        if (wanted === null ||
+            fullRest === null ||
+            fullRest === 0n ||
+            floors === null) {
+            return [];
+        }
+        const text = (nanoseconds) => Temporal.Instant.fromEpochNanoseconds(nanoseconds).toString();
+        return restPairs(runsOf(entries, wanted), fullRest, floors).map(({ first, second }) => ({
+            first: { start: text(first.start), end: text(first.end) },
+            second: { start: text(second.start), end: text(second.end) },
+        }));
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
+        return [];
+    }
+}

package/dist/workforce/calculate/qualifyingRests.d.ts

@@ -0,0 +1,27 @@
+import type { DutyEntry, Interval } from "../../types/index.js";
+/**
+ * Return every rest of at least `minimum` in a duty log: the runs of touching entries in any of
+ * `spec.statuses` that last that long.
+ *
+ * - A run is ended by another status or an unlogged gap, never by a change between two of
+ *   `statuses`: an off period running straight into a sleeper-berth period is one rest.
+ * - The whole log is read. Intervals are UTC instants ending in "Z", in log order.
+ * - For two shorter rests that count together, use `qualifyingRestPairs`.
+ * - `[]` is both a legitimate result and the sentinel: returned when the log fails
+ *   `isValidDutyLog`, when `spec` is not an object, when `statuses` is not an array of strings,
+ *   and when `minimum` is not a positive ISO 8601 duration of exact time.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param spec the statuses a rest is made of and the shortest that counts
+ * @returns the rests' `{ start, end }` records, or [] on invalid input
+ *
+ * @example qualifyingRests([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "work", start: "2024-01-01T10:00:00Z", end: "2024-01-01T16:00:00Z" }, { status: "off", start: "2024-01-01T16:00:00Z", end: "2024-01-01T23:00:00Z" }], { statuses: ["off"], minimum: "PT10H" }) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }]
+ * @example qualifyingRests([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T05:00:00Z" }, { status: "sleeper", start: "2024-01-01T05:00:00Z", end: "2024-01-01T12:00:00Z" }], { statuses: ["off", "sleeper"], minimum: "PT10H" }) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T12:00:00Z" }] — one rest
+ * @example qualifyingRests([], { statuses: ["off"], minimum: "PT0S" }) // [] — a zero minimum
+ */
+export declare function qualifyingRests(log: DutyEntry[], spec: {
+    /** The statuses a rest is made of. Touching entries in any of them are one rest. */
+    statuses: string[];
+    /** The shortest rest returned, a positive ISO 8601 duration of exact time (`"PT10H"`). */
+    minimum: string;
+}): Interval[];

package/dist/workforce/calculate/qualifyingRests.js

@@ -0,0 +1,49 @@
+import { Temporal } from "../../internal/temporal.js";
+import { isObject, nonNegativeExactDurationNanoseconds } from "../../internal/index.js";
+import { parseDutyLog } from "../../internal/dutyLog.js";
+import { readStatusList, runsOf } from "../../internal/dutyEngine.js";
+/**
+ * Return every rest of at least `minimum` in a duty log: the runs of touching entries in any of
+ * `spec.statuses` that last that long.
+ *
+ * - A run is ended by another status or an unlogged gap, never by a change between two of
+ *   `statuses`: an off period running straight into a sleeper-berth period is one rest.
+ * - The whole log is read. Intervals are UTC instants ending in "Z", in log order.
+ * - For two shorter rests that count together, use `qualifyingRestPairs`.
+ * - `[]` is both a legitimate result and the sentinel: returned when the log fails
+ *   `isValidDutyLog`, when `spec` is not an object, when `statuses` is not an array of strings,
+ *   and when `minimum` is not a positive ISO 8601 duration of exact time.
+ *
+ * @param log the duty log, ordered and non-overlapping
+ * @param spec the statuses a rest is made of and the shortest that counts
+ * @returns the rests' `{ start, end }` records, or [] on invalid input
+ *
+ * @example qualifyingRests([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "work", start: "2024-01-01T10:00:00Z", end: "2024-01-01T16:00:00Z" }, { status: "off", start: "2024-01-01T16:00:00Z", end: "2024-01-01T23:00:00Z" }], { statuses: ["off"], minimum: "PT10H" }) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }]
+ * @example qualifyingRests([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T05:00:00Z" }, { status: "sleeper", start: "2024-01-01T05:00:00Z", end: "2024-01-01T12:00:00Z" }], { statuses: ["off", "sleeper"], minimum: "PT10H" }) // [{ start: "2024-01-01T00:00:00Z", end: "2024-01-01T12:00:00Z" }] — one rest
+ * @example qualifyingRests([], { statuses: ["off"], minimum: "PT0S" }) // [] — a zero minimum
+ */
+export function qualifyingRests(log, spec) {
+    try {
+        const entries = parseDutyLog(log);
+        if (entries === null || !isObject(spec)) {
+            return [];
+        }
+        const { statuses, minimum } = spec;
+        const wanted = readStatusList(statuses);
+        const floor = nonNegativeExactDurationNanoseconds(minimum);
+        if (wanted === null || floor === null || floor === 0n) {
+            return [];
+        }
+        return runsOf(entries, wanted)
+            .filter((run) => run.end - run.start >= floor)
+            .map((run) => ({
+            start: Temporal.Instant.fromEpochNanoseconds(run.start).toString(),
+            end: Temporal.Instant.fromEpochNanoseconds(run.end).toString(),
+        }));
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
+        return [];
+    }
+}

package/dist/workforce/index.d.ts

@@ -0,0 +1,3 @@
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
+export * from "./calculate/index.js";
+export * from "./validate/index.js";

package/dist/workforce/index.js

@@ -0,0 +1,4 @@
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
+export * from "./calculate/index.js";
+export * from "./validate/index.js";

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

@@ -0,0 +1 @@
+export * from "./isValidDutyLog.js";

package/dist/workforce/validate/index.js

@@ -0,0 +1 @@
+export * from "./isValidDutyLog.js";

package/dist/workforce/validate/isValidDutyLog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Validate whether a value is a duty log every `workforce/` function accepts.
+ *
+ * - True for an array of `{ status, start, end }` entries where `status` is a string and `start`
+ *   and `end` are ISO 8601 instant strings (offset required, no leap second), `end` after `start`.
+ * - Entries must be ordered by `start` and must not overlap. One may start exactly where the
+ *   previous one ends, since entries are half-open, or later, leaving a gap. Order is by instant,
+ *   not text.
+ * - `[]` is a valid, empty log. Extra keys on an entry are ignored.
+ * - Every other `workforce/` function returns its sentinel for a log this rejects.
+ * - Returns `false` for a non-array, an entry that is not an object, a non-string status, a bound
+ *   that is not an instant, a zero-length or inverted entry, and entries out of order or
+ *   overlapping.
+ *
+ * @param log candidate array of `{ status, start, end }` records
+ * @returns boolean indicating whether the log is valid
+ *
+ * @example isValidDutyLog([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "driving", start: "2024-01-01T10:00:00Z", end: "2024-01-01T15:00:00Z" }]) // true
+ * @example isValidDutyLog([]) // true — an empty log
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T02:00:00Z", end: "2024-01-01T01:00:00Z" }]) // false — inverted
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T00:00:00Z", end: "2024-01-01T02:00:00Z" }, { status: "off", start: "2024-01-01T01:59:59Z", end: "2024-01-01T03:00:00Z" }]) // false — overlapping
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T00:00:00", end: "2024-01-01T01:00:00Z" }]) // false — no offset
+ */
+export declare function isValidDutyLog(log: unknown): boolean;

package/dist/workforce/validate/isValidDutyLog.js

@@ -0,0 +1,34 @@
+import { parseDutyLog } from "../../internal/dutyLog.js";
+/**
+ * Validate whether a value is a duty log every `workforce/` function accepts.
+ *
+ * - True for an array of `{ status, start, end }` entries where `status` is a string and `start`
+ *   and `end` are ISO 8601 instant strings (offset required, no leap second), `end` after `start`.
+ * - Entries must be ordered by `start` and must not overlap. One may start exactly where the
+ *   previous one ends, since entries are half-open, or later, leaving a gap. Order is by instant,
+ *   not text.
+ * - `[]` is a valid, empty log. Extra keys on an entry are ignored.
+ * - Every other `workforce/` function returns its sentinel for a log this rejects.
+ * - Returns `false` for a non-array, an entry that is not an object, a non-string status, a bound
+ *   that is not an instant, a zero-length or inverted entry, and entries out of order or
+ *   overlapping.
+ *
+ * @param log candidate array of `{ status, start, end }` records
+ * @returns boolean indicating whether the log is valid
+ *
+ * @example isValidDutyLog([{ status: "off", start: "2024-01-01T00:00:00Z", end: "2024-01-01T10:00:00Z" }, { status: "driving", start: "2024-01-01T10:00:00Z", end: "2024-01-01T15:00:00Z" }]) // true
+ * @example isValidDutyLog([]) // true — an empty log
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T02:00:00Z", end: "2024-01-01T01:00:00Z" }]) // false — inverted
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T00:00:00Z", end: "2024-01-01T02:00:00Z" }, { status: "off", start: "2024-01-01T01:59:59Z", end: "2024-01-01T03:00:00Z" }]) // false — overlapping
+ * @example isValidDutyLog([{ status: "on", start: "2024-01-01T00:00:00", end: "2024-01-01T01:00:00Z" }]) // false — no offset
+ */
+export function isValidDutyLog(log) {
+    try {
+        return parseDutyLog(log) !== null;
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile
+        // argument is invalid input, not an exception.
+        return false;
+    }
+}

package/dist/zoned/calculate/addZoned.d.ts

@@ -6,11 +6,11 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  * - Validates duration units and values.
  * - Accepts an RFC 9557 calendar-annotated zoned string (as `Temporal.ZonedDateTime#toString()`
  *   and `convertZonedToCalendar` write it, e.g.
- *   `"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`), not just a bare ISO string (E7,
+ *   `"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`), not just a bare ISO string (E7,
  *   issue #152). Calendar-unit arithmetic ("add 1 month") resolves against that calendar (a Hebrew
  *   leap month, an Ethiopic Pagumen) **and** the DST rules of the zone, in one operation: Hebrew
- *   Adar I 15 in `America/New_York` `+1 month` moves both the month (Adar I -> Adar II) and the
- *   offset (-05:00 -> -04:00). The result carries the same calendar annotation. A bare ISO string
+ *   Adar I 25 in `Europe/London` `+1 month` moves both the month (Adar I -> Adar II) and the
+ *   offset (+00:00 -> +01:00). The result carries the same calendar annotation. A bare ISO string
  *   is the `"iso8601"` calendar and returns a bare ISO string.
  * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, the `[u-ca=<id>]`
  *   annotation after the zone, canonical calendar ids); see `isValidCalendarZonedDateTime`.
@@ -23,7 +23,7 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  *   forward, whatever `disambiguation` said, so "earlier" matched "compatible" and "reject" did not
  *   fail. Pass "compatible" (or omit it) to keep the forward result.
  * - Compatibility: before 1.16.0 a non-"compatible" `disambiguation` re-resolved the final wall
- *   clock (so `+ { minutes: 10 }` from `01:30-05:00` with "earlier" returned `01:40-04:00`, 50
+ *   clock (so `+ { minutes: 10 }` from `01:30+00:00` with "earlier" returned `01:40+01:00`, 50
  *   minutes earlier in exact time). To get that value, re-resolve the result's wall clock:
  *   `setZoned(result, { hour, minute, second }, { disambiguation, offset: "ignore" })`.
  * - There is no `offset` option (removed in 1.16.0): the intermediate wall clock is resolved from
@@ -36,20 +36,20 @@ import type { DateTimeDurationUnit, Disambiguation, Overflow } from "../../types
  * @param optionsArg optional settings for resolving a DST gap or overlap and an out-of-range date
  * @returns zoned ISO 8601 string on success, or "" on invalid input
  *
- * @example addZoned("2024-02-29T14:30:45.123-05:00[America/New_York]", { days: 1 }) // "2024-03-01T14:30:45.123-05:00[America/New_York]"
+ * @example addZoned("2024-02-29T14:30:45.123+00:00[Europe/London]", { days: 1 }) // "2024-03-01T14:30:45.123+00:00[Europe/London]"
  * @example addZoned("invalid", { days: 1 }) // ""
- * @example addZoned("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", { months: 1 }) // "2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]" (Adar I -> Adar II, EST -> EDT in one call)
+ * @example addZoned("2024-03-05T14:30:00+00:00[Europe/London][u-ca=hebrew]", { months: 1 }) // "2024-04-04T14:30:00+01:00[Europe/London][u-ca=hebrew]" (Adar I -> Adar II, GMT -> BST in one call)
  * @example addZoned("2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]", { days: 1 }) // "2019-05-01T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]" (Heisei 31 -> Reiwa 1)
  * @example addZoned("2025-09-05T00:30:00-04:00[America/Santiago][u-ca=ethioaa]", { months: 1 }, { overflow: "reject" }) // "" (day 30 does not exist in the 5-day Pagumen)
- * @example addZoned("2024-03-10T14:30:00-04:00[u-ca=hebrew][America/New_York]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
- * @example addZoned("2024-11-02T01:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "later" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example addZoned("2024-11-02T01:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }) // "2024-03-10T03:30:00-04:00[America/New_York]" (02:30 on 10 March is in the spring-forward gap; "compatible" moves it forward an hour)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "earlier" }) // "2024-03-10T01:30:00-05:00[America/New_York]" (spring-forward gap; "earlier" moves it back an hour)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
- * @example addZoned("2024-11-03T01:30:00-05:00[America/New_York]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-11-03T01:40:00-05:00[America/New_York]" (exact time — disambiguation never re-resolves it)
- * @example setZoned(addZoned("2024-11-03T01:30:00-05:00[America/New_York]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-11-03T01:40:00-04:00[America/New_York]" (pre-1.16.0 result)
- * @example addZoned("2024-01-31T12:00:00-05:00[America/New_York]", { months: 1 }, { overflow: "reject" }) // ""
+ * @example addZoned("2024-03-10T14:30:00+05:30[u-ca=hebrew][Asia/Kolkata]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
+ * @example addZoned("2024-10-26T01:30:00+01:00[Europe/London]", { days: 1 }, { disambiguation: "later" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example addZoned("2024-10-26T01:30:00+01:00[Europe/London]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }) // "2024-10-06T03:30:00+11:00[Australia/Sydney]" (02:30 on 6 October is in the spring-forward gap; "compatible" moves it forward an hour)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }, { disambiguation: "earlier" }) // "2024-10-06T01:30:00+10:00[Australia/Sydney]" (spring-forward gap; "earlier" moves it back an hour)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
+ * @example addZoned("2024-10-27T01:30:00+00:00[Europe/London]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-10-27T01:40:00+00:00[Europe/London]" (exact time — disambiguation never re-resolves it)
+ * @example setZoned(addZoned("2024-10-27T01:30:00+00:00[Europe/London]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-10-27T01:40:00+01:00[Europe/London]" (pre-1.16.0 result)
+ * @example addZoned("2024-01-31T12:00:00+02:00[Africa/Johannesburg]", { months: 1 }, { overflow: "reject" }) // ""
  */
 export declare function addZoned(value: string, units: Partial<Record<DateTimeDurationUnit, number>>, optionsArg?: {
     /**

package/dist/zoned/calculate/addZoned.js

@@ -1,5 +1,5 @@
 // fallow-ignore-file code-duplication -- sibling variant keeps its own guard, parse and try/catch, by design
-import { addToZonedDisambiguated, calendarSystemOfZonedValue, formatZonedInCalendar, isValidAmount, parseCalendarZonedValue, resolveOverflow, } from "../../internal/index.js";
+import { addToZonedDisambiguated, calendarSystemOfZonedValue, formatZonedInCalendar, parseCalendarZonedValue, readDurationUnits, resolveOverflow, } from "../../internal/index.js";
 import { isValidDateTimeDurationUnit } from "../../plain/validate/index.js";
 import { isValidCalendarZonedDateTime } from "../validate/index.js";
 import { isOptionsArgument } from "../../internal/isObject.js";
@@ -11,11 +11,11 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * - Validates duration units and values.
  * - Accepts an RFC 9557 calendar-annotated zoned string (as `Temporal.ZonedDateTime#toString()`
  *   and `convertZonedToCalendar` write it, e.g.
- *   `"2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]"`), not just a bare ISO string (E7,
+ *   `"2024-02-24T14:30:00+00:00[Europe/London][u-ca=hebrew]"`), not just a bare ISO string (E7,
  *   issue #152). Calendar-unit arithmetic ("add 1 month") resolves against that calendar (a Hebrew
  *   leap month, an Ethiopic Pagumen) **and** the DST rules of the zone, in one operation: Hebrew
- *   Adar I 15 in `America/New_York` `+1 month` moves both the month (Adar I -> Adar II) and the
- *   offset (-05:00 -> -04:00). The result carries the same calendar annotation. A bare ISO string
+ *   Adar I 25 in `Europe/London` `+1 month` moves both the month (Adar I -> Adar II) and the
+ *   offset (+00:00 -> +01:00). The result carries the same calendar annotation. A bare ISO string
  *   is the `"iso8601"` calendar and returns a bare ISO string.
  * - Compatibility: since 1.16.0 calendar strings are RFC 9557 (ISO digits, the `[u-ca=<id>]`
  *   annotation after the zone, canonical calendar ids); see `isValidCalendarZonedDateTime`.
@@ -28,7 +28,7 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  *   forward, whatever `disambiguation` said, so "earlier" matched "compatible" and "reject" did not
  *   fail. Pass "compatible" (or omit it) to keep the forward result.
  * - Compatibility: before 1.16.0 a non-"compatible" `disambiguation` re-resolved the final wall
- *   clock (so `+ { minutes: 10 }` from `01:30-05:00` with "earlier" returned `01:40-04:00`, 50
+ *   clock (so `+ { minutes: 10 }` from `01:30+00:00` with "earlier" returned `01:40+01:00`, 50
  *   minutes earlier in exact time). To get that value, re-resolve the result's wall clock:
  *   `setZoned(result, { hour, minute, second }, { disambiguation, offset: "ignore" })`.
  * - There is no `offset` option (removed in 1.16.0): the intermediate wall clock is resolved from
@@ -41,20 +41,20 @@ import { optionOrDefault } from "../../internal/optionOrDefault.js";
  * @param optionsArg optional settings for resolving a DST gap or overlap and an out-of-range date
  * @returns zoned ISO 8601 string on success, or "" on invalid input
  *
- * @example addZoned("2024-02-29T14:30:45.123-05:00[America/New_York]", { days: 1 }) // "2024-03-01T14:30:45.123-05:00[America/New_York]"
+ * @example addZoned("2024-02-29T14:30:45.123+00:00[Europe/London]", { days: 1 }) // "2024-03-01T14:30:45.123+00:00[Europe/London]"
  * @example addZoned("invalid", { days: 1 }) // ""
- * @example addZoned("2024-02-24T14:30:00-05:00[America/New_York][u-ca=hebrew]", { months: 1 }) // "2024-03-25T14:30:00-04:00[America/New_York][u-ca=hebrew]" (Adar I -> Adar II, EST -> EDT in one call)
+ * @example addZoned("2024-03-05T14:30:00+00:00[Europe/London][u-ca=hebrew]", { months: 1 }) // "2024-04-04T14:30:00+01:00[Europe/London][u-ca=hebrew]" (Adar I -> Adar II, GMT -> BST in one call)
  * @example addZoned("2019-04-30T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]", { days: 1 }) // "2019-05-01T12:00:00+09:00[Asia/Tokyo][u-ca=japanese]" (Heisei 31 -> Reiwa 1)
  * @example addZoned("2025-09-05T00:30:00-04:00[America/Santiago][u-ca=ethioaa]", { months: 1 }, { overflow: "reject" }) // "" (day 30 does not exist in the 5-day Pagumen)
- * @example addZoned("2024-03-10T14:30:00-04:00[u-ca=hebrew][America/New_York]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
- * @example addZoned("2024-11-02T01:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "later" }) // "2024-11-03T01:30:00-05:00[America/New_York]" (fall-back overlap resolved; default "compatible" would return the -04:00 instant instead)
- * @example addZoned("2024-11-02T01:30:00-04:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }) // "2024-03-10T03:30:00-04:00[America/New_York]" (02:30 on 10 March is in the spring-forward gap; "compatible" moves it forward an hour)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "earlier" }) // "2024-03-10T01:30:00-05:00[America/New_York]" (spring-forward gap; "earlier" moves it back an hour)
- * @example addZoned("2024-03-09T02:30:00-05:00[America/New_York]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
- * @example addZoned("2024-11-03T01:30:00-05:00[America/New_York]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-11-03T01:40:00-05:00[America/New_York]" (exact time — disambiguation never re-resolves it)
- * @example setZoned(addZoned("2024-11-03T01:30:00-05:00[America/New_York]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-11-03T01:40:00-04:00[America/New_York]" (pre-1.16.0 result)
- * @example addZoned("2024-01-31T12:00:00-05:00[America/New_York]", { months: 1 }, { overflow: "reject" }) // ""
+ * @example addZoned("2024-03-10T14:30:00+05:30[u-ca=hebrew][Asia/Kolkata]", { days: 1 }) // "" (calendar before zone is not RFC 9557)
+ * @example addZoned("2024-10-26T01:30:00+01:00[Europe/London]", { days: 1 }, { disambiguation: "later" }) // "2024-10-27T01:30:00+00:00[Europe/London]" (fall-back overlap resolved; default "compatible" would return the +01:00 instant instead)
+ * @example addZoned("2024-10-26T01:30:00+01:00[Europe/London]", { days: 1 }, { disambiguation: "reject" }) // "" (fall-back overlap rejected)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }) // "2024-10-06T03:30:00+11:00[Australia/Sydney]" (02:30 on 6 October is in the spring-forward gap; "compatible" moves it forward an hour)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }, { disambiguation: "earlier" }) // "2024-10-06T01:30:00+10:00[Australia/Sydney]" (spring-forward gap; "earlier" moves it back an hour)
+ * @example addZoned("2024-10-05T02:30:00+10:00[Australia/Sydney]", { days: 1 }, { disambiguation: "reject" }) // "" (spring-forward gap rejected)
+ * @example addZoned("2024-10-27T01:30:00+00:00[Europe/London]", { minutes: 10 }, { disambiguation: "earlier" }) // "2024-10-27T01:40:00+00:00[Europe/London]" (exact time — disambiguation never re-resolves it)
+ * @example setZoned(addZoned("2024-10-27T01:30:00+00:00[Europe/London]", { minutes: 10 }), { hour: 1, minute: 40, second: 0 }, { disambiguation: "earlier", offset: "ignore" }) // "2024-10-27T01:40:00+01:00[Europe/London]" (pre-1.16.0 result)
+ * @example addZoned("2024-01-31T12:00:00+02:00[Africa/Johannesburg]", { months: 1 }, { overflow: "reject" }) // ""
  */
 export function addZoned(value, units, optionsArg) {
     try {
@@ -62,11 +62,8 @@ export function addZoned(value, units, optionsArg) {
             return "";
         }
         const validZonedDateTime = isValidCalendarZonedDateTime(value);
-        const validUnits = typeof units === "object" &&
-            units !== null &&
-            Object.keys(units).every(isValidDateTimeDurationUnit);
-        const validAmounts = validUnits && Object.values(units).every(isValidAmount);
-        if (!validZonedDateTime || !validUnits || !validAmounts) {
+        const amounts = readDurationUnits(units, isValidDateTimeDurationUnit);
+        if (!validZonedDateTime || amounts === null) {
             // TODO descriptive messages of what failed - likely could be GMT offset for historical changes and DST
             return "";
         }
@@ -78,7 +75,7 @@ export function addZoned(value, units, optionsArg) {
                 return "";
             }
             const zoned = parseCalendarZonedValue(value);
-            const added = addToZonedDisambiguated(zoned, units, 1, {
+            const added = addToZonedDisambiguated(zoned, amounts, 1, {
                 overflow,
                 disambiguation,
             });