@northguild/gmt 1.19.0 → 1.20.0

package/dist/transport/calculate/cutoffAt.js

@@ -1,104 +1,8 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { rollDate } from "../../calendar/business/rollDate.js";
-import { isValidBusinessCalendar } from "../../calendar/validate/isValidBusinessCalendar.js";
-import { isValidRollConvention } from "../../calendar/validate/isValidRollConvention.js";
-import { isValidDuration } from "../../duration/validate/isValidDuration.js";
-import { classifyLocal } from "../../instant/convert/classifyLocal.js";
-import { resolveLocal } from "../../instant/convert/resolveLocal.js";
-import { instantFrom } from "../../internal/index.js";
+import { Temporal } from "../../internal/temporal.js";
+import { cutoffAtResolved, resolveCutoffTime, resolveSharedCutoffOptions, } from "../../internal/cutoffAtResolved.js";
+import { instantFrom, parseInstantNanoseconds } from "../../internal/index.js";
+import { isDurationString } from "../../internal/inputChecks.js";
 import { isObject } from "../../internal/isObject.js";
-import { isValidTime } from "../../plain/validate/isValidTime.js";
-import { isValidInstant } from "../../precision/validate/isValidInstant.js";
-import { isValidTimeZone } from "../../zoned/validate/isValidTimeZone.js";
-function resolveOptions(options) {
-    if (!isObject(options)) {
-        return null;
-    }
-    const { timeZone, atLocalTime, calendar, roll } = options;
-    if (typeof timeZone !== "string" || !isValidTimeZone(timeZone)) {
-        return null;
-    }
-    if (atLocalTime !== undefined && !isValidTime(atLocalTime)) {
-        return null;
-    }
-    if (calendar !== undefined && !isValidBusinessCalendar(calendar)) {
-        return null;
-    }
-    if (roll !== undefined && !isValidRollConvention(roll)) {
-        return null;
-    }
-    // Rolling needs both a calendar and a direction, and no standard supplies either one by
-    // default: a calendar without a roll, or a roll without a calendar, is a missing term.
-    if ((calendar === undefined) !== (roll === undefined)) {
-        return null;
-    }
-    return {
-        timeZone,
-        atLocalTime: atLocalTime === undefined ? null : Temporal.PlainTime.from(atLocalTime),
-        rolling: calendar === undefined || roll === undefined ? null : { calendar, roll },
-    };
-}
-/**
- * The instant a local wall time names: the first occurrence of a repeated hour, as RFC 5545
- * §3.3.5 reads a local time that "occurs more than once", and `null` for a skipped one, which
- * is never shifted.
- */
-function resolveWallTime(wall, timeZone) {
-    const local = wall.toString();
-    const kind = classifyLocal(local, timeZone);
-    if (kind === null || kind === "nonexistent") {
-        return null;
-    }
-    const instant = resolveLocal(local, timeZone, { disambiguation: "earlier" });
-    return instant === ""
-        ? null
-        : Temporal.Instant.from(instant).toZonedDateTimeISO(timeZone);
-}
-/** The calendar part of a duration — years, months, weeks and days. */
-function datePart(offset) {
-    return Temporal.Duration.from({
-        years: offset.years,
-        months: offset.months,
-        weeks: offset.weeks,
-        days: offset.days,
-    });
-}
-/** The exact part of a duration — hours and smaller. */
-function timePart(offset) {
-    return Temporal.Duration.from({
-        hours: offset.hours,
-        minutes: offset.minutes,
-        seconds: offset.seconds,
-        milliseconds: offset.milliseconds,
-        microseconds: offset.microseconds,
-        nanoseconds: offset.nanoseconds,
-    });
-}
-/**
- * The offset taken off the anchor with no pinning: the calendar part moves the local wall
- * clock, then the exact part comes off in exact time — Temporal's `ZonedDateTime#subtract`,
- * except that a wall clock landing in a skipped hour is `null` rather than moved forward.
- */
-function subtractOffset(anchor, offset) {
-    const calendarPart = datePart(offset);
-    if (calendarPart.blank) {
-        return anchor.subtract(timePart(offset));
-    }
-    const wall = resolveWallTime(anchor.toPlainDateTime().subtract(calendarPart), anchor.timeZoneId);
-    return wall === null ? null : wall.subtract(timePart(offset));
-}
-/**
- * The local date the cut-off falls on after rolling, or `null` when the roll fails. With no
- * calendar the date is left as it is.
- */
-function rolledDate(date, options) {
-    if (options.rolling === null) {
-        return date;
-    }
-    const { calendar, roll } = options.rolling;
-    const rolled = rollDate(date.toString(), roll, calendar);
-    return rolled === "" ? null : Temporal.PlainDate.from(rolled);
-}
 /**
  * Find a deadline stated as an offset before an anchor event, in the local time of the place
  * that enforces it.
@@ -155,49 +59,36 @@ function rolledDate(date, options) {
  * @example cutoffAt("2024-06-14T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00" }) // "2024-06-12T17:00:00+02:00[Europe/Amsterdam]"
  * @example cutoffAt("2024-06-14T16:00:00Z", "PT48H", { timeZone: "Europe/Amsterdam" }) // "2024-06-12T18:00:00+02:00[Europe/Amsterdam]" (48 hours keeps the departure's 18:00)
  * @example cutoffAt("2024-06-14T16:00:00Z", "P1D", { timeZone: "Europe/Amsterdam", atLocalTime: "10:00" }) // "2024-06-13T10:00:00+02:00[Europe/Amsterdam]"
- * @example cutoffAt("2024-11-05T17:00:00Z", "PT96H", { timeZone: "America/New_York" }) // "2024-11-01T13:00:00-04:00[America/New_York]" (96 elapsed hours across the fall-back)
- * @example cutoffAt("2024-03-11T22:00:00Z", "P2D", { timeZone: "America/New_York", atLocalTime: "17:00" }) // "2024-03-09T17:00:00-05:00[America/New_York]" (17:00 local, across the spring-forward)
+ * @example cutoffAt("2024-04-09T07:00:00Z", "PT96H", { timeZone: "Australia/Sydney" }) // "2024-04-05T18:00:00+11:00[Australia/Sydney]" (96 elapsed hours across the fall-back)
+ * @example cutoffAt("2024-04-01T16:00:00Z", "P2D", { timeZone: "Europe/London", atLocalTime: "17:00" }) // "2024-03-30T17:00:00+00:00[Europe/London]" (17:00 local, across the spring-forward)
  * @example cutoffAt("2024-06-18T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" }, roll: "preceding" }) // "2024-06-14T17:00:00+02:00[Europe/Amsterdam]" (Sunday rolls back to Friday)
  * @example cutoffAt("2024-06-18T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", atLocalTime: "17:00", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" } }) // "" (a calendar needs a roll convention)
- * @example cutoffAt("2024-11-04T23:00:00Z", "P1D", { timeZone: "America/New_York", atLocalTime: "01:30" }) // "2024-11-03T01:30:00-04:00[America/New_York]" (a repeated hour takes the earlier pass)
- * @example cutoffAt("2024-03-11T22:00:00Z", "P1D", { timeZone: "America/New_York", atLocalTime: "02:30" }) // "" (02:30 on 10 March never happened)
+ * @example cutoffAt("2024-10-28T18:00:00Z", "P1D", { timeZone: "Europe/London", atLocalTime: "01:30" }) // "2024-10-27T01:30:00+01:00[Europe/London]" (a repeated hour takes the earlier pass)
+ * @example cutoffAt("2024-10-07T07:00:00Z", "P1D", { timeZone: "Australia/Sydney", atLocalTime: "02:30" }) // "" (02:30 on 6 October never happened)
  * @example cutoffAt("2024-06-14T18:00:00", "P2D", { timeZone: "Europe/Amsterdam" }) // "" (a zoneless anchor is not a moment)
  * @example cutoffAt("2024-06-14T16:00:00Z", "P2D", { timeZone: "Europe/Amsterdam", roll: "preceding" }) // "" (a roll needs a calendar)
  */
 export function cutoffAt(anchor, offset, options) {
     try {
-        const resolved = resolveOptions(options);
-        if (resolved === null ||
-            !isValidInstant(anchor) ||
-            !isValidDuration(offset)) {
+        if (!isObject(options)) {
+            return "";
+        }
+        // Every read of `options` happens here, once.
+        const { timeZone, atLocalTime, calendar, roll } = options;
+        // The time of day is checked before the calendar is read, so an invalid one never reads it.
+        const local = resolveCutoffTime(atLocalTime);
+        const shared = local === null
+            ? null
+            : resolveSharedCutoffOptions(timeZone, calendar, roll);
+        if (shared === null ||
+            local === null ||
+            parseInstantNanoseconds(anchor) === null ||
+            !isDurationString(offset)) {
             return "";
         }
         try {
-            const start = instantFrom(anchor).toZonedDateTimeISO(resolved.timeZone);
-            const duration = Temporal.Duration.from(offset);
-            if (resolved.atLocalTime !== null) {
-                const day = rolledDate(start
-                    .subtract(timePart(duration))
-                    .toPlainDate()
-                    .subtract(datePart(duration)), resolved);
-                const pinned = day === null
-                    ? null
-                    : resolveWallTime(day.toPlainDateTime(resolved.atLocalTime), resolved.timeZone);
-                return pinned === null ? "" : pinned.toString();
-            }
-            const cutoff = subtractOffset(start, duration);
-            if (cutoff === null) {
-                return "";
-            }
-            const day = rolledDate(cutoff.toPlainDate(), resolved);
-            if (day === null) {
-                return "";
-            }
-            if (day.equals(cutoff.toPlainDate())) {
-                return cutoff.toString();
-            }
-            const rolled = resolveWallTime(day.toPlainDateTime(cutoff.toPlainTime()), resolved.timeZone);
-            return rolled === null ? "" : rolled.toString();
+            const found = cutoffAtResolved(instantFrom(anchor), Temporal.Duration.from(offset), local.time, shared);
+            return found === null ? "" : found.text;
         }
         catch {
             return "";

package/dist/transport/calculate/cutoffSchedule.d.ts

@@ -1,4 +1,4 @@
-import { type CutoffOptions } from "./cutoffAt.js";
+import type { CutoffOptions } from "./cutoffAt.js";
 /** One named deadline in a cut-off stack: how long before the anchor, and at what local time. */
 export interface Cutoff {
     /** The caller's label, echoed back (`"document"`, `"VGM"`); GMT does not interpret it. */
@@ -70,6 +70,6 @@ export interface CutoffScheduleOptions {
  * @example cutoffSchedule("2024-06-18T16:00:00Z", [{ name: "document", offset: "P2D", atLocalTime: "17:00" }, { name: "VGM", offset: "P1D", atLocalTime: "10:00" }], { timeZone: "Europe/Amsterdam", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" }, roll: "preceding" }) // [{ name: "document", at: "2024-06-14T17:00:00+02:00[Europe/Amsterdam]" }, { name: "VGM", at: "2024-06-17T10:00:00+02:00[Europe/Amsterdam]" }] (Sunday's document cut-off rolls back to Friday)
  * @example cutoffSchedule("2024-06-14T16:00:00Z", [], { timeZone: "Europe/Amsterdam" }) // []
  * @example cutoffSchedule("2024-06-14T16:00:00Z", [{ name: "document", offset: "2 days" }], { timeZone: "Europe/Amsterdam" }) // []
- * @example cutoffSchedule("2024-03-11T22:00:00Z", [{ name: "gate-in", offset: "P1D" }, { name: "VGM", offset: "P1D", atLocalTime: "02:30" }], { timeZone: "America/New_York" }) // [] (02:30 on 10 March never happened)
+ * @example cutoffSchedule("2024-10-07T07:00:00Z", [{ name: "gate-in", offset: "P1D" }, { name: "VGM", offset: "P1D", atLocalTime: "02:30" }], { timeZone: "Australia/Sydney" }) // [] (02:30 on 6 October never happened)
  */
 export declare function cutoffSchedule(anchor: string, cutoffs: Cutoff[], options: CutoffScheduleOptions): CutoffTime[];

package/dist/transport/calculate/cutoffSchedule.js

@@ -1,7 +1,42 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { instantFrom } from "../../internal/index.js";
+import { Temporal } from "../../internal/temporal.js";
+import { cutoffAtResolved, resolveCutoffTime, resolveSharedCutoffOptions, } from "../../internal/cutoffAtResolved.js";
+import { instantFrom, parseInstantNanoseconds } from "../../internal/index.js";
+import { isDurationString } from "../../internal/inputChecks.js";
 import { isObject } from "../../internal/isObject.js";
-import { cutoffAt } from "./cutoffAt.js";
+/** The shared options and the anchor, resolved once; `null` when either is invalid. */
+function stackContext(state) {
+    const { timeZone, calendar, roll } = state.options;
+    state.shared ??= resolveSharedCutoffOptions(timeZone, calendar, roll);
+    if (state.shared === null) {
+        return null;
+    }
+    if (state.anchorInstant === null) {
+        if (parseInstantNanoseconds(state.anchor) === null) {
+            return null;
+        }
+        state.anchorInstant = instantFrom(state.anchor);
+    }
+    return { shared: state.shared, anchorInstant: state.anchorInstant };
+}
+/** One entry's cut-off, or `null` when the entry or its cut-off is invalid. */
+function scheduleEntry(cutoff, state) {
+    if (!isObject(cutoff)) {
+        return null;
+    }
+    const { name, offset, atLocalTime } = cutoff;
+    if (typeof name !== "string") {
+        return null;
+    }
+    // The entry's own time of day is checked before the stack's options are read, so an invalid
+    // entry never reads the calendar.
+    const local = resolveCutoffTime(atLocalTime);
+    const context = local === null ? null : stackContext(state);
+    if (local === null || context === null || !isDurationString(offset)) {
+        return null;
+    }
+    const found = cutoffAtResolved(context.anchorInstant, Temporal.Duration.from(offset), local.time, context.shared);
+    return found === null ? null : { name, at: found.text, ns: found.ns };
+}
 /**
  * Compute a whole stack of cut-offs against one anchor event, earliest first.
  *
@@ -32,37 +67,34 @@ import { cutoffAt } from "./cutoffAt.js";
  * @example cutoffSchedule("2024-06-18T16:00:00Z", [{ name: "document", offset: "P2D", atLocalTime: "17:00" }, { name: "VGM", offset: "P1D", atLocalTime: "10:00" }], { timeZone: "Europe/Amsterdam", calendar: { weekend: [6, 7], holidays: [], timeZone: "Europe/Amsterdam" }, roll: "preceding" }) // [{ name: "document", at: "2024-06-14T17:00:00+02:00[Europe/Amsterdam]" }, { name: "VGM", at: "2024-06-17T10:00:00+02:00[Europe/Amsterdam]" }] (Sunday's document cut-off rolls back to Friday)
  * @example cutoffSchedule("2024-06-14T16:00:00Z", [], { timeZone: "Europe/Amsterdam" }) // []
  * @example cutoffSchedule("2024-06-14T16:00:00Z", [{ name: "document", offset: "2 days" }], { timeZone: "Europe/Amsterdam" }) // []
- * @example cutoffSchedule("2024-03-11T22:00:00Z", [{ name: "gate-in", offset: "P1D" }, { name: "VGM", offset: "P1D", atLocalTime: "02:30" }], { timeZone: "America/New_York" }) // [] (02:30 on 10 March never happened)
+ * @example cutoffSchedule("2024-10-07T07:00:00Z", [{ name: "gate-in", offset: "P1D" }, { name: "VGM", offset: "P1D", atLocalTime: "02:30" }], { timeZone: "Australia/Sydney" }) // [] (02:30 on 6 October never happened)
  */
 export function cutoffSchedule(anchor, cutoffs, options) {
     try {
         if (!Array.isArray(cutoffs) || !isObject(options)) {
             return [];
         }
+        // Every read of `options` happens here, once. The zone, the calendar and the anchor are
+        // validated and parsed once for the whole stack, at the first entry: an empty list reads
+        // none of them.
         const { timeZone, calendar, roll } = options;
+        const state = {
+            anchor,
+            options: { timeZone, calendar, roll },
+            shared: null,
+            anchorInstant: null,
+        };
         const schedule = [];
         for (const cutoff of cutoffs) {
-            if (!isObject(cutoff)) {
-                return [];
-            }
-            const { name, offset, atLocalTime } = cutoff;
-            if (typeof name !== "string") {
-                return [];
-            }
-            const at = cutoffAt(anchor, offset, {
-                timeZone,
-                atLocalTime,
-                calendar,
-                roll,
-            });
-            if (at === "") {
+            const entry = scheduleEntry(cutoff, state);
+            if (entry === null) {
                 return [];
             }
-            schedule.push({ name, at, instant: instantFrom(at) });
+            schedule.push(entry);
         }
         // Array.prototype.sort is stable, so entries on the same instant keep their input order.
         return schedule
-            .sort((a, b) => Temporal.Instant.compare(a.instant, b.instant))
+            .sort((a, b) => (a.ns < b.ns ? -1 : a.ns > b.ns ? 1 : 0))
             .map(({ name, at }) => ({ name, at }));
     }
     catch {

package/dist/transport/calculate/dwellTime.d.ts

@@ -71,12 +71,12 @@ export interface Dwell {
  *   days are counted in; defaults to `entry`'s bracketed zone
  * @returns exact duration, zone-local entry and exit, and the local calendar days touched, or null on invalid input
  *
- * @example dwellTime("2024-06-15T23:00:00-04:00[America/New_York]", "2024-06-16T01:00:00-04:00[America/New_York]") // { duration: "PT2H", enter: "2024-06-15T23:00:00-04:00[America/New_York]", exit: "2024-06-16T01:00:00-04:00[America/New_York]", calendarDays: 2 }
+ * @example dwellTime("2024-06-15T23:00:00+09:00[Asia/Tokyo]", "2024-06-16T01:00:00+09:00[Asia/Tokyo]") // { duration: "PT2H", enter: "2024-06-15T23:00:00+09:00[Asia/Tokyo]", exit: "2024-06-16T01:00:00+09:00[Asia/Tokyo]", calendarDays: 2 }
  * @example dwellTime("2024-06-15T08:00:00Z", "2024-06-15T17:30:00Z", "Europe/Berlin") // { duration: "PT9H30M", enter: "2024-06-15T10:00:00+02:00[Europe/Berlin]", exit: "2024-06-15T19:30:00+02:00[Europe/Berlin]", calendarDays: 1 }
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "Europe/London") // { duration: "PT2H30M", enter: "2024-06-15T23:30:00+01:00[Europe/London]", exit: "2024-06-16T02:00:00+01:00[Europe/London]", calendarDays: 2 }
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "Europe/Amsterdam") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[Europe/Amsterdam]", exit: "2024-06-16T03:00:00+02:00[Europe/Amsterdam]", calendarDays: 1 } (the same two instants, one fewer day: the zone decides)
- * @example dwellTime("2024-06-15T22:00:00Z", "2024-06-16T04:00:00Z", "America/New_York") // { duration: "PT6H", enter: "2024-06-15T18:00:00-04:00[America/New_York]", exit: "2024-06-16T00:00:00-04:00[America/New_York]", calendarDays: 1 } (an exit exactly at local midnight does not touch the new day)
- * @example dwellTime("2024-03-10T05:00:00Z", "2024-03-10T12:00:00Z", "America/New_York") // { duration: "PT7H", enter: "2024-03-10T00:00:00-05:00[America/New_York]", exit: "2024-03-10T08:00:00-04:00[America/New_York]", calendarDays: 1 } (seven elapsed hours across the spring-forward, one local day)
+ * @example dwellTime("2024-06-15T22:00:00Z", "2024-06-16T04:00:00Z", "America/Caracas") // { duration: "PT6H", enter: "2024-06-15T18:00:00-04:00[America/Caracas]", exit: "2024-06-16T00:00:00-04:00[America/Caracas]", calendarDays: 1 } (an exit exactly at local midnight does not touch the new day)
+ * @example dwellTime("2024-03-31T00:00:00Z", "2024-03-31T07:00:00Z", "Europe/London") // { duration: "PT7H", enter: "2024-03-31T00:00:00+00:00[Europe/London]", exit: "2024-03-31T08:00:00+01:00[Europe/London]", calendarDays: 1 } (seven elapsed hours across the spring-forward, one local day)
  * @example dwellTime("2011-12-30T08:00:00Z", "2011-12-30T11:00:00Z", "Pacific/Apia") // { duration: "PT3H", enter: "2011-12-29T22:00:00-10:00[Pacific/Apia]", exit: "2011-12-31T01:00:00+14:00[Pacific/Apia]", calendarDays: 2 } (29 and 31 December: Samoa deleted the 30th)
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "+02:00") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[+02:00]", exit: "2024-06-16T03:00:00+02:00[+02:00]", calendarDays: 1 } (a fixed offset counts days with no DST)
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z") // null (bare instants and no zone: the day count has no locality)

package/dist/transport/calculate/dwellTime.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { countZonedLocalDates, instantFrom, zonedDateTimeFrom, } from "../../internal/index.js";
 import { isValidInstant } from "../../precision/validate/isValidInstant.js";
 import { isValidTimeZone } from "../../zoned/validate/isValidTimeZone.js";
@@ -80,12 +80,12 @@ function dwellZone(entry, targetZone) {
  *   days are counted in; defaults to `entry`'s bracketed zone
  * @returns exact duration, zone-local entry and exit, and the local calendar days touched, or null on invalid input
  *
- * @example dwellTime("2024-06-15T23:00:00-04:00[America/New_York]", "2024-06-16T01:00:00-04:00[America/New_York]") // { duration: "PT2H", enter: "2024-06-15T23:00:00-04:00[America/New_York]", exit: "2024-06-16T01:00:00-04:00[America/New_York]", calendarDays: 2 }
+ * @example dwellTime("2024-06-15T23:00:00+09:00[Asia/Tokyo]", "2024-06-16T01:00:00+09:00[Asia/Tokyo]") // { duration: "PT2H", enter: "2024-06-15T23:00:00+09:00[Asia/Tokyo]", exit: "2024-06-16T01:00:00+09:00[Asia/Tokyo]", calendarDays: 2 }
  * @example dwellTime("2024-06-15T08:00:00Z", "2024-06-15T17:30:00Z", "Europe/Berlin") // { duration: "PT9H30M", enter: "2024-06-15T10:00:00+02:00[Europe/Berlin]", exit: "2024-06-15T19:30:00+02:00[Europe/Berlin]", calendarDays: 1 }
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "Europe/London") // { duration: "PT2H30M", enter: "2024-06-15T23:30:00+01:00[Europe/London]", exit: "2024-06-16T02:00:00+01:00[Europe/London]", calendarDays: 2 }
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "Europe/Amsterdam") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[Europe/Amsterdam]", exit: "2024-06-16T03:00:00+02:00[Europe/Amsterdam]", calendarDays: 1 } (the same two instants, one fewer day: the zone decides)
- * @example dwellTime("2024-06-15T22:00:00Z", "2024-06-16T04:00:00Z", "America/New_York") // { duration: "PT6H", enter: "2024-06-15T18:00:00-04:00[America/New_York]", exit: "2024-06-16T00:00:00-04:00[America/New_York]", calendarDays: 1 } (an exit exactly at local midnight does not touch the new day)
- * @example dwellTime("2024-03-10T05:00:00Z", "2024-03-10T12:00:00Z", "America/New_York") // { duration: "PT7H", enter: "2024-03-10T00:00:00-05:00[America/New_York]", exit: "2024-03-10T08:00:00-04:00[America/New_York]", calendarDays: 1 } (seven elapsed hours across the spring-forward, one local day)
+ * @example dwellTime("2024-06-15T22:00:00Z", "2024-06-16T04:00:00Z", "America/Caracas") // { duration: "PT6H", enter: "2024-06-15T18:00:00-04:00[America/Caracas]", exit: "2024-06-16T00:00:00-04:00[America/Caracas]", calendarDays: 1 } (an exit exactly at local midnight does not touch the new day)
+ * @example dwellTime("2024-03-31T00:00:00Z", "2024-03-31T07:00:00Z", "Europe/London") // { duration: "PT7H", enter: "2024-03-31T00:00:00+00:00[Europe/London]", exit: "2024-03-31T08:00:00+01:00[Europe/London]", calendarDays: 1 } (seven elapsed hours across the spring-forward, one local day)
  * @example dwellTime("2011-12-30T08:00:00Z", "2011-12-30T11:00:00Z", "Pacific/Apia") // { duration: "PT3H", enter: "2011-12-29T22:00:00-10:00[Pacific/Apia]", exit: "2011-12-31T01:00:00+14:00[Pacific/Apia]", calendarDays: 2 } (29 and 31 December: Samoa deleted the 30th)
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z", "+02:00") // { duration: "PT2H30M", enter: "2024-06-16T00:30:00+02:00[+02:00]", exit: "2024-06-16T03:00:00+02:00[+02:00]", calendarDays: 1 } (a fixed offset counts days with no DST)
  * @example dwellTime("2024-06-15T22:30:00Z", "2024-06-16T01:00:00Z") // null (bare instants and no zone: the day count has no locality)

package/dist/transport/calculate/estimateDrift.d.ts

@@ -40,7 +40,7 @@ export interface DriftReport {
  * - `revisions` is the number of EST records, the first included.
  * - `drift` is the last EST's `at` minus the first's, in exact elapsed time with hours as the
  *   largest unit: positive when the estimate moved later, negative when earlier. Across a
- *   fall-back night, 01:30 EDT to 01:30 EST is `PT1H`.
+ *   fall-back night, 01:30 BST to 01:30 GMT is `PT1H`.
  * - With `tolerance`, `exceedsTolerance` is `true` when the drift, in either direction, is
  *   **greater** than the tolerance; exactly the tolerance is `false`. Without it, `null`.
  * - `first` and `last` echo `at` exactly as written; both are instants (`Z`/offset) or zoned

package/dist/transport/calculate/estimateDrift.js

@@ -13,7 +13,7 @@ import { formatHourDuration, isOptionsArgument, nonNegativeExactDurationNanoseco
  * - `revisions` is the number of EST records, the first included.
  * - `drift` is the last EST's `at` minus the first's, in exact elapsed time with hours as the
  *   largest unit: positive when the estimate moved later, negative when earlier. Across a
- *   fall-back night, 01:30 EDT to 01:30 EST is `PT1H`.
+ *   fall-back night, 01:30 BST to 01:30 GMT is `PT1H`.
  * - With `tolerance`, `exceedsTolerance` is `true` when the drift, in either direction, is
  *   **greater** than the tolerance; exactly the tolerance is `false`. Without it, `null`.
  * - `first` and `last` echo `at` exactly as written; both are instants (`Z`/offset) or zoned

package/dist/transport/calculate/nextDeparture.d.ts

@@ -67,10 +67,10 @@ export interface NextDepartureOptions {
  *
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T08:00:00Z", "2024-06-15T09:30:00Z", "2024-06-15T11:00:00Z"]) // "2024-06-15T09:30:00Z"
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T08:00:00Z", "2024-06-15T09:30:00Z", "2024-06-15T11:00:00Z"], { minimumConnection: "PT45M" }) // "2024-06-15T11:00:00Z" (a 45-minute connection misses the 09:30)
- * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T05:30:00-04:00[America/New_York]"]) // "2024-06-15T05:30:00-04:00[America/New_York]" (echoed as written)
+ * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T05:30:00-04:00[America/Santiago]"]) // "2024-06-15T05:30:00-04:00[America/Santiago]" (echoed as written)
  * @example nextDeparture("2024-06-15T06:05:00+02:00", { headway: "PT20M", from: "2024-06-15T06:00:00+02:00", to: "2024-06-15T09:00:00+02:00" }) // "2024-06-15T06:20:00+02:00"
  * @example nextDeparture("2024-06-15T09:00:00+02:00", { headway: "PT20M", from: "2024-06-15T06:00:00+02:00", to: "2024-06-15T09:00:00+02:00" }) // "" (to is excluded)
- * @example nextDeparture("2024-11-03T01:30:00-04:00[America/New_York]", { headway: "PT1H", from: "2024-11-03T00:00:00-04:00[America/New_York]", to: "2024-11-03T04:00:00-05:00[America/New_York]" }) // "2024-11-03T01:00:00-05:00[America/New_York]" (hourly in exact time: the repeated hour's second pass)
+ * @example nextDeparture("2024-10-27T01:30:00+01:00[Europe/London]", { headway: "PT1H", from: "2024-10-27T00:00:00+01:00[Europe/London]", to: "2024-10-27T04:00:00+00:00[Europe/London]" }) // "2024-10-27T01:00:00+00:00[Europe/London]" (hourly in exact time: the repeated hour's second pass)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00"]) // "" (a timetable entry needs an offset)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00[Europe/London]"]) // "" (a zoned entry needs its offset too)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00Z"], { minimumConnection: "-PT5M" }) // "" (a negative connection)

package/dist/transport/calculate/nextDeparture.js

@@ -91,10 +91,10 @@ function headwayDeparture(threshold, service) {
  *
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T08:00:00Z", "2024-06-15T09:30:00Z", "2024-06-15T11:00:00Z"]) // "2024-06-15T09:30:00Z"
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T08:00:00Z", "2024-06-15T09:30:00Z", "2024-06-15T11:00:00Z"], { minimumConnection: "PT45M" }) // "2024-06-15T11:00:00Z" (a 45-minute connection misses the 09:30)
- * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T05:30:00-04:00[America/New_York]"]) // "2024-06-15T05:30:00-04:00[America/New_York]" (echoed as written)
+ * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T05:30:00-04:00[America/Santiago]"]) // "2024-06-15T05:30:00-04:00[America/Santiago]" (echoed as written)
  * @example nextDeparture("2024-06-15T06:05:00+02:00", { headway: "PT20M", from: "2024-06-15T06:00:00+02:00", to: "2024-06-15T09:00:00+02:00" }) // "2024-06-15T06:20:00+02:00"
  * @example nextDeparture("2024-06-15T09:00:00+02:00", { headway: "PT20M", from: "2024-06-15T06:00:00+02:00", to: "2024-06-15T09:00:00+02:00" }) // "" (to is excluded)
- * @example nextDeparture("2024-11-03T01:30:00-04:00[America/New_York]", { headway: "PT1H", from: "2024-11-03T00:00:00-04:00[America/New_York]", to: "2024-11-03T04:00:00-05:00[America/New_York]" }) // "2024-11-03T01:00:00-05:00[America/New_York]" (hourly in exact time: the repeated hour's second pass)
+ * @example nextDeparture("2024-10-27T01:30:00+01:00[Europe/London]", { headway: "PT1H", from: "2024-10-27T00:00:00+01:00[Europe/London]", to: "2024-10-27T04:00:00+00:00[Europe/London]" }) // "2024-10-27T01:00:00+00:00[Europe/London]" (hourly in exact time: the repeated hour's second pass)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00"]) // "" (a timetable entry needs an offset)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00[Europe/London]"]) // "" (a zoned entry needs its offset too)
  * @example nextDeparture("2024-06-15T09:00:00Z", ["2024-06-15T09:30:00Z"], { minimumConnection: "-PT5M" }) // "" (a negative connection)

package/dist/transport/calculate/scheduleDelivery.d.ts

@@ -109,7 +109,7 @@ export interface DeliverySchedule {
  *   cannot be used for a later one. The missed-connection check still runs after resolution, so a
  *   later zoneless departure that resolves earlier than the cursor is still `null`.
  * - **Local-time resolution policy (`"compatible"`).** A zoned departure written without an
- *   offset (`"2024-11-03T01:30:00[America/New_York]"`), a zoneless first departure read in
+ *   offset (`"2024-10-27T01:30:00[Europe/London]"`), a zoneless first departure read in
  *   `startTimeZone`, and a zoneless later-leg departure read in the previous leg's `timeZone`
  *   are all wall times. An **ambiguous** wall time — a fall-back hour the clock ran through
  *   twice — resolves to the **earlier** instant; a **nonexistent** one — a spring-forward hour
@@ -144,7 +144,7 @@ export interface DeliverySchedule {
  * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00Z", duration: "PT36H", timeZone: "Asia/Tokyo" }]) // { eta: "2024-06-17T07:00:00+09:00[Asia/Tokyo]", legTimes: [{ arrival: "2024-06-16T22:00:00Z", localArrival: "2024-06-17T07:00:00+09:00[Asia/Tokyo]", dwellAfter: "PT0S" }] }
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { duration: "PT5H", timeZone: "Asia/Tokyo" }]) // { eta: "2024-06-16T02:00:00+09:00[Asia/Tokyo]", legTimes: [{ arrival: "2024-06-15T10:00:00Z", localArrival: "2024-06-15T10:00:00+00:00[UTC]", dwellAfter: "PT2H" }, { arrival: "2024-06-15T17:00:00Z", localArrival: "2024-06-16T02:00:00+09:00[Asia/Tokyo]", dwellAfter: "PT0S" }] } (the second leg leaves at 12:00Z, after the dwell)
  * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00Z", duration: "PT1H", timeZone: "UTC", mode: "ship" }]) // { eta: "2024-06-15T11:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T11:00:00Z", localArrival: "2024-06-15T11:00:00+00:00[UTC]", dwellAfter: "PT0S", mode: "ship" }] } (tags echo back; unsupplied tag keys stay absent)
- * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00", duration: "PT1H", timeZone: "UTC" }], { startTimeZone: "America/New_York" }) // { eta: "2024-06-15T15:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T15:00:00Z", localArrival: "2024-06-15T15:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (a published 10:00 wall time, read in New York)
+ * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00", duration: "PT1H", timeZone: "UTC" }], { startTimeZone: "America/Sao_Paulo" }) // { eta: "2024-06-15T14:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T14:00:00Z", localArrival: "2024-06-15T14:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (a published 10:00 wall time, read in São Paulo)
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { departure: "2024-06-15T13:00:00", duration: "PT1H", timeZone: "UTC" }]) // { eta: "2024-06-15T14:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T10:00:00Z", localArrival: "2024-06-15T10:00:00+00:00[UTC]", dwellAfter: "PT2H" }, { arrival: "2024-06-15T14:00:00Z", localArrival: "2024-06-15T14:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (leg 2's zoneless 13:00 is read in leg 1's UTC destination zone, not startTimeZone, since none was supplied)
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { departure: "2024-06-15T11:00:00", duration: "PT1H", timeZone: "UTC" }]) // null (leg 2's zoneless 11:00, read in UTC, falls inside leg 1's dwell: a missed connection)
  * @example scheduleDelivery([]) // { eta: "", legTimes: [] }

package/dist/transport/calculate/scheduleDelivery.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "../../internal/temporal.js";
 import { TIME_ZONE_ANNOTATION, exactDurationNanoseconds, isOptionsArgument, isoStringBody, zonedDateTimeFrom, } from "../../internal/index.js";
 import { isValidDateTime } from "../../plain/validate/isValidDateTime.js";
 import { isValidInstant } from "../../precision/validate/isValidInstant.js";
@@ -231,7 +231,7 @@ function chainLegs(legs, startTimeZone) {
  *   cannot be used for a later one. The missed-connection check still runs after resolution, so a
  *   later zoneless departure that resolves earlier than the cursor is still `null`.
  * - **Local-time resolution policy (`"compatible"`).** A zoned departure written without an
- *   offset (`"2024-11-03T01:30:00[America/New_York]"`), a zoneless first departure read in
+ *   offset (`"2024-10-27T01:30:00[Europe/London]"`), a zoneless first departure read in
  *   `startTimeZone`, and a zoneless later-leg departure read in the previous leg's `timeZone`
  *   are all wall times. An **ambiguous** wall time — a fall-back hour the clock ran through
  *   twice — resolves to the **earlier** instant; a **nonexistent** one — a spring-forward hour
@@ -266,7 +266,7 @@ function chainLegs(legs, startTimeZone) {
  * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00Z", duration: "PT36H", timeZone: "Asia/Tokyo" }]) // { eta: "2024-06-17T07:00:00+09:00[Asia/Tokyo]", legTimes: [{ arrival: "2024-06-16T22:00:00Z", localArrival: "2024-06-17T07:00:00+09:00[Asia/Tokyo]", dwellAfter: "PT0S" }] }
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { duration: "PT5H", timeZone: "Asia/Tokyo" }]) // { eta: "2024-06-16T02:00:00+09:00[Asia/Tokyo]", legTimes: [{ arrival: "2024-06-15T10:00:00Z", localArrival: "2024-06-15T10:00:00+00:00[UTC]", dwellAfter: "PT2H" }, { arrival: "2024-06-15T17:00:00Z", localArrival: "2024-06-16T02:00:00+09:00[Asia/Tokyo]", dwellAfter: "PT0S" }] } (the second leg leaves at 12:00Z, after the dwell)
  * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00Z", duration: "PT1H", timeZone: "UTC", mode: "ship" }]) // { eta: "2024-06-15T11:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T11:00:00Z", localArrival: "2024-06-15T11:00:00+00:00[UTC]", dwellAfter: "PT0S", mode: "ship" }] } (tags echo back; unsupplied tag keys stay absent)
- * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00", duration: "PT1H", timeZone: "UTC" }], { startTimeZone: "America/New_York" }) // { eta: "2024-06-15T15:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T15:00:00Z", localArrival: "2024-06-15T15:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (a published 10:00 wall time, read in New York)
+ * @example scheduleDelivery([{ departure: "2024-06-15T10:00:00", duration: "PT1H", timeZone: "UTC" }], { startTimeZone: "America/Sao_Paulo" }) // { eta: "2024-06-15T14:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T14:00:00Z", localArrival: "2024-06-15T14:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (a published 10:00 wall time, read in São Paulo)
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { departure: "2024-06-15T13:00:00", duration: "PT1H", timeZone: "UTC" }]) // { eta: "2024-06-15T14:00:00+00:00[UTC]", legTimes: [{ arrival: "2024-06-15T10:00:00Z", localArrival: "2024-06-15T10:00:00+00:00[UTC]", dwellAfter: "PT2H" }, { arrival: "2024-06-15T14:00:00Z", localArrival: "2024-06-15T14:00:00+00:00[UTC]", dwellAfter: "PT0S" }] } (leg 2's zoneless 13:00 is read in leg 1's UTC destination zone, not startTimeZone, since none was supplied)
  * @example scheduleDelivery([{ departure: "2024-06-15T00:00:00Z", duration: "PT10H", timeZone: "UTC", dwellAfter: "PT2H" }, { departure: "2024-06-15T11:00:00", duration: "PT1H", timeZone: "UTC" }]) // null (leg 2's zoneless 11:00, read in UTC, falls inside leg 1's dwell: a missed connection)
  * @example scheduleDelivery([]) // { eta: "", legTimes: [] }

package/dist/transport/calculate/transitTime.d.ts

@@ -16,7 +16,7 @@
  *   leg takes "a month" in a sense that time arithmetic can fix without a reference point, and
  *   Temporal's `round` and `total` require a `relativeTo` for them. Scheduled connections that
  *   are dated rather than timed belong to `scheduleDelivery`.
- * - **The departure's zone is preserved.** A bracketed IANA zone (`…-05:00[America/New_York]`)
+ * - **The departure's zone is preserved.** A bracketed IANA zone (`…+09:00[Asia/Tokyo]`)
  *   stays that zone, so the arrival's offset is whatever is in force there at arrival. A `Z`
  *   instant returns a `Z` instant; an offset-only instant keeps its offset, written exactly as
  *   the departure wrote it, sub-minute offsets such as `+05:30:15` included (an offset is not a
@@ -34,9 +34,9 @@
  *   bracketed zone and no offset is resolved in that zone with the `"compatible"` policy,
  *   Temporal's default and `resolveLocal`'s. An **ambiguous** wall time — a fall-back hour the
  *   clock ran through twice — resolves to the **earlier** instant:
- *   `2024-11-03T01:30:00[America/New_York]` is `01:30-04:00`. A **nonexistent** one — a
+ *   `2024-04-07T02:30:00[Australia/Sydney]` is `02:30+11:00`. A **nonexistent** one — a
  *   spring-forward hour the clock skipped — resolves to the **later** instant:
- *   `2024-03-10T02:30:00[America/New_York]` is `03:30-04:00`. Write the offset to name the other
+ *   `2024-10-06T02:30:00[Australia/Sydney]` is `03:30+11:00`. Write the offset to name the other
  *   pass of a repeated hour; a departure that carries its offset is never re-resolved.
  * - RFC 9557 annotations are read as `Temporal.Instant.from` reads them: a bracket without `=`
  *   is a time zone, and a `key=value` bracket with an unknown key is ignored when elective and
@@ -52,18 +52,18 @@
  * @param duration ISO 8601 duration of the leg; time units and 24-hour days only
  * @returns the arrival in the departure's zone or offset form, or "" on invalid input
  *
- * @example transitTime("2024-06-15T10:00:00-04:00[America/New_York]", "PT2H30M") // "2024-06-15T12:30:00-04:00[America/New_York]"
- * @example transitTime("2024-03-09T23:00:00-05:00[America/New_York]", "PT4H") // "2024-03-10T04:00:00-04:00[America/New_York]" (four elapsed hours across the spring-forward, so the wall clock reads 04:00, not 03:00)
- * @example transitTime("2024-03-09T12:00:00-05:00[America/New_York]", "P1D") // "2024-03-10T13:00:00-04:00[America/New_York]" (a day is 24 elapsed hours, not "the same wall time tomorrow")
+ * @example transitTime("2024-06-15T10:00:00+09:00[Asia/Tokyo]", "PT2H30M") // "2024-06-15T12:30:00+09:00[Asia/Tokyo]"
+ * @example transitTime("2024-03-30T23:00:00+00:00[Europe/London]", "PT4H") // "2024-03-31T04:00:00+01:00[Europe/London]" (four elapsed hours across the spring-forward, so the wall clock reads 04:00, not 03:00)
+ * @example transitTime("2024-03-30T12:00:00+00:00[Europe/London]", "P1D") // "2024-03-31T13:00:00+01:00[Europe/London]" (a day is 24 elapsed hours, not "the same wall time tomorrow")
  * @example transitTime("2024-06-15T10:00:00Z", "PT36H") // "2024-06-16T22:00:00Z"
  * @example transitTime("2024-06-15T10:00:00+09:00", "PT1H") // "2024-06-15T11:00:00+09:00" (an offset stays an offset)
  * @example transitTime("2024-06-15T10:00:00+05:30:15", "PT1H") // "2024-06-15T11:00:00+05:30:15" (a sub-minute offset is kept as written)
  * @example transitTime("2024-06-15T10:00:00Z[foo=bar]", "PT1H") // "2024-06-15T11:00:00Z" (an elective unknown annotation is ignored)
- * @example transitTime("2024-06-15T12:30:00-04:00[America/New_York]", "-PT2H30M") // "2024-06-15T10:00:00-04:00[America/New_York]"
- * @example transitTime("2024-11-03T01:30:00[America/New_York]", "PT0S") // "2024-11-03T01:30:00-04:00[America/New_York]" (an ambiguous wall time resolves to the earlier instant)
- * @example transitTime("2024-03-10T02:30:00[America/New_York]", "PT0S") // "2024-03-10T03:30:00-04:00[America/New_York]" (a nonexistent wall time resolves to the later instant)
- * @example transitTime("2024-06-15T10:00:00-04:00[America/New_York]", "P1M") // "" (calendar units need a reference point)
- * @example transitTime("2024-06-15T10:00:00-05:00[America/New_York]", "PT2H") // "" (New York is -04:00 in June: the offset contradicts the zone)
+ * @example transitTime("2024-06-15T12:30:00+09:00[Asia/Tokyo]", "-PT2H30M") // "2024-06-15T10:00:00+09:00[Asia/Tokyo]"
+ * @example transitTime("2024-04-07T02:30:00[Australia/Sydney]", "PT0S") // "2024-04-07T02:30:00+11:00[Australia/Sydney]" (an ambiguous wall time resolves to the earlier instant)
+ * @example transitTime("2024-10-06T02:30:00[Australia/Sydney]", "PT0S") // "2024-10-06T03:30:00+11:00[Australia/Sydney]" (a nonexistent wall time resolves to the later instant)
+ * @example transitTime("2024-06-15T10:00:00+02:00[Africa/Johannesburg]", "P1M") // "" (calendar units need a reference point)
+ * @example transitTime("2024-06-15T10:00:00+00:00[Europe/London]", "PT2H") // "" (London is +01:00 in June: the offset contradicts the zone)
  * @example transitTime("-271821-04-19T23:59:00-00:01[Europe/London]", "PT0S") // "" (a zoned string on a local date before Temporal's date range)
  * @example transitTime("2024-06-15T10:00:00", "PT2H") // "" (no zone and no offset: not a moment)
  * @example transitTime("2024-06-15T10:00:00Z", "2 hours") // ""

package/dist/transport/calculate/transitTime.js

@@ -17,7 +17,7 @@ import { exactDurationNanoseconds, readExactMoment, writeExactMoment, } from "..
  *   leg takes "a month" in a sense that time arithmetic can fix without a reference point, and
  *   Temporal's `round` and `total` require a `relativeTo` for them. Scheduled connections that
  *   are dated rather than timed belong to `scheduleDelivery`.
- * - **The departure's zone is preserved.** A bracketed IANA zone (`…-05:00[America/New_York]`)
+ * - **The departure's zone is preserved.** A bracketed IANA zone (`…+09:00[Asia/Tokyo]`)
  *   stays that zone, so the arrival's offset is whatever is in force there at arrival. A `Z`
  *   instant returns a `Z` instant; an offset-only instant keeps its offset, written exactly as
  *   the departure wrote it, sub-minute offsets such as `+05:30:15` included (an offset is not a
@@ -35,9 +35,9 @@ import { exactDurationNanoseconds, readExactMoment, writeExactMoment, } from "..
  *   bracketed zone and no offset is resolved in that zone with the `"compatible"` policy,
  *   Temporal's default and `resolveLocal`'s. An **ambiguous** wall time — a fall-back hour the
  *   clock ran through twice — resolves to the **earlier** instant:
- *   `2024-11-03T01:30:00[America/New_York]` is `01:30-04:00`. A **nonexistent** one — a
+ *   `2024-04-07T02:30:00[Australia/Sydney]` is `02:30+11:00`. A **nonexistent** one — a
  *   spring-forward hour the clock skipped — resolves to the **later** instant:
- *   `2024-03-10T02:30:00[America/New_York]` is `03:30-04:00`. Write the offset to name the other
+ *   `2024-10-06T02:30:00[Australia/Sydney]` is `03:30+11:00`. Write the offset to name the other
  *   pass of a repeated hour; a departure that carries its offset is never re-resolved.
  * - RFC 9557 annotations are read as `Temporal.Instant.from` reads them: a bracket without `=`
  *   is a time zone, and a `key=value` bracket with an unknown key is ignored when elective and
@@ -53,18 +53,18 @@ import { exactDurationNanoseconds, readExactMoment, writeExactMoment, } from "..
  * @param duration ISO 8601 duration of the leg; time units and 24-hour days only
  * @returns the arrival in the departure's zone or offset form, or "" on invalid input
  *
- * @example transitTime("2024-06-15T10:00:00-04:00[America/New_York]", "PT2H30M") // "2024-06-15T12:30:00-04:00[America/New_York]"
- * @example transitTime("2024-03-09T23:00:00-05:00[America/New_York]", "PT4H") // "2024-03-10T04:00:00-04:00[America/New_York]" (four elapsed hours across the spring-forward, so the wall clock reads 04:00, not 03:00)
- * @example transitTime("2024-03-09T12:00:00-05:00[America/New_York]", "P1D") // "2024-03-10T13:00:00-04:00[America/New_York]" (a day is 24 elapsed hours, not "the same wall time tomorrow")
+ * @example transitTime("2024-06-15T10:00:00+09:00[Asia/Tokyo]", "PT2H30M") // "2024-06-15T12:30:00+09:00[Asia/Tokyo]"
+ * @example transitTime("2024-03-30T23:00:00+00:00[Europe/London]", "PT4H") // "2024-03-31T04:00:00+01:00[Europe/London]" (four elapsed hours across the spring-forward, so the wall clock reads 04:00, not 03:00)
+ * @example transitTime("2024-03-30T12:00:00+00:00[Europe/London]", "P1D") // "2024-03-31T13:00:00+01:00[Europe/London]" (a day is 24 elapsed hours, not "the same wall time tomorrow")
  * @example transitTime("2024-06-15T10:00:00Z", "PT36H") // "2024-06-16T22:00:00Z"
  * @example transitTime("2024-06-15T10:00:00+09:00", "PT1H") // "2024-06-15T11:00:00+09:00" (an offset stays an offset)
  * @example transitTime("2024-06-15T10:00:00+05:30:15", "PT1H") // "2024-06-15T11:00:00+05:30:15" (a sub-minute offset is kept as written)
  * @example transitTime("2024-06-15T10:00:00Z[foo=bar]", "PT1H") // "2024-06-15T11:00:00Z" (an elective unknown annotation is ignored)
- * @example transitTime("2024-06-15T12:30:00-04:00[America/New_York]", "-PT2H30M") // "2024-06-15T10:00:00-04:00[America/New_York]"
- * @example transitTime("2024-11-03T01:30:00[America/New_York]", "PT0S") // "2024-11-03T01:30:00-04:00[America/New_York]" (an ambiguous wall time resolves to the earlier instant)
- * @example transitTime("2024-03-10T02:30:00[America/New_York]", "PT0S") // "2024-03-10T03:30:00-04:00[America/New_York]" (a nonexistent wall time resolves to the later instant)
- * @example transitTime("2024-06-15T10:00:00-04:00[America/New_York]", "P1M") // "" (calendar units need a reference point)
- * @example transitTime("2024-06-15T10:00:00-05:00[America/New_York]", "PT2H") // "" (New York is -04:00 in June: the offset contradicts the zone)
+ * @example transitTime("2024-06-15T12:30:00+09:00[Asia/Tokyo]", "-PT2H30M") // "2024-06-15T10:00:00+09:00[Asia/Tokyo]"
+ * @example transitTime("2024-04-07T02:30:00[Australia/Sydney]", "PT0S") // "2024-04-07T02:30:00+11:00[Australia/Sydney]" (an ambiguous wall time resolves to the earlier instant)
+ * @example transitTime("2024-10-06T02:30:00[Australia/Sydney]", "PT0S") // "2024-10-06T03:30:00+11:00[Australia/Sydney]" (a nonexistent wall time resolves to the later instant)
+ * @example transitTime("2024-06-15T10:00:00+02:00[Africa/Johannesburg]", "P1M") // "" (calendar units need a reference point)
+ * @example transitTime("2024-06-15T10:00:00+00:00[Europe/London]", "PT2H") // "" (London is +01:00 in June: the offset contradicts the zone)
  * @example transitTime("-271821-04-19T23:59:00-00:01[Europe/London]", "PT0S") // "" (a zoned string on a local date before Temporal's date range)
  * @example transitTime("2024-06-15T10:00:00", "PT2H") // "" (no zone and no offset: not a moment)
  * @example transitTime("2024-06-15T10:00:00Z", "2 hours") // ""

package/dist/transport/compare/classifyPunctuality.d.ts

@@ -39,7 +39,7 @@ import type { Punctuality, PunctualityTolerance } from "../../types/index.js";
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T09:49:00Z", { late: "PT15M", early: "PT10M" }) // "early"
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T11:30:00Z", { late: "PT120M" }) // "onTime" (a 90-minute delay under a 120-minute tolerance)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:00:00Z", { late: "PT15M", early: "PT0S" }) // "early" (exactly on the plan is on the early boundary, which is outside)
- * @example classifyPunctuality("2024-11-03T01:30:00-04:00[America/New_York]", "2024-11-03T01:30:00-05:00[America/New_York]", { late: "PT15M" }) // "late" (the same wall time an hour later, across the fall-back)
+ * @example classifyPunctuality("2024-10-27T01:30:00+01:00[Europe/London]", "2024-10-27T01:30:00+00:00[Europe/London]", { late: "PT15M" }) // "late" (the same wall time an hour later, across the fall-back)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:14:00Z", { late: "-PT15M" }) // null (a negative tolerance)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:14:00Z", { late: "P1W" }) // null (weeks need a reference point)
  */

package/dist/transport/compare/classifyPunctuality.js

@@ -39,7 +39,7 @@ import { parseInstantNanoseconds, parsePunctualityTolerance, punctualityOf, } fr
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T09:49:00Z", { late: "PT15M", early: "PT10M" }) // "early"
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T11:30:00Z", { late: "PT120M" }) // "onTime" (a 90-minute delay under a 120-minute tolerance)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:00:00Z", { late: "PT15M", early: "PT0S" }) // "early" (exactly on the plan is on the early boundary, which is outside)
- * @example classifyPunctuality("2024-11-03T01:30:00-04:00[America/New_York]", "2024-11-03T01:30:00-05:00[America/New_York]", { late: "PT15M" }) // "late" (the same wall time an hour later, across the fall-back)
+ * @example classifyPunctuality("2024-10-27T01:30:00+01:00[Europe/London]", "2024-10-27T01:30:00+00:00[Europe/London]", { late: "PT15M" }) // "late" (the same wall time an hour later, across the fall-back)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:14:00Z", { late: "-PT15M" }) // null (a negative tolerance)
  * @example classifyPunctuality("2024-06-15T10:00:00Z", "2024-06-15T10:14:00Z", { late: "P1W" }) // null (weeks need a reference point)
  */