@northguild/gmt 1.17.0 → 1.19.0

package/dist/internal/operatingSchedule.js

@@ -0,0 +1,756 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { resolveLocal } from "../instant/convert/resolveLocal.js";
+import { isValidDate } from "../plain/validate/isValidDate.js";
+import { isValidTime } from "../plain/validate/isValidTime.js";
+import { parseBusinessCalendar, parseHolidays } from "./businessCalendar.js";
+import { coalesceIntervalNanoseconds, } from "./intervalNanoseconds.js";
+import { isObject, isOptionsArgument } from "./isObject.js";
+import { nextZonedBucketStart, zonedUnitStart } from "./zonedBucket.js";
+import { frameEpochNanoseconds, frameWallClock, frameZoned, zoneFrame, } from "./zoneFrame.js";
+const DISAMBIGUATIONS = [
+    "compatible",
+    "earlier",
+    "later",
+    "reject",
+];
+const WEEKDAY_KEYS = ["1", "2", "3", "4", "5", "6", "7"];
+/**
+ * Local dates a range may span, counted from the date its start falls on: about 27 years, the
+ * same bound `bucketRange` puts on a day walk. A walk that runs out answers with the sentinel,
+ * never a partial list.
+ */
+export const MAX_SCHEDULE_DAYS = 10_000;
+/**
+ * Day buckets one walk may step through: the lookback, the dates, the one date past them that
+ * settles the last, and the extra bucket a fall-back into the previous date opens. The date
+ * limit is the one that binds.
+ */
+const MAX_SCHEDULE_BUCKETS = 2 * MAX_SCHEDULE_DAYS;
+/**
+ * How far before the first instant of interest the walk starts, in nanoseconds (72 hours). A
+ * window is at most one local day of wall time, but a resolved edge can land a whole deleted day
+ * later (`Pacific/Apia` skipped 2011-12-30), so a window that started up to two days earlier can
+ * still be open. Three days clears that with room to spare.
+ */
+const LOOKBACK_NANOSECONDS = 259200000000000n;
+/** TC39 `nsMinInstant` and `nsMaxInstant`: ±10^8 days from the epoch. */
+const MIN_INSTANT_NANOSECONDS = -8640000000000000000000n;
+const MAX_INSTANT_NANOSECONDS = 8640000000000000000000n;
+/**
+ * Where an edge whose wall time lies past Temporal's range resolves: just outside it. Such an
+ * edge has no string, so it is only ever clipped to a range or compared, never returned.
+ */
+const PAST_LAST_INSTANT = MAX_INSTANT_NANOSECONDS + 1n;
+const BEFORE_FIRST_INSTANT = MIN_INSTANT_NANOSECONDS - 1n;
+/**
+ * The search horizon of `nextOpenAt`, `nextCloseAt` and `addOperatingTime` when the caller
+ * gives no `within`: one calendar year in the schedule's zone.
+ */
+export const DEFAULT_OPERATING_HORIZON = "P1Y";
+function parseWindow(value) {
+    if (!isObject(value) || Array.isArray(value)) {
+        return null;
+    }
+    const { from, to } = value;
+    if (typeof from !== "string" ||
+        typeof to !== "string" ||
+        !isValidTime(from) ||
+        !isValidTime(to)) {
+        return null;
+    }
+    const fromTime = Temporal.PlainTime.from(from);
+    const toTime = Temporal.PlainTime.from(to);
+    return {
+        from: fromTime.toString(),
+        to: toTime.toString(),
+        wraps: Temporal.PlainTime.compare(toTime, fromTime) <= 0,
+    };
+}
+function parseWindows(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const windows = [];
+    for (const candidate of value) {
+        const window = parseWindow(candidate);
+        if (window === null) {
+            return null;
+        }
+        windows.push(window);
+    }
+    return windows;
+}
+/**
+ * Parse `OperatingSchedule['weekly']`: an object keyed by ISO weekday `"1"`–`"7"`, each holding an
+ * array of `LocalWindow`s (or `undefined`, meaning closed). Each weekday is read with an ordinary
+ * property get, as Temporal's `Get` reads a field list, so a non-enumerable or inherited weekday
+ * applies. Any other own enumerable key, string or symbol, or a malformed window, returns `null`;
+ * a non-enumerable one is not an entry, as `Object.assign` and spread do not copy it, so a
+ * function carrying the weekdays is read without its built-in `length` and `name`.
+ */
+export function parseWeeklyPattern(value) {
+    if (!isObject(value) || Array.isArray(value)) {
+        return null;
+    }
+    const weekly = Array.from({ length: 8 }, () => []);
+    const record = value;
+    for (const key of Reflect.ownKeys(record)) {
+        if ((typeof key !== "string" || !WEEKDAY_KEYS.includes(key)) &&
+            Object.prototype.propertyIsEnumerable.call(record, key)) {
+            return null;
+        }
+    }
+    for (const key of WEEKDAY_KEYS) {
+        const day = record[key];
+        if (day === undefined) {
+            continue;
+        }
+        const windows = parseWindows(day);
+        if (windows === null) {
+            return null;
+        }
+        weekly[Number(key)] = windows;
+    }
+    return weekly;
+}
+/** `holidays` as a date list or a `BusinessCalendar` (only its `holidays` are read). */
+function parseScheduleHolidays(value) {
+    if (value === undefined) {
+        return new Set();
+    }
+    if (Array.isArray(value)) {
+        return parseHolidays(value);
+    }
+    return parseBusinessCalendar(value)?.holidays ?? null;
+}
+function parseOverrides(value) {
+    if (value === undefined) {
+        return new Map();
+    }
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const overrides = new Map();
+    for (const candidate of value) {
+        if (!isObject(candidate) || Array.isArray(candidate)) {
+            return null;
+        }
+        const { date, windows } = candidate;
+        if (typeof date !== "string" || !isValidDate(date)) {
+            return null;
+        }
+        const key = Temporal.PlainDate.from(date).toString();
+        const parsed = parseWindows(windows);
+        // Two overrides for one date say two different things about it.
+        if (parsed === null || overrides.has(key)) {
+            return null;
+        }
+        overrides.set(key, parsed);
+    }
+    return overrides;
+}
+/** Validate an `OperatingSchedule`, or `null` when any part of it is malformed. */
+export function parseOperatingSchedule(value) {
+    if (!isObject(value) || Array.isArray(value)) {
+        return null;
+    }
+    const { timeZone, weekly, holidays, overrides } = value;
+    const frame = zoneFrame(timeZone);
+    if (typeof timeZone !== "string" || frame === null) {
+        return null;
+    }
+    const weeklyWindows = parseWeeklyPattern(weekly);
+    const holidayDates = parseScheduleHolidays(holidays);
+    const overrideWindows = parseOverrides(overrides);
+    if (weeklyWindows === null ||
+        holidayDates === null ||
+        overrideWindows === null) {
+        return null;
+    }
+    return {
+        timeZone,
+        frame,
+        weekly: weeklyWindows,
+        holidays: holidayDates,
+        overrides: overrideWindows,
+    };
+}
+/**
+ * Read `disambiguation` from an options argument. Omitted means `"compatible"`, as in
+ * `resolveLocal`; anything but the four Temporal values, or an options argument that is not an
+ * object, returns `null`.
+ */
+export function parseScheduleDisambiguation(options) {
+    if (!isOptionsArgument(options)) {
+        return null;
+    }
+    const value = options
+        ?.disambiguation;
+    if (value === undefined) {
+        return "compatible";
+    }
+    return typeof value === "string" && DISAMBIGUATIONS.includes(value)
+        ? value
+        : null;
+}
+/**
+ * The last instant a search may answer with: `from` plus `within` (default one year), added in
+ * the schedule's zone so `P1D` is one local day. It is clamped to the search cap: the last instant
+ * before the local date `MAX_SCHEDULE_DAYS + 1` after the one `from` falls on, so a search answers
+ * anywhere on the 10,000th date and nowhere after it. A horizon past Temporal's last instant is
+ * that instant, since nothing after it can be answered. `null` when `within` is not a
+ * non-negative ISO duration.
+ */
+export function parseSearchHorizon(fromNs, within, frame) {
+    const text = within === undefined ? DEFAULT_OPERATING_HORIZON : within;
+    if (typeof text !== "string") {
+        return null;
+    }
+    let duration;
+    try {
+        duration = Temporal.Duration.from(text);
+    }
+    catch {
+        return null;
+    }
+    if (duration.sign < 0) {
+        return null;
+    }
+    const from = frameZoned(Temporal.Instant.fromEpochNanoseconds(fromNs), frame);
+    const horizon = clampedToRange(() => frameEpochNanoseconds(from.add(duration), frame));
+    const cap = clampedToRange(() => frameEpochNanoseconds(from
+        .toPlainDate()
+        .add({ days: MAX_SCHEDULE_DAYS + 1 })
+        .toZonedDateTime(frame.timeZone), frame) - 1n);
+    return horizon < cap ? horizon : cap;
+}
+/** An instant computed by `instant`, or Temporal's last instant when it lies past the range. */
+function clampedToRange(instant) {
+    try {
+        const nanoseconds = instant();
+        // At a seconds offset west of UTC the instant is later than the stand-in it was computed
+        // on (`frameZoned`), so it can pass the last instant without Temporal throwing.
+        return nanoseconds > MAX_INSTANT_NANOSECONDS
+            ? MAX_INSTANT_NANOSECONDS
+            : nanoseconds;
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return MAX_INSTANT_NANOSECONDS;
+        }
+        throw error;
+    }
+}
+/** The local date of an instant in the schedule's zone. */
+function localDateOf(schedule, ns) {
+    return frameWallClock(Temporal.Instant.fromEpochNanoseconds(ns), schedule.frame).toPlainDate();
+}
+/**
+ * The local date `days` after the one `fromNs` falls on, or `null` when that is past Temporal's
+ * last date: no walk from `fromNs` can reach it before time runs out.
+ */
+function dateLimit(schedule, fromNs, days) {
+    try {
+        return localDateOf(schedule, fromNs).add({ days });
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * The day bucket the walk starts in: the one holding the instant 72 hours before `fromNs`, or
+ * the earliest instant the schedule's frame can place when that is earlier. When the bucket's own
+ * start is not representable, the walk starts at that instant instead, the earliest of its date
+ * there is.
+ *
+ * The earliest instant is Temporal's first, except at an offset with seconds west of UTC: its
+ * stand-in sits the offset's seconds before the instant (`frameZoned`), so the first instant it
+ * can place is that many seconds after Temporal's first. A walk from before it throws
+ * `RangeError`, the caller's sentinel, rather than start after its own instant.
+ *
+ * `atRangeStart` is true when the walk starts at that earliest instant. No day bucket lies
+ * before it, so the windows of the local date before the bucket's own are not reached by walking
+ * back: the walk carries them in (`resolveWindowsBefore`).
+ */
+function firstWalkBucket(schedule, fromNs) {
+    const shift = schedule.frame.shiftNanoseconds;
+    const earliestNs = shift < 0n ? MIN_INSTANT_NANOSECONDS - shift : MIN_INSTANT_NANOSECONDS;
+    if (fromNs < earliestNs) {
+        throw new RangeError("the instant is before the first the frame can place");
+    }
+    const atRangeStart = fromNs - LOOKBACK_NANOSECONDS <= earliestNs;
+    const startNs = atRangeStart ? earliestNs : fromNs - LOOKBACK_NANOSECONDS;
+    const zoned = frameZoned(Temporal.Instant.fromEpochNanoseconds(startNs), schedule.frame);
+    try {
+        return { bucket: zonedUnitStart(zoned, "day"), atRangeStart };
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return { bucket: zoned, atRangeStart };
+        }
+        throw error;
+    }
+}
+/** The windows that apply on `date`: an override, else nothing on a holiday, else the weekday's. */
+function windowsOn(schedule, date) {
+    const key = date.toString();
+    const override = schedule.overrides.get(key);
+    if (override !== undefined) {
+        return override;
+    }
+    return schedule.holidays.has(key) ? [] : schedule.weekly[date.dayOfWeek];
+}
+/**
+ * Resolve one window edge with `resolveLocal`. An edge on a date Temporal cannot hold is already
+ * outside the range. A wall time outside Temporal's range fails under every policy, so it
+ * resolves just outside the range, on the side its date lies. `undefined` means `"reject"`
+ * refused it.
+ */
+function resolveEdge(edge, timeZone, disambiguation) {
+    if (typeof edge === "bigint") {
+        return { ns: edge, text: "" };
+    }
+    const local = `${edge.date.toString()}T${edge.time}`;
+    const text = resolveLocal(local, timeZone, { disambiguation });
+    if (text !== "") {
+        return { ns: Temporal.Instant.from(text).epochNanoseconds, text };
+    }
+    if (disambiguation === "reject" && resolveLocal(local, timeZone) !== "") {
+        return undefined;
+    }
+    return {
+        ns: edge.date.year > 0 ? PAST_LAST_INSTANT : BEFORE_FIRST_INSTANT,
+        text: "",
+    };
+}
+/** The local date after `date`, or `null` past Temporal's last date. */
+function dateAfter(date) {
+    try {
+        return date.add({ days: 1 });
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return null;
+        }
+        throw error;
+    }
+}
+/** The local date before `date`, or `null` before Temporal's first date. */
+function dateBefore(date) {
+    try {
+        return date.subtract({ days: 1 });
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Resolve the windows of one local date to instants with `resolveLocal`. Each edge is resolved on
+ * its own under `disambiguation`; a wrapping window's `to` is read on the next date. An edge pair
+ * that resolves to an empty or inverted span (a window shorter than the gap it straddles) is
+ * dropped.
+ *
+ * `date` is `null` for the date before Temporal's first, and `next` is `null` for the date after
+ * its last. A window is a rule about the local clock, so it still holds on the side of it that
+ * Temporal can reach: an edge on a date Temporal cannot hold lies just outside the range.
+ *
+ * Under `"earlier"`, an edge in a gap moves back by the gap's length (TC39
+ * DisambiguatePossibleEpochNanoseconds), so a date whose midnight is skipped can open before its
+ * own first instant, on the previous date. No zone has jumped forward by more than a day, so a
+ * window never starts before the previous date's first instant.
+ *
+ * Under `"reject"`, a window with an ambiguous or nonexistent edge is not guessed: it is returned
+ * in `unresolved` as the widest span it could cover (its start read `"earlier"`, its end
+ * `"later"`), so the caller can refuse an answer it might change and ignore it elsewhere.
+ */
+function resolveDateWindows(schedule, windows, date, next, disambiguation) {
+    const records = [];
+    const unresolved = [];
+    const { timeZone } = schedule;
+    for (const window of windows) {
+        const startEdge = date === null ? BEFORE_FIRST_INSTANT : { date, time: window.from };
+        const endDate = window.wraps ? next : date;
+        const endEdge = endDate === null
+            ? window.wraps
+                ? PAST_LAST_INSTANT
+                : BEFORE_FIRST_INSTANT
+            : { date: endDate, time: window.to };
+        const start = resolveEdge(startEdge, timeZone, disambiguation);
+        const end = resolveEdge(endEdge, timeZone, disambiguation);
+        if (start === undefined || end === undefined) {
+            // "earlier" and "later" always resolve, so the widest span is always known.
+            const earliest = resolveEdge(startEdge, timeZone, "earlier");
+            const latest = resolveEdge(endEdge, timeZone, "later");
+            unresolved.push({
+                start: earliest?.ns ?? BEFORE_FIRST_INSTANT,
+                end: latest?.ns ?? PAST_LAST_INSTANT,
+            });
+            continue;
+        }
+        if (start.ns < end.ns) {
+            records.push({
+                start: start.ns,
+                end: end.ns,
+                startText: start.text,
+                endText: end.text,
+            });
+        }
+    }
+    return { records, unresolved };
+}
+/**
+ * Resolve the windows of the local date before `date`, the first date of a walk that starts at
+ * the earliest instant its frame can place.
+ *
+ * A window that opened on that date and wraps past midnight is still open on `date`, although
+ * the instant it opened at is before the range. The previous date follows its own override or
+ * holiday like any other. West of UTC the first date is Temporal's first, `-271821-04-19`, and
+ * the date before it cannot be held or named: no override or holiday can be written for it, so
+ * the weekly pattern applies, by the weekday before `date`'s.
+ */
+function resolveWindowsBefore(schedule, date, disambiguation) {
+    const previous = dateBefore(date);
+    const windows = previous === null
+        ? schedule.weekly[date.dayOfWeek === 1 ? 7 : date.dayOfWeek - 1]
+        : windowsOn(schedule, previous);
+    return resolveDateWindows(schedule, windows, previous, date, disambiguation);
+}
+/**
+ * Resolve the windows a walk gains on reaching `date`: the date's own and, for the first date of
+ * a walk from the start of the range (`carryIn`), those of the date before it.
+ */
+function resolveVisit(schedule, date, carryIn, disambiguation) {
+    const own = resolveDateWindows(schedule, windowsOn(schedule, date), date, dateAfter(date), disambiguation);
+    if (!carryIn) {
+        return own;
+    }
+    const before = resolveWindowsBefore(schedule, date, disambiguation);
+    return {
+        records: [...before.records, ...own.records],
+        unresolved: [...before.unresolved, ...own.unresolved],
+    };
+}
+/**
+ * Walk the schedule's local dates from a little before `fromNs`, handing the visitor each open
+ * run as soon as no later window can extend it.
+ *
+ * - Dates come from the day buckets `floorToZone` and `bucketRange` use, so a deleted date
+ *   (`Pacific/Apia`, 2011-12-30) is never visited, and a date the clock re-enters after a
+ *   fall-back (`America/Goose_Bay`, 2010-11-06) is visited once.
+ * - A window can start as early as the previous date's first instant (see `resolveDateWindows`),
+ *   so the walk settles one date behind: once a date is resolved, the first instant of the date
+ *   resolved before it is the `bound` no later window starts before.
+ * - A walk from the start of Temporal's range also resolves the date before its first, whose
+ *   wrapping windows are still open when the range begins (`resolveWindowsBefore`).
+ * - When the visitor stops the walk from `day`, or the last representable day is reached, the
+ *   runs still pending are handed over too.
+ * - Returns `null` when a day bucket could not be found, or the walk would resolve a date
+ *   `MAX_SCHEDULE_DAYS + 2` after the one `fromNs` falls on. Neither use reaches that: a range
+ *   is refused up front past `MAX_SCHEDULE_DAYS` dates, and a search's horizon ends with the
+ *   `MAX_SCHEDULE_DAYS`th date, so its walk stops by the horizon one date later.
+ */
+export function walkSchedule(schedule, fromNs, disambiguation, visitor) {
+    let pending = [];
+    let unresolvedStart;
+    const finish = () => ({ unresolvedStart });
+    const flush = () => {
+        for (const run of pending) {
+            if (visitor.run(run)) {
+                break;
+            }
+        }
+        return finish();
+    };
+    // The span a range or search may cover, plus the date after its last, which is resolved to
+    // settle it because its windows can start before its own first instant.
+    const limitDate = dateLimit(schedule, fromNs, MAX_SCHEDULE_DAYS + 2);
+    const first = firstWalkBucket(schedule, fromNs);
+    let current = first.bucket;
+    // True until the first date is resolved, for a walk from the start of the range.
+    let carryIn = first.atRangeStart;
+    let lastDate = null;
+    let bound;
+    for (let bucket = 0; bucket < MAX_SCHEDULE_BUCKETS; bucket++) {
+        if (current === null) {
+            return null;
+        }
+        if (bound !== undefined) {
+            const settleBefore = bound;
+            for (const run of pending) {
+                if (run.end >= settleBefore) {
+                    break;
+                }
+                if (visitor.run(run)) {
+                    return finish();
+                }
+            }
+            pending = pending.filter((run) => run.end >= settleBefore);
+            if (visitor.day(settleBefore, pending)) {
+                return flush();
+            }
+        }
+        const date = current.toPlainDate();
+        // A fall-back that re-enters the previous date opens a second bucket for it; its windows
+        // were already resolved on the first visit.
+        if (lastDate === null || Temporal.PlainDate.compare(date, lastDate) > 0) {
+            if (limitDate !== null &&
+                Temporal.PlainDate.compare(date, limitDate) >= 0) {
+                return null;
+            }
+            const resolved = resolveVisit(schedule, date, carryIn, disambiguation);
+            carryIn = false;
+            for (const window of resolved.unresolved) {
+                if (window.end > fromNs &&
+                    (unresolvedStart === undefined || window.start < unresolvedStart)) {
+                    unresolvedStart = window.start;
+                }
+            }
+            pending = coalesceIntervalNanoseconds([...pending, ...resolved.records]);
+            lastDate = date;
+            bound = frameEpochNanoseconds(current, schedule.frame);
+        }
+        try {
+            current = nextZonedBucketStart(current, "day");
+        }
+        catch (error) {
+            // The next day starts past Temporal's last instant: nothing more can open.
+            if (error instanceof RangeError) {
+                return flush();
+            }
+            throw error;
+        }
+    }
+    return null;
+}
+/**
+ * The schedule's open runs clipped to `[startNs, endNs)`, in the range's own strings where a run
+ * is clipped. `null` when the walk fails (see `walkSchedule`), or when a window rejected under
+ * `"reject"` reaches into the range.
+ */
+export function scheduleRunsWithin(schedule, range, disambiguation) {
+    // Refuse a range spanning more than MAX_SCHEDULE_DAYS local dates before walking it. Walking
+    // thousands of dates only to return the sentinel took seconds.
+    const lastInstant = range.end > range.start ? range.end - 1n : range.end;
+    const limit = dateLimit(schedule, range.start, MAX_SCHEDULE_DAYS);
+    if (limit !== null &&
+        Temporal.PlainDate.compare(localDateOf(schedule, lastInstant), limit) >= 0) {
+        return null;
+    }
+    const runs = [];
+    const walked = walkSchedule(schedule, range.start, disambiguation, {
+        run: (run) => {
+            if (run.start >= range.end) {
+                return true;
+            }
+            if (run.end > range.start) {
+                const clipStart = run.start < range.start;
+                const clipEnd = run.end > range.end;
+                runs.push({
+                    start: clipStart ? range.start : run.start,
+                    end: clipEnd ? range.end : run.end,
+                    startText: clipStart ? range.startText : run.startText,
+                    endText: clipEnd ? range.endText : run.endText,
+                });
+            }
+            return false;
+        },
+        day: (bound) => bound >= range.end,
+    });
+    if (walked === null ||
+        (walked.unresolvedStart !== undefined && walked.unresolvedStart < range.end)) {
+        return null;
+    }
+    return runs.filter((run) => run.start < run.end);
+}
+/** The later of two instants. */
+function later(a, b) {
+    return a > b ? a : b;
+}
+/**
+ * The first instant at or after `fromNs` that the schedule is open: `fromNs` itself inside an
+ * open run, else the start of the next run. Answered as soon as no later window can open
+ * sooner, without waiting for the run to close. `undefined` when none falls at or before
+ * `horizonNs`, `null` when the walk fails or a window rejected under `"reject"` could open
+ * sooner.
+ */
+export function firstOpenInstant(schedule, fromNs, horizonNs, disambiguation) {
+    let answer;
+    const walked = walkSchedule(schedule, fromNs, disambiguation, {
+        run: (run) => {
+            if (answer !== undefined) {
+                return true;
+            }
+            if (run.end <= fromNs) {
+                return false;
+            }
+            answer = later(run.start, fromNs);
+            return true;
+        },
+        day: (bound, pending) => {
+            if (bound > horizonNs) {
+                return true;
+            }
+            const next = pending.find((run) => run.end > fromNs);
+            if (next !== undefined && later(next.start, fromNs) <= bound) {
+                answer = later(next.start, fromNs);
+                return true;
+            }
+            return false;
+        },
+    });
+    if (walked === null) {
+        return null;
+    }
+    if (answer === undefined || answer > horizonNs) {
+        return undefined;
+    }
+    const { unresolvedStart } = walked;
+    return answer > fromNs &&
+        unresolvedStart !== undefined &&
+        unresolvedStart < answer
+        ? null
+        : answer;
+}
+/**
+ * The first instant at or after `fromNs` that the schedule is closed: `fromNs` itself outside
+ * every open run, else the end of the run holding it. A closed `fromNs` is answered as soon as
+ * no later window can cover it. `undefined` when the answer falls after `horizonNs`, `null` when
+ * the walk fails or a window rejected under `"reject"` could keep the schedule open past it.
+ */
+export function firstClosedInstant(schedule, fromNs, horizonNs, disambiguation) {
+    let answer;
+    const walked = walkSchedule(schedule, fromNs, disambiguation, {
+        run: (run) => {
+            if (answer !== undefined) {
+                return true;
+            }
+            if (run.end <= fromNs) {
+                return false;
+            }
+            answer = run.start <= fromNs ? run.end : fromNs;
+            return true;
+        },
+        day: (bound, pending) => {
+            if (bound > horizonNs) {
+                return true;
+            }
+            const next = pending.find((run) => run.end > fromNs);
+            // Closed at `fromNs`, and every later window starts after it.
+            if (fromNs < bound && (next === undefined || next.start > fromNs)) {
+                answer = fromNs;
+                return true;
+            }
+            return false;
+        },
+    });
+    if (walked === null) {
+        return null;
+    }
+    const closed = answer ?? fromNs;
+    if (closed > horizonNs) {
+        return undefined;
+    }
+    const { unresolvedStart } = walked;
+    return unresolvedStart !== undefined && unresolvedStart <= closed
+        ? null
+        : closed;
+}
+/**
+ * The instant at which `amountNs` of open time has elapsed since `fromNs`: the earliest `X`
+ * with exactly that much open time in `[fromNs, X)`. `fromNs` itself when `amountNs` is zero.
+ * Answered as soon as no later window can add open time before `X`. `undefined` when `X` falls
+ * after `horizonNs`, `null` when the walk fails or a window rejected under `"reject"` could add
+ * open time before `X`.
+ */
+export function instantAfterOpenTime(schedule, fromNs, amountNs, horizonNs, disambiguation) {
+    if (amountNs === 0n) {
+        return fromNs;
+    }
+    let remaining = amountNs;
+    let answer;
+    const walked = walkSchedule(schedule, fromNs, disambiguation, {
+        run: (run) => {
+            if (answer !== undefined) {
+                return true;
+            }
+            if (run.end <= fromNs) {
+                return false;
+            }
+            const start = later(run.start, fromNs);
+            if (run.end - start >= remaining) {
+                answer = start + remaining;
+                return true;
+            }
+            remaining -= run.end - start;
+            return false;
+        },
+        day: (bound, pending) => {
+            if (bound > horizonNs) {
+                return true;
+            }
+            // Every pending run ends at or after `bound`, so only the first can hold a deadline at or
+            // before it; open time before `bound` is final.
+            const next = pending.find((run) => run.end > fromNs);
+            if (next !== undefined) {
+                const deadline = later(next.start, fromNs) + remaining;
+                if (deadline <= next.end && deadline <= bound) {
+                    answer = deadline;
+                    return true;
+                }
+            }
+            return false;
+        },
+    });
+    if (walked === null) {
+        return null;
+    }
+    if (answer === undefined || answer > horizonNs) {
+        return undefined;
+    }
+    const { unresolvedStart } = walked;
+    return unresolvedStart !== undefined && unresolvedStart < answer
+        ? null
+        : answer;
+}
+const NANOSECONDS_PER_UNIT = {
+    hours: 3600000000000n,
+    minutes: 60000000000n,
+    seconds: 1000000000n,
+    milliseconds: 1000000n,
+    microseconds: 1000n,
+    nanoseconds: 1n,
+};
+/**
+ * An amount of open time in nanoseconds, from an ISO duration of hours and smaller units.
+ * `null` for a negative duration, for any calendar unit (years, months, weeks or days — `P1D`
+ * could mean 24 open hours or one working day, so it is not guessed), or invalid input.
+ */
+export function parseOpenTimeAmount(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    try {
+        const duration = Temporal.Duration.from(value);
+        if (duration.sign < 0 ||
+            duration.years !== 0 ||
+            duration.months !== 0 ||
+            duration.weeks !== 0 ||
+            duration.days !== 0) {
+            return null;
+        }
+        return Object.keys(NANOSECONDS_PER_UNIT).reduce((total, unit) => total + BigInt(duration[unit]) * NANOSECONDS_PER_UNIT[unit], 0n);
+    }
+    catch {
+        return null;
+    }
+}
+/** Epoch nanoseconds as a UTC instant string ending in `Z`. */
+export function instantText(nanoseconds) {
+    return Temporal.Instant.fromEpochNanoseconds(nanoseconds).toString();
+}