@remit/web-client 0.0.325 → 0.0.327

package/dist/src/lib/calendar-format.js

@@ -0,0 +1,57 @@
+const DAY = new Intl.DateTimeFormat(undefined, {
+    weekday: "short",
+    day: "numeric",
+    month: "long",
+});
+const CLOCK = new Intl.DateTimeFormat(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+});
+const LONG_DAY = new Intl.DateTimeFormat(undefined, {
+    weekday: "long",
+    day: "numeric",
+    month: "long",
+    timeZone: "UTC",
+});
+const CIVIL_DAY = new Intl.DateTimeFormat(undefined, {
+    weekday: "short",
+    day: "numeric",
+    month: "long",
+    timeZone: "UTC",
+});
+/**
+ * "Wed 10 March", for a civil date `YYYY-MM-DD`. A date with no hours is the
+ * same day wherever the reader is, so it is never read as an instant.
+ */
+export function formatCivilDay(date) {
+    return CIVIL_DAY.format(new Date(`${date}T00:00:00Z`));
+}
+/**
+ * "Wed 10 June, 10:00 – 11:00", or the day alone when it runs all of it. An
+ * all-day span is read off its civil date: parsed as an instant, it lands on
+ * the day before anywhere west of UTC.
+ */
+export function formatEventWhen(event) {
+    if (event.allDay)
+        return `${formatCivilDay(event.start.slice(0, 10))}, all day`;
+    const start = new Date(event.start);
+    const end = new Date(event.end);
+    const day = DAY.format(start);
+    const sameDay = DAY.format(end) === day;
+    if (sameDay)
+        return `${day}, ${CLOCK.format(start)} – ${CLOCK.format(end)}`;
+    return `${day}, ${CLOCK.format(start)} – ${DAY.format(end)}, ${CLOCK.format(end)}`;
+}
+/** "Thursday 11 June", for a civil date `YYYY-MM-DD` read on no clock at all. */
+export function formatDayLabel(date) {
+    return LONG_DAY.format(new Date(`${date}T00:00:00Z`));
+}
+/** "10:00", for a clock time `HH:MM` already on the right clock. */
+export function formatClock(time) {
+    return CLOCK.format(new Date(`1970-01-01T${time}:00`));
+}
+/** "10:00", for an instant, on this device's clock. */
+export function formatInstantClock(iso) {
+    return CLOCK.format(new Date(iso));
+}

package/dist/src/lib/calendar-report.d.ts

@@ -0,0 +1,4 @@
+/** A prefilled issue for an invitation answer or read that did not land. */
+export declare function calendarReportHref(what: string): string;
+/** A prefilled issue for an event the calendar could not look up. */
+export declare function calendarEventReportHref(what: string): string;

package/dist/src/lib/calendar-report.js

@@ -0,0 +1,15 @@
+import { buildBugReportContext, buildGitHubIssueUrl } from "./bug-report";
+/** A prefilled issue for an invitation answer or read that did not land. */
+export function calendarReportHref(what) {
+    return buildGitHubIssueUrl(buildBugReportContext({
+        title: `Calendar invitation: ${what}`,
+        errorMessage: what,
+    }));
+}
+/** A prefilled issue for an event the calendar could not look up. */
+export function calendarEventReportHref(what) {
+    return buildGitHubIssueUrl(buildBugReportContext({
+        title: `Calendar event: ${what}`,
+        errorMessage: what,
+    }));
+}

package/dist/src/lib/calendar-route.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The calendar's address, read and written in one place.
+ *
+ * `/calendar/{view}/{date}` and, under it, the event a reader has open. The
+ * five zoom levels are mutually exclusive and each is a different surface, so
+ * the view is a path segment (R5); the date is one too, because the strip is
+ * infinite and the address has to name where it opened — a `?date=` param
+ * would be a query compensating for a missing segment (R4). What the reader
+ * has ticked off modifies the view without changing what is mounted, so the
+ * calendar filter is query (R2), validated here rather than at the read site
+ * (R7).
+ *
+ * Nothing here reads a clock. Every function takes the instant it needs, so
+ * "today" is a decision the caller makes once and this module can be tested
+ * without one.
+ */
+import type { CalendarViewId } from "@remit/ui";
+import { z } from "zod";
+/** The zoom ladder, widest first. The union `@remit/ui` already publishes. */
+export declare const calendarViews: readonly ["year", "month", "week", "day", "agenda"];
+/** Where `/calendar` sends a reader who named no zoom of their own. */
+export declare const DEFAULT_CALENDAR_VIEW: CalendarViewId;
+export declare const calendarViewMountsGrid: (view: CalendarViewId) => boolean;
+/**
+ * The one view the strip draws. It is a zoom of the same ladder rather than a
+ * different screen: the grid is what a reader drops into for a day that has
+ * earned it, and the strip is what they come back out to, with the day and the
+ * ticked calendars they left with.
+ */
+export declare const calendarViewMountsAgenda: (view: CalendarViewId) => boolean;
+/** The view a segment names, or `undefined` where it names none. */
+export declare function parseCalendarView(segment: string): CalendarViewId | undefined;
+/**
+ * The day a segment names, or `undefined`. A date the calendar does not have —
+ * the 31st of February, the 13th month — is not a day, so it is rejected
+ * rather than rolled forward into one the reader did not ask for.
+ */
+export declare function parseCalendarDate(segment: string): string | undefined;
+/** The day an instant falls on, by the clock the reader's device is running. */
+export declare function isoDate(instant: Date): string;
+export interface CalendarParams {
+    view: CalendarViewId;
+    date: string;
+}
+/**
+ * The address a pair of segments resolves to.
+ *
+ * A hand-edited or stale URL is a normal thing to receive, so an unreadable
+ * segment is replaced rather than thrown: the half that was readable is kept,
+ * and the reader lands on a calendar instead of an error. The caller compares
+ * this with what it was given and redirects when they differ, so the address
+ * bar ends up naming exactly what is on screen.
+ */
+export declare function canonicalCalendarParams(segments: {
+    view: string;
+    date: string;
+}, today: string): CalendarParams;
+/**
+ * The day the previous or next screenful starts on. A step is measured in the
+ * view's own unit, which is what makes back-and-forward land where the reader
+ * came from at every zoom. Agenda steps a week, which is far enough to be worth
+ * a press and near enough to stay inside the days it is already holding.
+ */
+export declare function stepCalendarDate(date: string, view: CalendarViewId, direction: -1 | 1): string;
+/**
+ * The calendars a query string has ticked.
+ *
+ * Repeated `calendarId=` params are the shape, and the shape the address is
+ * written back in (`lib/search-params.ts`). They arrive here in three readings
+ * all the same: a list from repeated params, a scalar from a single one, and a
+ * number where the id looked like one. One set of ticked calendars has one
+ * spelling, which is what deduplicating and sorting is for.
+ */
+export declare function readCalendarIds(value: unknown): string[];
+/**
+ * What the calendar reads out of the query, and all of it.
+ *
+ * Ticking nothing off leaves the param out rather than writing an empty list:
+ * the address states what a reader has narrowed to, so a calendar showing
+ * everything is a calendar the query has nothing to say about.
+ *
+ * Density is absent on purpose: it is how much of a day this device fits on
+ * screen, which is a preference the device holds (`lib/calendar-density.ts`)
+ * rather than a fact about the view, so it belongs to no tier of the address.
+ */
+export declare const calendarSearchSchema: z.ZodObject<{
+    calendarId: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], unknown>, string[] | undefined, unknown>;
+}, "strip", z.ZodTypeAny, {
+    calendarId?: string[] | undefined;
+}, {
+    calendarId?: unknown;
+}>;
+export type CalendarSearch = z.infer<typeof calendarSearchSchema>;

package/dist/src/lib/calendar-route.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+/** The zoom ladder, widest first. The union `@remit/ui` already publishes. */
+export const calendarViews = [
+    "year",
+    "month",
+    "week",
+    "day",
+    "agenda",
+];
+const calendarViewSchema = z.enum(calendarViews);
+/** Where `/calendar` sends a reader who named no zoom of their own. */
+export const DEFAULT_CALENDAR_VIEW = "week";
+/**
+ * The views the grid draws. The year is a named surface that arrives in a later
+ * stage, and it says so on screen rather than matching a route that renders
+ * nothing.
+ */
+const GRID_VIEWS = new Set(["month", "week", "day"]);
+export const calendarViewMountsGrid = (view) => GRID_VIEWS.has(view);
+/**
+ * The one view the strip draws. It is a zoom of the same ladder rather than a
+ * different screen: the grid is what a reader drops into for a day that has
+ * earned it, and the strip is what they come back out to, with the day and the
+ * ticked calendars they left with.
+ */
+export const calendarViewMountsAgenda = (view) => view === "agenda";
+/** The view a segment names, or `undefined` where it names none. */
+export function parseCalendarView(segment) {
+    const parsed = calendarViewSchema.safeParse(segment);
+    return parsed.success ? parsed.data : undefined;
+}
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/**
+ * The day a segment names, or `undefined`. A date the calendar does not have —
+ * the 31st of February, the 13th month — is not a day, so it is rejected
+ * rather than rolled forward into one the reader did not ask for.
+ */
+export function parseCalendarDate(segment) {
+    if (!ISO_DATE.test(segment))
+        return undefined;
+    const [year, month, day] = segment.split("-").map(Number);
+    const instant = Date.UTC(year, month - 1, day);
+    const round = new Date(instant);
+    if (round.getUTCFullYear() !== year)
+        return undefined;
+    if (round.getUTCMonth() !== month - 1)
+        return undefined;
+    if (round.getUTCDate() !== day)
+        return undefined;
+    return segment;
+}
+const pad = (value) => String(value).padStart(2, "0");
+/** The day an instant falls on, by the clock the reader's device is running. */
+export function isoDate(instant) {
+    return `${instant.getFullYear()}-${pad(instant.getMonth() + 1)}-${pad(instant.getDate())}`;
+}
+/**
+ * The address a pair of segments resolves to.
+ *
+ * A hand-edited or stale URL is a normal thing to receive, so an unreadable
+ * segment is replaced rather than thrown: the half that was readable is kept,
+ * and the reader lands on a calendar instead of an error. The caller compares
+ * this with what it was given and redirects when they differ, so the address
+ * bar ends up naming exactly what is on screen.
+ */
+export function canonicalCalendarParams(segments, today) {
+    return {
+        view: parseCalendarView(segments.view) ?? DEFAULT_CALENDAR_VIEW,
+        date: parseCalendarDate(segments.date) ?? today,
+    };
+}
+/**
+ * The day the previous or next screenful starts on. A step is measured in the
+ * view's own unit, which is what makes back-and-forward land where the reader
+ * came from at every zoom. Agenda steps a week, which is far enough to be worth
+ * a press and near enough to stay inside the days it is already holding.
+ */
+export function stepCalendarDate(date, view, direction) {
+    const [year, month, day] = date.split("-").map(Number);
+    if (view === "year")
+        return clampedDate(year + direction, month, day);
+    if (view === "month")
+        return clampedDate(year, month + direction, day);
+    const days = view === "day" ? 1 : 7;
+    const stepped = new Date(Date.UTC(year, month - 1, day + days * direction));
+    return isoDateUtc(stepped);
+}
+const isoDateUtc = (instant) => `${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(instant.getUTCDate())}`;
+/**
+ * A month or a year away from a date, held to a day that month has. Stepping
+ * off the 31st of March must land in February rather than skipping it.
+ */
+function clampedDate(year, month, day) {
+    const normalisedYear = year + Math.floor((month - 1) / 12);
+    const normalisedMonth = ((((month - 1) % 12) + 12) % 12) + 1;
+    const lastDay = new Date(Date.UTC(normalisedYear, normalisedMonth, 0)).getUTCDate();
+    return `${normalisedYear}-${pad(normalisedMonth)}-${pad(Math.min(day, lastDay))}`;
+}
+/**
+ * A calendar's id, as the URL carries it.
+ *
+ * Deliberately looser than the id the API mints. An address is something people
+ * paste, bookmark and hand-edit, and what to do with an id that names no
+ * calendar is already settled downstream: the reader is shown the calendars
+ * that do exist. Refusing the segment here would turn a stale link into an
+ * error page instead of a calendar.
+ */
+const calendarIdSchema = z.string().min(1);
+/**
+ * The calendars a query string has ticked.
+ *
+ * Repeated `calendarId=` params are the shape, and the shape the address is
+ * written back in (`lib/search-params.ts`). They arrive here in three readings
+ * all the same: a list from repeated params, a scalar from a single one, and a
+ * number where the id looked like one. One set of ticked calendars has one
+ * spelling, which is what deduplicating and sorting is for.
+ */
+export function readCalendarIds(value) {
+    const raw = value === undefined || value === null ? [] : [value].flat();
+    const named = new Set();
+    for (const entry of raw) {
+        if (typeof entry !== "string" && typeof entry !== "number")
+            continue;
+        const id = calendarIdSchema.safeParse(String(entry));
+        if (id.success)
+            named.add(id.data);
+    }
+    return [...named].sort();
+}
+/**
+ * What the calendar reads out of the query, and all of it.
+ *
+ * Ticking nothing off leaves the param out rather than writing an empty list:
+ * the address states what a reader has narrowed to, so a calendar showing
+ * everything is a calendar the query has nothing to say about.
+ *
+ * Density is absent on purpose: it is how much of a day this device fits on
+ * screen, which is a preference the device holds (`lib/calendar-density.ts`)
+ * rather than a fact about the view, so it belongs to no tier of the address.
+ */
+export const calendarSearchSchema = z.object({
+    calendarId: z
+        .preprocess(readCalendarIds, z.array(calendarIdSchema))
+        .transform((ids) => (ids.length === 0 ? undefined : ids)),
+});

package/dist/src/lib/calendar-subscription.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Where a subscribed calendar's events come from, named by host alone. For a
+ * Google feed the full address is the credential, so no surface draws it.
+ */
+export declare const subscriptionHostOf: (subscriptionUrl: string) => string;
+export declare const subscriptionReadOnlyNote: (subscriptionUrl: string) => string;

package/dist/src/lib/calendar-subscription.js

@@ -0,0 +1,8 @@
+/**
+ * Where a subscribed calendar's events come from, named by host alone. For a
+ * Google feed the full address is the credential, so no surface draws it.
+ */
+export const subscriptionHostOf = (subscriptionUrl) => URL.canParse(subscriptionUrl)
+    ? new URL(subscriptionUrl).host
+    : "an iCalendar feed";
+export const subscriptionReadOnlyNote = (subscriptionUrl) => `Read-only: from ${subscriptionHostOf(subscriptionUrl)}. Change it where the feed comes from.`;

package/dist/src/lib/calendar-suggestion.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A suggestion the server read out of a message, as the calendar kit draws it.
+ *
+ * The API carries projections of the invitation and nothing about who is
+ * looking at it, so what the reader is asked — whether the card still wants an
+ * answer, what the span runs into, which half-hours are open — is decided here,
+ * in one place, rather than in each surface that shows a card.
+ */
+import type { RemitImapCalendarFreeBusySpan, RemitImapCalendarSuggestionResponse } from "@remit/api-http-client/types.gen.ts";
+import { type CalendarClash, type CalendarInvite, type CalendarInviteState, type CalendarSlotPick, type EventSuggestion, type RsvpState } from "@remit/ui";
+export type CalendarSuggestion = RemitImapCalendarSuggestionResponse;
+/** Half an hour is what an offer of another time is worth. */
+export declare const OFFER_MINUTES = 30;
+/** Where the card stands, or nothing when there is no card left to draw. */
+export interface InviteStanding {
+    state: CalendarInviteState;
+    rsvp: RsvpState;
+}
+/**
+ * What a suggestion's state means for its card.
+ *
+ * A dismissed card was waved away without an answer, and stays so it can be
+ * taken back. A cancellation asks for an answer only while it is pending: once
+ * taken or kept, the event it named is settled and there is nothing left to
+ * say beside the message.
+ */
+export declare function inviteStanding(suggestion: CalendarSuggestion): InviteStanding | undefined;
+export declare const isFromInvitation: (suggestion: CalendarSuggestion) => boolean;
+/** The day a suggestion lands on, on the clock this device reads. */
+export declare function suggestionDate(suggestion: CalendarSuggestion): string;
+export declare const suggestionTitle: (suggestion: CalendarSuggestion) => string;
+export declare function suggestionWhen(suggestion: CalendarSuggestion): string;
+export interface InviteContext {
+    threadId: string;
+    threadSubject: string;
+    /** Who the mail came from, for an invitation that names no organiser. */
+    senderName: string;
+    calendarId: string;
+}
+export declare function toCalendarInvite(suggestion: CalendarSuggestion, state: CalendarInviteState, context: InviteContext): CalendarInvite;
+export declare function toEventSuggestion(suggestion: CalendarSuggestion, context: Omit<InviteContext, "senderName"> & {
+    sender: string;
+}): EventSuggestion;
+/**
+ * What is already booked over a span. Busy time is merged across every
+ * calendar on the server and carries no titles, so a clash names the hours it
+ * takes rather than the meeting in them.
+ */
+export declare function clashesOver(span: {
+    start: string;
+    end: string;
+}, busy: readonly RemitImapCalendarFreeBusySpan[]): CalendarClash[];
+/** Half-hours still open on a day, cut out of the busy time the server merged. */
+export declare function slotOffersOn(date: string, busy: readonly RemitImapCalendarFreeBusySpan[]): CalendarSlotPick[];
+/** The picked half-hours as a line a reply can carry. */
+export declare function slotsAsText(date: string, slots: readonly CalendarSlotPick[], picked: readonly string[]): string;

package/dist/src/lib/calendar-suggestion.js

@@ -0,0 +1,165 @@
+import { formatMinute, freeStretchesFromSpans, } from "@remit/ui";
+import { addDays, busySpansByDate } from "../hooks/calendar";
+import { formatCivilDay, formatClock, formatDayLabel, formatEventWhen, formatInstantClock, } from "./calendar-format";
+import { isoDate } from "./calendar-route";
+/** Half an hour is what an offer of another time is worth. */
+export const OFFER_MINUTES = 30;
+/** More than a handful of offers is a timetable, not a reply. */
+const OFFER_LIMIT = 6;
+const ZONES = {
+    Local: "local",
+    Explicit: "explicit",
+    Ambiguous: "ambiguous",
+};
+const AMBIGUOUS_ZONE = "The invitation's time zone could not be resolved. Add opens the editor so you can set the time.";
+const AMBIGUOUS_CANCELLATION = "The invitation's time zone could not be resolved.";
+/**
+ * What a suggestion's state means for its card.
+ *
+ * A dismissed card was waved away without an answer, and stays so it can be
+ * taken back. A cancellation asks for an answer only while it is pending: once
+ * taken or kept, the event it named is settled and there is nothing left to
+ * say beside the message.
+ */
+export function inviteStanding(suggestion) {
+    if (suggestion.method === "Cancel")
+        return suggestion.state === "Pending"
+            ? { state: "cancelled", rsvp: "noReply" }
+            : undefined;
+    if (suggestion.state === "Dismissed")
+        return { state: "dismissed", rsvp: "noReply" };
+    if (suggestion.state === "Superseded")
+        return { state: "superseded", rsvp: "noReply" };
+    if (suggestion.state === "Accepted")
+        return { state: "answered", rsvp: "accepted" };
+    if (suggestion.state === "Declined")
+        return { state: "answered", rsvp: "declined" };
+    if (suggestion.state === "Tentative")
+        return { state: "answered", rsvp: "tentative" };
+    return { state: "pending", rsvp: "noReply" };
+}
+export const isFromInvitation = (suggestion) => suggestion.source !== "TextHeuristic";
+/** The day a suggestion lands on, on the clock this device reads. */
+export function suggestionDate(suggestion) {
+    if (suggestion.allDay)
+        return suggestion.dtStart.slice(0, 10);
+    return isoDate(new Date(suggestion.dtStart));
+}
+export const suggestionTitle = (suggestion) => suggestion.summary === "" ? "Untitled event" : suggestion.summary;
+export function suggestionWhen(suggestion) {
+    if (suggestion.allDay) {
+        const first = suggestion.dtStart.slice(0, 10);
+        const end = suggestion.dtEnd.slice(0, 10);
+        const last = end > first ? addDays(end, -1) : first;
+        return last === first
+            ? `${formatCivilDay(first)}, all day`
+            : `${formatCivilDay(first)} – ${formatCivilDay(last)}, all day`;
+    }
+    return formatEventWhen({
+        start: suggestion.dtStart,
+        end: suggestion.dtEnd,
+        allDay: suggestion.allDay,
+    });
+}
+function proposedEvent(suggestion, context) {
+    return {
+        id: suggestion.suggestionId,
+        calendarId: context.calendarId,
+        title: suggestionTitle(suggestion),
+        start: suggestion.dtStart,
+        end: suggestion.dtEnd,
+        allDay: suggestion.allDay,
+        location: suggestion.location,
+        notes: "",
+        attendees: [],
+        myRsvp: "noReply",
+        threadId: context.threadId,
+        threadSubject: context.threadSubject,
+        timeZone: "",
+        zoneCertainty: ZONES[suggestion.zoneCertainty],
+        recurrenceRule: "",
+        seriesId: "",
+        seriesException: false,
+        status: "confirmed",
+    };
+}
+export function toCalendarInvite(suggestion, state, context) {
+    const organizer = suggestion.organizer === "" ? context.senderName : suggestion.organizer;
+    return {
+        id: suggestion.suggestionId,
+        threadId: context.threadId,
+        proposed: proposedEvent(suggestion, context),
+        organizerName: organizer === "" ? "The sender" : organizer,
+        organizerEmail: suggestion.organizer,
+        method: "ics",
+        evidence: "",
+        state,
+        sequence: suggestion.sequence,
+    };
+}
+function ambiguityOf(suggestion) {
+    if (suggestion.zoneCertainty !== "Ambiguous")
+        return "";
+    return suggestion.method === "Cancel"
+        ? AMBIGUOUS_CANCELLATION
+        : AMBIGUOUS_ZONE;
+}
+export function toEventSuggestion(suggestion, context) {
+    return {
+        id: suggestion.suggestionId,
+        title: suggestionTitle(suggestion),
+        start: suggestion.dtStart,
+        end: suggestion.dtEnd,
+        allDay: suggestion.allDay,
+        location: suggestion.location,
+        threadId: context.threadId,
+        threadSubject: context.threadSubject,
+        sender: context.sender,
+        senderAddress: suggestion.organizer,
+        confidence: isFromInvitation(suggestion) ? 1 : 0.6,
+        ambiguity: ambiguityOf(suggestion),
+        suggestedCalendarId: context.calendarId,
+        timeZone: "",
+        zoneCertainty: ZONES[suggestion.zoneCertainty],
+    };
+}
+const overlaps = (span, busy) => Date.parse(busy.start) < Date.parse(span.end) &&
+    Date.parse(busy.end) > Date.parse(span.start);
+/**
+ * What is already booked over a span. Busy time is merged across every
+ * calendar on the server and carries no titles, so a clash names the hours it
+ * takes rather than the meeting in them.
+ */
+export function clashesOver(span, busy) {
+    return busy
+        .filter((entry) => overlaps(span, entry))
+        .map((entry) => ({
+        id: `${entry.start}/${entry.end}`,
+        label: `Busy ${formatInstantClock(entry.start)} – ${formatInstantClock(entry.end)}`,
+    }));
+}
+/** Half-hours still open on a day, cut out of the busy time the server merged. */
+export function slotOffersOn(date, busy) {
+    const spans = busySpansByDate([date], busy).get(date) ?? [];
+    const offers = [];
+    for (const stretch of freeStretchesFromSpans(date, spans, OFFER_MINUTES)) {
+        for (let minute = stretch.startMinute; minute + OFFER_MINUTES <= stretch.endMinute &&
+            offers.length < OFFER_LIMIT; minute += OFFER_MINUTES) {
+            offers.push({
+                date,
+                endDate: date,
+                startTime: formatMinute(minute),
+                endTime: formatMinute(minute + OFFER_MINUTES),
+                allDay: false,
+            });
+        }
+    }
+    return offers;
+}
+/** The picked half-hours as a line a reply can carry. */
+export function slotsAsText(date, slots, picked) {
+    const times = slots
+        .filter((slot) => picked.includes(slot.startTime))
+        .map((slot) => `${formatClock(slot.startTime)} – ${formatClock(slot.endTime)}`);
+    return `${formatDayLabel(date)}: ${times.join(", ")}`;
+}

package/dist/src/lib/client.d.ts

@@ -0,0 +1,2 @@
+import { client } from "@remit/api-http-client/client.gen.ts";
+export { client };

package/dist/src/lib/client.js

@@ -0,0 +1,30 @@
+import { client } from "@remit/api-http-client/client.gen.ts";
+import { getRuntimeConfig } from "../runtime-config";
+import { ApiError, wrapHttpFailure } from "./api";
+import { taggedFetch } from "./network-error";
+// In production, the config.js apiUrl points at the deployed API Gateway.
+// In local dev, the Vite proxy forwards /api -> localhost:4321 (see vite.config.ts).
+const baseUrl = getRuntimeConfig().apiUrl;
+client.setConfig({
+    baseUrl,
+    // Transport failures are tagged where they happen; see `network-error.ts`.
+    fetch: taggedFetch,
+});
+/**
+ * The hey-api client throws the parsed JSON error *body* on a non-ok response —
+ * a shape with no HTTP status. That makes it impossible to tell a 404 (expected)
+ * from a 500 (fatal) at the call site, which is the whole point of the fail-fast
+ * classifier. This error interceptor re-wraps every HTTP error as an `ApiError`
+ * carrying `response.status`, so `shouldEscalate` / `getErrorStatus` work
+ * uniformly across both clients. The body's `message` is preserved on the
+ * `ApiError` so existing message-prefix checks (e.g. `isMessageNotFoundError`)
+ * keep working.
+ */
+client.interceptors.error.use((error, response) => {
+    if (error instanceof ApiError)
+        return error;
+    if (!response)
+        return error;
+    return wrapHttpFailure(error, response.status);
+});
+export { client };