@northguild/gmt 1.18.0 → 1.19.0

package/dist/calendar/calculate/bucketRange.d.ts

@@ -29,11 +29,18 @@ import type { ZoneBucketUnit } from "../../types/index.js";
  *   if a zone ever presented more transitions inside one bucket than the stepper walks — no
  *   IANA zone does, and the whole table was swept to confirm it. A truncated list would be
  *   worse than the sentinel, so none is returned in any of those cases.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `[]`. An offset to the minute has no
+ *   such limit.
  *
  * @param start ISO 8601 instant string for the range start (inclusive)
  * @param end ISO 8601 instant string for the range end (exclusive)
- * @param unit bucket unit ("hour" | "day" | "week" | "month", or its plural)
- * @param timeZone IANA name or UTC offset the buckets are computed in
+ * @param unit bucket unit ("month" | "week" | "day" | "hour", or its plural)
+ * @param timeZone IANA name or UTC offset the buckets are computed in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns array of UTC instant strings ending in "Z", or [] on invalid input
  *
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "day", "America/New_York") // ["2024-06-14T04:00:00Z", "2024-06-15T04:00:00Z", "2024-06-16T04:00:00Z"]
@@ -45,5 +52,6 @@ import type { ZoneBucketUnit } from "../../types/index.js";
  * @example bucketRange("2024-06-16T00:00:00Z", "2024-06-15T00:00:00Z", "day", "UTC") // [] (start after end)
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "days", "America/New_York") // ["2024-06-14T04:00:00Z", "2024-06-15T04:00:00Z", "2024-06-16T04:00:00Z"] (plural unit name)
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "year", "UTC") // [] (not a bucketing unit)
+ * @example bucketRange("1970-01-01T00:00:00Z", "1970-01-02T01:00:00Z", "day", "-00:44:30") // ["1969-12-31T00:44:30Z", "1970-01-01T00:44:30Z", "1970-01-02T00:44:30Z"]
  */
 export declare function bucketRange(start: string, end: string, unit: Temporal.SmallestUnit<ZoneBucketUnit>, timeZone: string): string[];

package/dist/calendar/calculate/bucketRange.js

@@ -1,9 +1,9 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { instantFrom, nextZonedBucketStart, zonedNextTransition, zonedUnitStart, } from "../../internal/index.js";
+import { frameInstant, frameZoned, instantFrom, nextZonedBucketStart, zonedUnitStart, zoneFrame, } from "../../internal/index.js";
 import { isValidInstant } from "../../precision/validate/index.js";
-import { isValidTimeZone } from "../../zoned/validate/index.js";
 import { isValidZoneBucketUnit } from "../validate/index.js";
 import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
+import { certainlyTouchesMoreBuckets } from "../../internal/zoneBucketCap.js";
 /**
  * Buckets a single call will return before giving up.
  *
@@ -12,58 +12,6 @@ import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
  * months — past anything a caller renders or aggregates in one pass.
  */
 const MAX_BUCKETS = 10_000;
-const NANOSECONDS_PER_HOUR = 3600000000000n;
-/**
- * The longest wall-clock stretch of each unit. Any wall-clock interval this long holds a unit
- * start: an hour holds an hour start, 24 hours a midnight, 7 days a Monday, 31 days a first of
- * the month.
- */
-const LONGEST_UNIT_NANOSECONDS = {
-    hour: NANOSECONDS_PER_HOUR,
-    day: 24n * NANOSECONDS_PER_HOUR,
-    week: 168n * NANOSECONDS_PER_HOUR,
-    month: 744n * NANOSECONDS_PER_HOUR,
-};
-/** Offset transitions read before the pre-count gives up and leaves the answer to the walk. */
-const MAX_PRECOUNT_TRANSITIONS = 4_096;
-/**
- * True when `[start, end)` certainly touches more than `MAX_BUCKETS` buckets, decided from the span
- * instead of stepping bucket by bucket (which costs milliseconds a step in some zones).
- *
- * Over a prefix of the range, the local wall clock runs continuously between offset transitions.
- * Those stretches cover at least the prefix's length less every backward offset change, in at most
- * one stretch more than there are transitions, and each stretch of wall clock holds at least
- * `floor(length / LONGEST_UNIT_NANOSECONDS)` distinct unit starts, each the start of its own
- * bucket before `end`. The count subtracts two per stretch for the partial units at its ends.
- * `false` means "not certain": the walk decides, exactly as before.
- */
-function certainlyExceedsBucketCap(startZoned, endZoned, unit) {
-    const unitNs = LONGEST_UNIT_NANOSECONDS[unit];
-    const startNs = startZoned.epochNanoseconds;
-    const prefixEndNs = [
-        endZoned.epochNanoseconds,
-        startNs + 2n * BigInt(MAX_BUCKETS + 1) * unitNs,
-    ].reduce((a, b) => (a < b ? a : b));
-    if (prefixEndNs - startNs <= BigInt(MAX_BUCKETS) * unitNs) {
-        return false;
-    }
-    let backwardNs = 0n;
-    let transitions = 0;
-    try {
-        for (let current = startZoned, next = zonedNextTransition(current); next !== null && next.epochNanoseconds < prefixEndNs; current = next, next = zonedNextTransition(current)) {
-            if (++transitions > MAX_PRECOUNT_TRANSITIONS) {
-                return false;
-            }
-            const shift = BigInt(current.offsetNanoseconds - next.offsetNanoseconds);
-            backwardNs += shift > 0n ? shift : 0n;
-        }
-    }
-    catch {
-        return false;
-    }
-    const wallStarts = (prefixEndNs - startNs - backwardNs) / unitNs;
-    return wallStarts - 2n * BigInt(transitions + 1) > BigInt(MAX_BUCKETS);
-}
 /**
  * The bucket start after `current`: `undefined` when it lies past Temporal's last representable
  * instant, null when the stepper cannot find it.
@@ -107,11 +55,18 @@ function nextBucketStartWithinRange(current, unit) {
  *   if a zone ever presented more transitions inside one bucket than the stepper walks — no
  *   IANA zone does, and the whole table was swept to confirm it. A truncated list would be
  *   worse than the sentinel, so none is returned in any of those cases.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `[]`. An offset to the minute has no
+ *   such limit.
  *
  * @param start ISO 8601 instant string for the range start (inclusive)
  * @param end ISO 8601 instant string for the range end (exclusive)
- * @param unit bucket unit ("hour" | "day" | "week" | "month", or its plural)
- * @param timeZone IANA name or UTC offset the buckets are computed in
+ * @param unit bucket unit ("month" | "week" | "day" | "hour", or its plural)
+ * @param timeZone IANA name or UTC offset the buckets are computed in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns array of UTC instant strings ending in "Z", or [] on invalid input
  *
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "day", "America/New_York") // ["2024-06-14T04:00:00Z", "2024-06-15T04:00:00Z", "2024-06-16T04:00:00Z"]
@@ -123,22 +78,24 @@ function nextBucketStartWithinRange(current, unit) {
  * @example bucketRange("2024-06-16T00:00:00Z", "2024-06-15T00:00:00Z", "day", "UTC") // [] (start after end)
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "days", "America/New_York") // ["2024-06-14T04:00:00Z", "2024-06-15T04:00:00Z", "2024-06-16T04:00:00Z"] (plural unit name)
  * @example bucketRange("2024-06-15T03:00:00Z", "2024-06-17T03:00:00Z", "year", "UTC") // [] (not a bucketing unit)
+ * @example bucketRange("1970-01-01T00:00:00Z", "1970-01-02T01:00:00Z", "day", "-00:44:30") // ["1969-12-31T00:44:30Z", "1970-01-01T00:44:30Z", "1970-01-02T00:44:30Z"]
  */
 export function bucketRange(start, end, unit, timeZone) {
     // The singular name; the guard below rejects anything outside the four units.
     const resolvedUnit = resolveDateTimeUnit(unit);
+    const frame = zoneFrame(timeZone);
     if (!isValidInstant(start) ||
         !isValidInstant(end) ||
         !isValidZoneBucketUnit(resolvedUnit) ||
-        !isValidTimeZone(timeZone)) {
+        frame === null) {
         return [];
     }
     try {
-        const startZoned = instantFrom(start).toZonedDateTimeISO(timeZone);
-        const endZoned = instantFrom(end).toZonedDateTimeISO(timeZone);
+        const startZoned = frameZoned(instantFrom(start), frame);
+        const endZoned = frameZoned(instantFrom(end), frame);
         if (Temporal.ZonedDateTime.compare(startZoned, endZoned) > 0)
             return [];
-        if (certainlyExceedsBucketCap(startZoned, endZoned, resolvedUnit))
+        if (certainlyTouchesMoreBuckets(startZoned, endZoned, resolvedUnit, MAX_BUCKETS))
             return [];
         const boundaries = [];
         const first = zonedUnitStart(startZoned, resolvedUnit);
@@ -149,7 +106,7 @@ export function bucketRange(start, end, unit, timeZone) {
             if (Temporal.ZonedDateTime.compare(current, endZoned) >= 0) {
                 return boundaries;
             }
-            boundaries.push(current.toInstant().toString());
+            boundaries.push(frameInstant(current, frame).toString());
             const next = nextBucketStartWithinRange(current, resolvedUnit);
             // Past the last representable instant, so after `end`: every touched bucket is collected.
             if (next === undefined)

package/dist/calendar/calculate/floorToZone.d.ts

@@ -24,10 +24,17 @@ import type { ZoneBucketUnit } from "../../types/index.js";
  * - Returns a UTC instant string ending in `"Z"`, exactly — no rounding.
  * - Returns `""` on invalid input, and where the boundary itself is not representable — the
  *   week or month containing the first instant Temporal supports began before it.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param value ISO 8601 instant string (e.g. "2024-06-15T03:00:00Z")
- * @param unit boundary unit ("hour" | "day" | "week" | "month", or its plural)
- * @param timeZone IANA name or UTC offset the boundary is computed in
+ * @param unit boundary unit ("month" | "week" | "day" | "hour", or its plural)
+ * @param timeZone IANA name or UTC offset the boundary is computed in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns UTC instant string ending in "Z", or "" on invalid input
  *
  * @example floorToZone("2024-06-15T03:00:00Z", "day", "America/New_York") // "2024-06-14T04:00:00Z" (the 14 June local midnight — the instant is already 14 June there)
@@ -40,5 +47,6 @@ import type { ZoneBucketUnit } from "../../types/index.js";
  * @example floorToZone("2024-06-15T03:00:00", "day", "UTC") // "" (zoneless, so it names no instant)
  * @example floorToZone("-271821-04-20T00:00:00Z", "month", "UTC") // "" (that month began before Temporal's range does)
  * @example floorToZone("2024-06-15T03:00:00Z", "day", "Invalid/Zone") // ""
+ * @example floorToZone("1970-01-01T13:00:00Z", "day", "-00:44:30") // "1970-01-01T00:44:30Z" (local midnight at a stored offset with seconds)
  */
 export declare function floorToZone(value: string, unit: Temporal.SmallestUnit<ZoneBucketUnit>, timeZone: string): string;

package/dist/calendar/calculate/floorToZone.js

@@ -1,6 +1,5 @@
-import { instantFrom, zonedUnitStart } from "../../internal/index.js";
+import { frameInstant, frameZoned, instantFrom, zonedUnitStart, zoneFrame, } from "../../internal/index.js";
 import { isValidInstant } from "../../precision/validate/index.js";
-import { isValidTimeZone } from "../../zoned/validate/index.js";
 import { isValidZoneBucketUnit } from "../validate/index.js";
 import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
 /**
@@ -27,10 +26,17 @@ import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
  * - Returns a UTC instant string ending in `"Z"`, exactly — no rounding.
  * - Returns `""` on invalid input, and where the boundary itself is not representable — the
  *   week or month containing the first instant Temporal supports began before it.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param value ISO 8601 instant string (e.g. "2024-06-15T03:00:00Z")
- * @param unit boundary unit ("hour" | "day" | "week" | "month", or its plural)
- * @param timeZone IANA name or UTC offset the boundary is computed in
+ * @param unit boundary unit ("month" | "week" | "day" | "hour", or its plural)
+ * @param timeZone IANA name or UTC offset the boundary is computed in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @returns UTC instant string ending in "Z", or "" on invalid input
  *
  * @example floorToZone("2024-06-15T03:00:00Z", "day", "America/New_York") // "2024-06-14T04:00:00Z" (the 14 June local midnight — the instant is already 14 June there)
@@ -43,19 +49,21 @@ import { resolveDateTimeUnit } from "../../internal/resolveDateTimeUnit.js";
  * @example floorToZone("2024-06-15T03:00:00", "day", "UTC") // "" (zoneless, so it names no instant)
  * @example floorToZone("-271821-04-20T00:00:00Z", "month", "UTC") // "" (that month began before Temporal's range does)
  * @example floorToZone("2024-06-15T03:00:00Z", "day", "Invalid/Zone") // ""
+ * @example floorToZone("1970-01-01T13:00:00Z", "day", "-00:44:30") // "1970-01-01T00:44:30Z" (local midnight at a stored offset with seconds)
  */
 export function floorToZone(value, unit, timeZone) {
     // The singular name; the guard below rejects anything outside the four units.
     const resolvedUnit = resolveDateTimeUnit(unit);
+    const frame = zoneFrame(timeZone);
     if (!isValidInstant(value) ||
         !isValidZoneBucketUnit(resolvedUnit) ||
-        !isValidTimeZone(timeZone)) {
+        frame === null) {
         return "";
     }
     try {
-        const zoned = instantFrom(value).toZonedDateTimeISO(timeZone);
+        const zoned = frameZoned(instantFrom(value), frame);
         const start = zonedUnitStart(zoned, resolvedUnit);
-        return start ? start.toInstant().toString() : "";
+        return start ? frameInstant(start, frame).toString() : "";
     }
     catch {
         return "";

package/dist/calendar/hours/addOperatingTime.d.ts

@@ -17,6 +17,12 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * - Returns `""` on invalid input: an invalid instant, duration or `OperatingSchedule`, a
  *   negative `duration`, a `within` that is not a non-negative ISO duration, a `disambiguation`
  *   that is not one of the four values, and a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param start ISO 8601 instant string where the clock starts
  * @param duration ISO 8601 duration of open time, hours and smaller units (e.g. "PT8H")

package/dist/calendar/hours/addOperatingTime.js

@@ -18,6 +18,12 @@ import { instantAfterOpenTime, instantText, parseOpenTimeAmount, parseOperatingS
  * - Returns `""` on invalid input: an invalid instant, duration or `OperatingSchedule`, a
  *   negative `duration`, a `within` that is not a non-negative ISO duration, a `disambiguation`
  *   that is not one of the four values, and a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param start ISO 8601 instant string where the clock starts
  * @param duration ISO 8601 duration of open time, hours and smaller units (e.g. "PT8H")
@@ -44,7 +50,7 @@ export function addOperatingTime(start, duration, schedule, optionsArg) {
             amount === null) {
             return "";
         }
-        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.timeZone);
+        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.frame);
         if (horizon === null) {
             return "";
         }

package/dist/calendar/hours/isOpenAt.d.ts

@@ -13,6 +13,11 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * - Returns `false` on invalid input: an invalid instant or `OperatingSchedule`, or a
  *   `disambiguation` that is not one of the four values. Check the schedule with
  *   `operatingIntervals` when "closed" and "invalid" must be told apart.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `false`. There `false` is
+ *   the sentinel, not a reading of the schedule. An offset to the minute has no such limit.
  *
  * @param isoString ISO 8601 instant string to test
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
@@ -24,6 +29,7 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * @example isOpenAt("2024-06-15T01:00:00Z", { timeZone: "UTC", weekly: { 5: [{ from: "23:00", to: "06:00" }] } }) // true — Friday's night window, on Saturday morning
  * @example isOpenAt("2024-07-04T14:00:00Z", { timeZone: "America/New_York", weekly: { 4: [{ from: "09:00", to: "17:00" }] }, holidays: ["2024-07-04"] }) // false — a holiday
  * @example isOpenAt("2024-06-17T14:00:00", { timeZone: "UTC", weekly: { 1: [{ from: "09:00", to: "17:00" }] } }) // false — no offset, not an instant
+ * @example isOpenAt("1970-01-01T08:44:30Z", { timeZone: "-00:44:30", weekly: { 4: [{ from: "08:00", to: "17:00" }] } }) // true (08:00 at a stored offset with seconds)
  */
 export declare function isOpenAt(isoString: string, schedule: OperatingSchedule, optionsArg?: {
     /**

package/dist/calendar/hours/isOpenAt.js

@@ -14,6 +14,11 @@ import { firstOpenInstant, parseOperatingSchedule, parseScheduleDisambiguation,
  * - Returns `false` on invalid input: an invalid instant or `OperatingSchedule`, or a
  *   `disambiguation` that is not one of the four values. Check the schedule with
  *   `operatingIntervals` when "closed" and "invalid" must be told apart.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `false`. There `false` is
+ *   the sentinel, not a reading of the schedule. An offset to the minute has no such limit.
  *
  * @param isoString ISO 8601 instant string to test
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
@@ -25,6 +30,7 @@ import { firstOpenInstant, parseOperatingSchedule, parseScheduleDisambiguation,
  * @example isOpenAt("2024-06-15T01:00:00Z", { timeZone: "UTC", weekly: { 5: [{ from: "23:00", to: "06:00" }] } }) // true — Friday's night window, on Saturday morning
  * @example isOpenAt("2024-07-04T14:00:00Z", { timeZone: "America/New_York", weekly: { 4: [{ from: "09:00", to: "17:00" }] }, holidays: ["2024-07-04"] }) // false — a holiday
  * @example isOpenAt("2024-06-17T14:00:00", { timeZone: "UTC", weekly: { 1: [{ from: "09:00", to: "17:00" }] } }) // false — no offset, not an instant
+ * @example isOpenAt("1970-01-01T08:44:30Z", { timeZone: "-00:44:30", weekly: { 4: [{ from: "08:00", to: "17:00" }] } }) // true (08:00 at a stored offset with seconds)
  */
 export function isOpenAt(isoString, schedule, optionsArg) {
     try {

package/dist/calendar/hours/nextCloseAt.d.ts

@@ -14,6 +14,12 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, a `within` that is
  *   not a non-negative ISO duration, a `disambiguation` that is not one of the four values, and
  *   a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param isoString ISO 8601 instant string to search from, inclusive
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule

package/dist/calendar/hours/nextCloseAt.js

@@ -15,6 +15,12 @@ import { firstClosedInstant, instantText, parseOperatingSchedule, parseScheduleD
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, a `within` that is
  *   not a non-negative ISO duration, a `disambiguation` that is not one of the four values, and
  *   a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param isoString ISO 8601 instant string to search from, inclusive
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
@@ -36,7 +42,7 @@ export function nextCloseAt(isoString, schedule, optionsArg) {
         if (disambiguation === null || resolved === null || from === null) {
             return "";
         }
-        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.timeZone);
+        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.frame);
         if (horizon === null) {
             return "";
         }

package/dist/calendar/hours/nextOpenAt.d.ts

@@ -11,6 +11,12 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, a `within` that is
  *   not a non-negative ISO duration, a `disambiguation` that is not one of the four values, and
  *   a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param isoString ISO 8601 instant string to search from, inclusive
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule

package/dist/calendar/hours/nextOpenAt.js

@@ -12,6 +12,12 @@ import { firstOpenInstant, instantText, parseOperatingSchedule, parseScheduleDis
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, a `within` that is
  *   not a non-negative ISO duration, a `disambiguation` that is not one of the four values, and
  *   a search that would go more than 10,000 local dates past the input's date.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the last instant Temporal supports
+ *   (`+275760-09-13T00:00:00Z`) for an offset east of UTC, or of the first
+ *   (`-271821-04-20T00:00:00Z`) for one west, this returns `""`. An offset to the minute has no
+ *   such limit.
  *
  * @param isoString ISO 8601 instant string to search from, inclusive
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
@@ -32,7 +38,7 @@ export function nextOpenAt(isoString, schedule, optionsArg) {
         if (disambiguation === null || resolved === null || from === null) {
             return "";
         }
-        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.timeZone);
+        const horizon = parseSearchHorizon(from, optionsArg?.within, resolved.frame);
         if (horizon === null) {
             return "";
         }

package/dist/calendar/hours/operatingIntervals.d.ts

@@ -18,6 +18,11 @@ import type { Disambiguation, Interval, OperatingSchedule } from "../../types/in
  *   for one date), when `range` is not a valid `Interval`, when `disambiguation` is not one of
  *   the four values, and when the range spans more than 10,000 local dates (about 27 years)
  *   counted from the date `range.start` falls on.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `[]`. An offset to the
+ *   minute has no such limit.
  *
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
  * @param range `{ start, end }` record of ISO 8601 instant strings to expand the schedule inside

package/dist/calendar/hours/operatingIntervals.js

@@ -19,6 +19,11 @@ import { parseOperatingSchedule, parseScheduleDisambiguation, scheduleRunsWithin
  *   for one date), when `range` is not a valid `Interval`, when `disambiguation` is not one of
  *   the four values, and when the range spans more than 10,000 local dates (about 27 years)
  *   counted from the date `range.start` falls on.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `[]`. An offset to the
+ *   minute has no such limit.
  *
  * @param schedule `{ timeZone, weekly, holidays?, overrides? }` operating schedule
  * @param range `{ start, end }` record of ISO 8601 instant strings to expand the schedule inside

package/dist/calendar/hours/operatingTimeBetween.d.ts

@@ -14,6 +14,11 @@ import type { Disambiguation, OperatingSchedule } from "../../types/index.js";
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, `start` after
  *   `end`, a `disambiguation` that is not one of the four values, and a range spanning more than
  *   10,000 local dates (about 27 years) counted from the date `start` falls on.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `""`. An offset to the
+ *   minute has no such limit.
  *
  * @param start ISO 8601 instant string where the clock starts (inclusive)
  * @param end ISO 8601 instant string where the clock stops (exclusive)

package/dist/calendar/hours/operatingTimeBetween.js

@@ -15,6 +15,11 @@ import { parseOperatingSchedule, parseScheduleDisambiguation, scheduleRunsWithin
  * - Returns `""` on invalid input: an invalid instant or `OperatingSchedule`, `start` after
  *   `end`, a `disambiguation` that is not one of the four values, and a range spanning more than
  *   10,000 local dates (about 27 years) counted from the date `start` falls on.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `""`. An offset to the
+ *   minute has no such limit.
  *
  * @param start ISO 8601 instant string where the clock starts (inclusive)
  * @param end ISO 8601 instant string where the clock stops (exclusive)

package/dist/calendar/hours/recurringWindows.d.ts

@@ -31,10 +31,16 @@ import type { Disambiguation, Interval, OperatingSchedule } from "../../types/in
  *   `range` is not a valid `Interval`, when `timeZone` is invalid, when `disambiguation` is not
  *   one of the four values, and when the range spans more than 10,000 local dates (about 27
  *   years) counted from the date `range.start` falls on, rather than a truncated list.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `[]`. An offset to the
+ *   minute has no such limit.
  *
  * @param weekly windows by ISO weekday, `{ 1: [{ from: "09:00", to: "17:00" }], … }`
  * @param range `{ start, end }` record of ISO 8601 instant strings to expand the pattern inside
- * @param timeZone IANA name or UTC offset the windows are read in
+ * @param timeZone IANA name or UTC offset the windows are read in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param optionsArg How a window edge on a clock change is resolved
  * @returns sorted, merged `{ start, end }` records of the open instants, or [] on invalid input
  *
@@ -47,6 +53,7 @@ import type { Disambiguation, Interval, OperatingSchedule } from "../../types/in
  * @example recurringWindows({ 8: [{ from: "09:00", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "UTC") // [] — not an ISO weekday
  * @example recurringWindows({ 1: [{ from: "9am", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "UTC") // [] — malformed window
  * @example recurringWindows({ 1: [{ from: "09:00", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "Invalid/Zone") // []
+ * @example recurringWindows({ 4: [{ from: "08:00", to: "17:00" }] }, { start: "1970-01-01T00:00:00Z", end: "1970-01-02T00:00:00Z" }, "-00:44:30") // [{ start: "1970-01-01T08:44:30Z", end: "1970-01-01T17:44:30Z" }]
  */
 export declare function recurringWindows(weekly: OperatingSchedule["weekly"], range: Interval, timeZone: string, optionsArg?: {
     /**

package/dist/calendar/hours/recurringWindows.js

@@ -1,6 +1,5 @@
-import { parseIntervalNanoseconds } from "../../internal/index.js";
+import { parseIntervalNanoseconds, zoneFrame } from "../../internal/index.js";
 import { parseScheduleDisambiguation, parseWeeklyPattern, scheduleRunsWithin, } from "../../internal/operatingSchedule.js";
-import { isValidTimeZone } from "../../zoned/validate/index.js";
 /**
  * Return the instants a weekly pattern of local windows is open inside `range`, read in
  * `timeZone`: the primitive under operating hours, curfews and recurring crew windows.
@@ -33,10 +32,16 @@ import { isValidTimeZone } from "../../zoned/validate/index.js";
  *   `range` is not a valid `Interval`, when `timeZone` is invalid, when `disambiguation` is not
  *   one of the four values, and when the range spans more than 10,000 local dates (about 27
  *   years) counted from the date `range.start` falls on, rather than a truncated list.
+ * - **Limit at an offset with seconds.** The instant is placed in the offset's whole-minute zone,
+ *   moved by its seconds, and the moved instant must be inside Temporal's range. So within the
+ *   offset's seconds (under a minute) of the first instant Temporal supports
+ *   (`-271821-04-20T00:00:00Z`), for an offset west of UTC, this returns `[]`. An offset to the
+ *   minute has no such limit.
  *
  * @param weekly windows by ISO weekday, `{ 1: [{ from: "09:00", to: "17:00" }], … }`
  * @param range `{ start, end }` record of ISO 8601 instant strings to expand the pattern inside
- * @param timeZone IANA name or UTC offset the windows are read in
+ * @param timeZone IANA name or UTC offset the windows are read in: a time zone identifier
+ *   (`+05:30`, `+0530`, `-08`) or a stored offset (`±HH:MM[:SS]`, what `getTimeZoneOffset` returns)
  * @param optionsArg How a window edge on a clock change is resolved
  * @returns sorted, merged `{ start, end }` records of the open instants, or [] on invalid input
  *
@@ -49,21 +54,24 @@ import { isValidTimeZone } from "../../zoned/validate/index.js";
  * @example recurringWindows({ 8: [{ from: "09:00", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "UTC") // [] — not an ISO weekday
  * @example recurringWindows({ 1: [{ from: "9am", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "UTC") // [] — malformed window
  * @example recurringWindows({ 1: [{ from: "09:00", to: "17:00" }] }, { start: "2024-06-10T00:00:00Z", end: "2024-06-11T00:00:00Z" }, "Invalid/Zone") // []
+ * @example recurringWindows({ 4: [{ from: "08:00", to: "17:00" }] }, { start: "1970-01-01T00:00:00Z", end: "1970-01-02T00:00:00Z" }, "-00:44:30") // [{ start: "1970-01-01T08:44:30Z", end: "1970-01-01T17:44:30Z" }]
  */
 export function recurringWindows(weekly, range, timeZone, optionsArg) {
     try {
         const disambiguation = parseScheduleDisambiguation(optionsArg);
         const weeklyWindows = parseWeeklyPattern(weekly);
         const bounds = parseIntervalNanoseconds(range);
+        const frame = zoneFrame(timeZone);
         if (disambiguation === null ||
             weeklyWindows === null ||
             bounds === null ||
             typeof timeZone !== "string" ||
-            !isValidTimeZone(timeZone)) {
+            frame === null) {
             return [];
         }
         const runs = scheduleRunsWithin({
             timeZone,
+            frame,
             weekly: weeklyWindows,
             holidays: new Set(),
             overrides: new Map(),

package/dist/duration/calculate/durationFromUnits.d.ts

@@ -0,0 +1,47 @@
+import type { DateTimeDurationUnit } from "../../types/index.js";
+/**
+ * Write an amount given as a unit object, such as `{ minutes: 15 }`, as an ISO 8601 duration
+ * string.
+ *
+ * - Uses Temporal.Duration.from to read the fields, then .toString() to write them.
+ * - Which function to use: `durationFromUnits` turns a unit object into the duration string that
+ *   the other duration functions take. `totalUnits` totals a unit object of exact units in one
+ *   call. `totalDuration` totals a duration string.
+ * - Takes all ten units, from years down to nanoseconds: writing a year, a month or a week needs
+ *   no date to measure from. To total a calendar amount, pass the result to `totalDuration` with
+ *   `relativeTo`.
+ * - Years down to minutes are written as given, and nothing is carried into a larger unit:
+ *   `{ minutes: 90 }` is "PT90M". `normalizeDuration` with `largestUnit` carries it.
+ * - Seconds, milliseconds, microseconds and nanoseconds are written together as one decimal
+ *   number of seconds, as Temporal's `Duration.prototype.toString` writes them:
+ *   `{ milliseconds: 1500 }` is "PT1.5S". Reading that string back gives 1 second and 500
+ *   milliseconds.
+ * - A zero amount is "PT0S", the one spelling Temporal writes for every zero duration.
+ * - Every key is a unit name in the plural, and every amount is a whole finite number. All
+ *   nonzero amounts share one sign, as Temporal requires of a duration. A unit set to `undefined`
+ *   is absent, as Temporal reads it.
+ * - An unknown key returns "", even beside a valid one. Temporal on its own ignores an unknown
+ *   key, so a misspelt `{ minutes: 15, hour: 1 }` would be written "PT15M" with no warning.
+ * - Returns "" on an object with no unit, a non-object `units` (a duration string included), an
+ *   invalid amount, or an amount past Temporal's duration range.
+ *
+ * @param units Partial<Record<DateTimeDurationUnit, number>> object holding the amount to write
+ * @returns ISO 8601 duration string, or "" on invalid input
+ *
+ * @example durationFromUnits({ minutes: 15 }) // "PT15M"
+ * @example durationFromUnits({ days: 1, hours: 12 }) // "P1DT12H"
+ * @example durationFromUnits({ minutes: 90 }) // "PT90M" (not carried into hours)
+ * @example durationFromUnits({ years: 1, months: 2 }) // "P1Y2M"
+ * @example durationFromUnits({ weeks: 1 }) // "P1W"
+ * @example durationFromUnits({ milliseconds: 1500 }) // "PT1.5S"
+ * @example durationFromUnits({ seconds: 59, milliseconds: 1500 }) // "PT60.5S" (one decimal number of seconds)
+ * @example durationFromUnits({ minutes: 15, hours: undefined }) // "PT15M" (an undefined unit is absent)
+ * @example durationFromUnits({ minutes: -15 }) // "-PT15M"
+ * @example durationFromUnits({ minutes: 0 }) // "PT0S"
+ * @example durationFromUnits({ minutes: 15, hour: 1 }) // "" (unknown key "hour")
+ * @example durationFromUnits({ minutes: 1.5 }) // "" (fractional amount)
+ * @example durationFromUnits({ hours: 1, minutes: -30 }) // "" (mixed signs)
+ * @example durationFromUnits({}) // ""
+ * @example durationFromUnits("PT15M") // "" (already a duration string)
+ */
+export declare function durationFromUnits(units: Partial<Record<DateTimeDurationUnit, number>>): string;