@patientos/website-kit 0.1.0

package/dist/patient-surface-theme.d.ts

@@ -0,0 +1,22 @@
+/** The four theme values an island will honour. Anything absent falls back to kit defaults. */
+interface PatientSurfaceTheme {
+    /** Brand colour — the island's primary. */
+    primary?: string;
+    /** Secondary emphasis colour. */
+    accent?: string;
+    /** Corner radius, a plain CSS length. */
+    radius?: string;
+    /** Font family stack. */
+    fontFamily?: string;
+}
+/**
+ * The clinic-supplied half of an island's theme, validated.
+ *
+ * Reads `primary` (falling back to the `brandColor` key the brand row uses), `accent`,
+ * `radius` and `fontFamily` off a loose token bag. Every value is checked; failures are
+ * dropped silently — a broken token should degrade to the kit default, never fail a build
+ * or a render. `null`/absent tokens yield `{}`.
+ */
+declare function patientSurfaceTheme(themeTokens: Record<string, unknown> | null): PatientSurfaceTheme;
+
+export { type PatientSurfaceTheme, patientSurfaceTheme };

package/dist/patient-surface-theme.js

@@ -0,0 +1,7 @@
+import {
+  patientSurfaceTheme
+} from "./chunk-JTZ6GYA7.js";
+import "./chunk-MLKGABMK.js";
+export {
+  patientSurfaceTheme
+};

package/dist/portal-account-EhOtLV5u.d.ts

@@ -0,0 +1,113 @@
+import * as React from 'react';
+
+/** Which portal surface this panel shows. */
+type PortalSurface = 'appointments' | 'documents' | 'orders' | 'profile';
+/** JSON-safe island configuration. Crosses the build→runtime boundary — see `./islands`. */
+type PortalPanelProps = {
+    /** The surface to render. Required — a panel is always ONE surface. */
+    surface: PortalSurface;
+    /**
+     * Where a signed-out visitor is sent to sign in. Omitted ⇒ the app's reserved
+     * `/portal` path on this same origin.
+     */
+    portalUrl?: string;
+};
+/** Marker-only props: the island config plus presentation the page controls. */
+type PortalPanelMarkerProps = PortalPanelProps & {
+    className?: string;
+};
+/**
+ * BUILD-TIME marker. Emits the mount point plus a static no-JS fallback.
+ *
+ * The fallback deliberately shows NO patient data (there is none at build time — the
+ * page is ONE static artifact served to every visitor) and only a sign-in link. It is
+ * fully VISIBLE, not a hidden skeleton: this HTML is what a crawler indexes, what a
+ * screen reader reads before the island mounts, and what a patient with JS blocked
+ * gets permanently. A `visibility:hidden` / `opacity:0` placeholder would make the
+ * no-JS experience a blank box.
+ */
+declare function PortalPanel({ surface, portalUrl, className, }: PortalPanelMarkerProps): React.ReactElement;
+
+/** A service the launcher can offer — what the build snapshot carries, nothing more. */
+type LauncherService = {
+    /** The clinic-stable `service.key`; what the funnel starts from. */
+    key: string;
+    label: string;
+};
+
+/** The build-time wiring an island is handed (the snapshot's `publicApi` block). */
+interface PublicApiConfig {
+    publishableKey: string;
+    /** '' ⇒ same-origin (the one-origin case). */
+    apiBase: string;
+    turnstileSiteKey?: string;
+    portalUrl?: string;
+    portalOrigin?: string;
+}
+
+/**
+ * Which account surface this island renders.
+ *
+ * A SUPERSET of `<PortalPanel/>`'s four: the teaser can only summarise things that
+ * already exist, so it has no `book` and no `addresses` — there is nothing to tease. The
+ * four shared names stay identical so a clinic page can pair a teaser and a full surface
+ * without a second vocabulary (PAT-783), and the account island adds the two DOING
+ * surfaces on top (PAT-789).
+ */
+type PortalAccountSurface = PortalSurface | 'book' | 'addresses';
+/** JSON-safe island configuration. Crosses the build→runtime boundary — see `./islands`. */
+type PortalAccountProps = {
+    /** The surface to render. Required — one island is always ONE surface. */
+    surface: PortalAccountSurface;
+    /**
+     * The portal's base path on this origin, used for the two things this island still
+     * does NOT inline (joining a telehealth consult, the signed-out/unreachable fallback).
+     * Omitted ⇒ the app's reserved `/portal`.
+     */
+    portalUrl?: string;
+    /**
+     * The SITE page carrying `<PortalAccount surface="book"/>`.
+     *
+     * Booking is inline now (PAT-789), so "Book an appointment" must land on the clinic's
+     * OWN page rather than bouncing to `/portal/book` — the bounce is the seam one-origin
+     * exists to remove. Omitted ⇒ `/account/book`, where the scaffolded account pages live.
+     */
+    bookHref?: string;
+    /**
+     * The SITE page carrying `<PortalAccount surface="appointments"/>` — where a completed
+     * booking sends the patient. Omitted ⇒ `bookHref` minus its last segment, which is the
+     * right answer for the scaffolded `/account/book` → `/account` pairing.
+     *
+     * NO CONSUMER since PAT-899: the account area stopped completing bookings when `book`
+     * became a launcher, and the funnel owns where a finished request lands. Kept so pages
+     * already passing it keep building; drop it once no site does.
+     */
+    appointmentsHref?: string;
+    /**
+     * The SITE page carrying `<CertificateFunnel/>` — where the `book` surface sends a
+     * patient who picks a service (PAT-899). Omitted ⇒ `/certificates`.
+     */
+    funnelHref?: string;
+    /** The clinic's services, for the `book` launcher. */
+    services?: LauncherService[];
+    /** How the launcher reaches the public API to price those services. */
+    publicApi?: PublicApiConfig;
+    /** Shown when the clinic has published no services at all. */
+    clinicPhone?: string;
+};
+/** Marker-only props: the island config plus presentation the page controls. */
+type PortalAccountMarkerProps = PortalAccountProps & {
+    className?: string;
+};
+/**
+ * BUILD-TIME marker. Emits the mount point plus a static no-JS fallback.
+ *
+ * The fallback is REAL, VISIBLE content — a sign-in card with a link into the portal —
+ * not a hidden skeleton. This HTML is what a crawler indexes, what a screen reader reads
+ * before the island mounts, and what a patient with JavaScript blocked gets PERMANENTLY.
+ * It shows no patient data because there is none at build time: the page is ONE static
+ * artifact served to every visitor.
+ */
+declare function PortalAccount({ surface, portalUrl, bookHref, appointmentsHref, funnelHref, className, }: PortalAccountMarkerProps): React.ReactElement;
+
+export { PortalAccount as P, type PortalAccountMarkerProps as a, type PortalAccountProps as b, type PortalAccountSurface as c, PortalPanel as d, type PortalPanelMarkerProps as e, type PortalPanelProps as f, type PortalSurface as g };

package/dist/portal-account.client-CTget1-3.d.ts

@@ -0,0 +1,169 @@
+import * as React from 'react';
+import { b as PortalAccountProps } from './portal-account-EhOtLV5u.js';
+
+/** The injectable fetch. Present so every behaviour here is provable without a DOM. */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/**
+ * The outcome of one portal call. A VALUE, never a throw.
+ *
+ * `status` is the HTTP status when the server answered and refused, and `null` when the
+ * transport failed or the body was not JSON — the caller needs that distinction because
+ * a 404 means "the clinic turned this off" (a quiet note) while a transport failure means
+ * "we cannot answer here" (link out).
+ */
+type PortalResult<T> = {
+    ok: true;
+    data: T;
+}
+/**
+ * `body` is the parsed error payload when there was one — typed `unknown`, NOT `T`:
+ * a refusal is not the success shape, and a caller must narrow it before trusting a
+ * field (see `hasPortalIdentity`). Keeping it off `T` also keeps a failed result
+ * assignable across surface types, which the callers that pass one through rely on.
+ */
+ | {
+    ok: false;
+    status: number | null;
+    error: string | null;
+    body?: unknown;
+};
+
+type PortalAddress = {
+    id: string;
+    line1?: string | null;
+    line2?: string | null;
+    suburb?: string | null;
+    state?: string | null;
+    postcode?: string | null;
+    /** Exactly one row is the primary. The SERVER owns that invariant, not this island. */
+    isPrimary?: boolean;
+    label?: string | null;
+};
+type PortalAddressesBody = {
+    items: PortalAddress[];
+};
+
+type PortalAppointment = {
+    id: string;
+    title?: string | null;
+    status?: string | null;
+    start?: string | null;
+    end?: string | null;
+    timezone?: string | null;
+    locationName?: string | null;
+    practitionerName?: string | null;
+    telehealth?: boolean;
+    canCancel?: boolean;
+    canReschedule?: boolean;
+    /**
+     * The server's own answer to "can this patient join the video room right now?" — the
+     * join window is open AND the clinic has telehealth configured. When true the button
+     * shows regardless of `joinOpensAt` (PAT-792).
+     */
+    canJoin?: boolean;
+    /**
+     * When the join window OPENS, ISO. Present on a telehealth row whose window is still
+     * ahead, so the page can flip to the button on the LOCAL clock rather than making the
+     * patient reload at the exact moment they least want to. The mint re-checks anyway.
+     */
+    joinOpensAt?: string | null;
+};
+type PortalAppointmentsBody = {
+    upcoming: PortalAppointment[];
+    past: PortalAppointment[];
+};
+type PortalDocument = {
+    id: string;
+    title?: string | null;
+    status?: string | null;
+    date?: string | null;
+};
+type PortalDocumentsBody = {
+    items: PortalDocument[];
+};
+type PortalOrder = {
+    id: string;
+    title?: string | null;
+    status?: string | null;
+    paymentStatus?: string | null;
+    total?: string | null;
+    currency?: string | null;
+    placedAt?: string | null;
+};
+type PortalOrdersBody = {
+    items: PortalOrder[];
+};
+type PortalProfile = {
+    givenName?: string | null;
+    familyName?: string | null;
+    email?: string | null;
+    phone?: string | null;
+    dateOfBirth?: string | null;
+};
+/** The body of whichever surface this island is showing. */
+type PortalSurfaceBody = PortalAppointmentsBody | PortalDocumentsBody | PortalOrdersBody | PortalProfile | PortalAddressesBody;
+/**
+ * Everything the island can be showing. A discriminated union derived once by
+ * `loadPortalAccount`, so the render is a pure function of state — and so the whole
+ * boot (including every failure mode) is testable without a DOM.
+ */
+type PortalAccountState = 
+/**
+ * Booting. `hinted` means a previous page in this TAB was signed in (PAT-797) — the
+ * account tabs are four separate documents, so without it every tab click flashes
+ * "Checking your sign-in…" for an answer that has not changed. Hinted, we show the
+ * shape of the surface instead and let the response fill it in. ADVISORY ONLY: it
+ * never gates what the patient is shown, it only picks the placeholder.
+ */
+{
+    kind: 'loading';
+    hinted?: boolean;
+}
+/** No patient session on this host — show the inline magic-link ramp. */
+ | {
+    kind: 'signed-out';
+}
+/** A link was requested; we never say whether the address matched an account. */
+ | {
+    kind: 'link-sent';
+    email: string;
+} | {
+    kind: 'signed-in';
+    givenName: string | null;
+    data: PortalSurfaceBody;
+}
+/** Signed in, but the clinic has this module off. A quiet note, NOT an error. */
+ | {
+    kind: 'not-available';
+    givenName: string | null;
+}
+/** We cannot answer here. Degrades to a plain link out. */
+ | {
+    kind: 'link-out';
+};
+/** How a fetched URL is opened. Injected so the open is assertable without a DOM. */
+type OpenUrl = (url: string) => void;
+type PortalAccountClientProps = PortalAccountProps & {
+    /** Test seam: the initial state, so the view is renderable without effects. */
+    initialState?: PortalAccountState;
+    /** Test seam: the fetch every call goes through. Defaults to the global one. */
+    fetchImpl?: FetchLike;
+    /** Test seam: how a minted document/receipt URL is opened. */
+    openUrl?: OpenUrl;
+};
+/**
+ * The island entry point, which forks on ONE surface.
+ *
+ * `book` is a LAUNCHER now (PAT-899), and a launcher is not an account view: it shows the
+ * clinic's public service list, identically to everyone. Routing it around the session
+ * machinery is not an optimisation — it is the behaviour. Sending it through the shared
+ * path would make it fetch a surface it does not read, and would put a sign-in ramp in
+ * front of a patient who is ready to book, when the funnel it links to is itself an
+ * anonymous flow that upgrades on session.
+ *
+ * A wrapper rather than an early return inside the view, so the branch cannot be mistaken
+ * for a conditional hook.
+ */
+declare function PortalAccountClient(props: PortalAccountClientProps): React.ReactElement;
+
+export { type FetchLike as F, PortalAccountClient as P, type PortalAppointment as a, type PortalAppointmentsBody as b, type PortalResult as c };

package/dist/portal-booking-client.d.ts

@@ -0,0 +1,232 @@
+import * as React from 'react';
+import { a as PortalAppointment, F as FetchLike, b as PortalAppointmentsBody, c as PortalResult } from './portal-account.client-CTget1-3.js';
+import './portal-account-EhOtLV5u.js';
+
+/** One bookable instant, collapsing the practitioners free at the same time. */
+interface TimeSlot {
+    start: string;
+    practitionerId: string;
+    /** How many practitioners are free — drives the "1 left" nudge. */
+    count: number;
+}
+
+type PortalBookingType = {
+    id: string;
+    key?: string | null;
+    label?: string | null;
+    durationMinutes?: number | null;
+    description?: string | null;
+    modality?: string | null;
+};
+type PortalBookingTypesBody = {
+    types: PortalBookingType[];
+};
+type PortalAvailabilitySlot = {
+    start: string;
+    end?: string | null;
+    practitionerId?: string | null;
+    practitionerName?: string | null;
+    locationName?: string | null;
+    timezone?: string | null;
+};
+type PortalAvailabilityBody = {
+    slots: PortalAvailabilitySlot[];
+    timezone: string;
+};
+/** The advisory reservation. `expiresAt` is shown to the patient, never enforced here. */
+type PortalHold = {
+    holdId: string;
+    expiresAt?: string | null;
+};
+/**
+ * What the server hands back to drive a reschedule.
+ *
+ * Read LOOSELY on purpose: it may carry the slots itself (one round trip) or only the
+ * appointment type to fetch availability for (two). Both are supported, so the server
+ * half can settle on either without breaking a published site — which is a real risk
+ * here, because a clinic's site is a static artifact built at a moment in time.
+ */
+type PortalRescheduleContext = {
+    appointment?: (PortalAppointment & {
+        appointmentType?: {
+            id?: string | null;
+            label?: string | null;
+        } | null;
+    }) | null;
+    appointmentTypeId?: string | null;
+    typeLabel?: string | null;
+    slots?: PortalAvailabilitySlot[];
+    timezone?: string | null;
+};
+/**
+ * The appointment type to fetch availability for. The server (PAT-789 canonical
+ * contract) nests it as `appointment.appointmentType.id`; the flat `appointmentTypeId`
+ * stays supported so an older artifact keeps working if the shape ever flattens.
+ */
+declare function rescheduleContextTypeId(ctx: PortalRescheduleContext): string | null;
+declare const PORTAL_BOOKING_TYPES_URL = "/portal/api/booking/types";
+/** The reschedule context for one appointment. */
+declare function portalRescheduleContextUrl(id: string): string;
+declare const SLOT_TAKEN_COPY = "That time just filled up. Please choose another.";
+declare const BOOK_FAILED_COPY = "We couldn't book that time just now. Please try again.";
+declare const AVAILABILITY_FAILED_COPY = "We could not load available times.";
+declare const RESCHEDULE_CUTOFF_COPY = "It's too close to your appointment to change it online. Please call the clinic and we'll sort it out.";
+declare const RESCHEDULE_FAILED_COPY = "We couldn't move that appointment just now. Please try again.";
+/** Normalise a `{types:[…]}` body — a missing or wrong-typed list is an EMPTY list. */
+declare function readPortalBookingTypes(body: unknown): PortalBookingTypesBody;
+/**
+ * Normalise an availability body.
+ *
+ * The timezone is the CLINIC's and travels with the answer: a patient booking a Perth
+ * clinic from Sydney must see Perth wall-clock times or they turn up two hours out. It is
+ * read from the body, then from the first slot, then falls back — never from the browser.
+ */
+declare function readPortalAvailability(body: unknown): PortalAvailabilityBody;
+/**
+ * Collapse raw slots into the board's `TimeSlot`s.
+ *
+ * Several practitioners free at the same minute is ONE choice for a patient with a count
+ * behind it (which drives the "1 left" nudge) — the same collapsing the anonymous funnel
+ * does, so the two grids read identically.
+ */
+declare function portalTimeSlots(slots: readonly PortalAvailabilitySlot[]): TimeSlot[];
+/** The first raw slot at an instant — where the practitioner/location labels come from. */
+declare function portalSlotAt(slots: readonly PortalAvailabilitySlot[], start?: string | null): PortalAvailabilitySlot | null;
+/**
+ * The availability window: from today, out a fortnight.
+ *
+ * `YYYY-MM-DD`, NOT an ISO instant. The edge validates `from`/`to` through the canonical
+ * `availabilityQuery` schema, whose dates are strictly date-only — an instant is a 400
+ * `invalid_query`, so the surface could never load a single time (PAT-796). The anonymous
+ * widget has always sent date-only here; this is the same window, spelled the same way.
+ *
+ * Losing the time component costs nothing: the availability core drops slots starting
+ * before `now + leadTimeMinutes`, so a same-day window never offers a time that has
+ * already passed. The day keys are UTC, matching the public path exactly.
+ *
+ * Pure + exported so the range is assertable without freezing the clock in a component
+ * test. Fourteen days matches the public booking window the anonymous funnel uses.
+ */
+declare function portalAvailabilityWindow(now?: number, days?: number): {
+    from: string;
+    to: string;
+};
+declare function portalAvailabilityUrl(typeId: string, window?: {
+    from: string;
+    to: string;
+}): string;
+declare function loadPortalBookingTypes(fetchImpl?: FetchLike): Promise<PortalResult<PortalBookingTypesBody>>;
+declare function loadPortalAvailability(typeId: string, fetchImpl?: FetchLike, window?: {
+    from: string;
+    to: string;
+}): Promise<PortalResult<PortalAvailabilityBody>>;
+/**
+ * Take an advisory hold on a slot.
+ *
+ * Returns `null` rather than an error on failure: a hold that could not be taken is a
+ * missing courtesy, not a reason to stop a patient booking. The caller carries on.
+ */
+declare function createPortalHold(input: {
+    typeId: string;
+    start: string;
+    practitionerId?: string | null;
+}, fetchImpl?: FetchLike): Promise<PortalHold | null>;
+/** Give a hold back when the patient steps away from the confirm screen. Best-effort. */
+declare function releasePortalHold(holdId: string, fetchImpl?: FetchLike): Promise<{
+    ok: boolean;
+}>;
+type PortalBookInput = {
+    typeId: string;
+    start: string;
+    practitionerId?: string | null;
+    holdId?: string | null;
+};
+/** The outcome a patient is shown. `slotTaken` is the one failure with a next step. */
+type PortalBookOutcome = {
+    ok: true;
+    appointmentId: string | null;
+} | {
+    ok: false;
+    slotTaken: boolean;
+    error: string;
+};
+/**
+ * Book. The AUTHORITATIVE call — the hold above only reduced the odds of losing the race.
+ *
+ * A 409 means someone else got there first, which is not the patient's mistake: it is
+ * reported as "choose another" and the caller refetches, never as an error they must
+ * interpret.
+ */
+declare function bookPortalAppointment(input: PortalBookInput, fetchImpl?: FetchLike): Promise<PortalBookOutcome>;
+/** What a reschedule context read can turn into. `cutoff` is a real, expected answer. */
+type PortalRescheduleContextOutcome = {
+    ok: true;
+    context: PortalRescheduleContext;
+} | {
+    ok: false;
+    cutoff: boolean;
+    error: string;
+};
+/**
+ * Read the reschedule context.
+ *
+ * A 409 is the CUTOFF: the appointment is too close to move online. That is clinic policy
+ * working, not a failure — it gets its own copy telling the patient to call, because
+ * "something went wrong, try again" would have them retrying forever.
+ */
+declare function loadPortalRescheduleContext(id: string, fetchImpl?: FetchLike): Promise<PortalRescheduleContextOutcome>;
+type PortalRescheduleOutcome = {
+    ok: true;
+    data: PortalAppointmentsBody;
+} | {
+    ok: false;
+    cutoff: boolean;
+    slotTaken: boolean;
+    error: string;
+};
+/**
+ * Move the appointment, then RE-READ the list.
+ *
+ * Server-confirmed, never optimistic — the same rule as cancelling. A move the server
+ * refused that the UI had already redrawn would send a patient to the clinic on the wrong
+ * day, which is the worst outcome this island can produce.
+ */
+declare function reschedulePortalAppointmentAndReload(id: string, input: {
+    start: string;
+    practitionerId?: string | null;
+}, fetchImpl?: FetchLike): Promise<PortalRescheduleOutcome>;
+/** One line describing a chosen time: the day + time, then who and where. */
+declare function PortalSlotSummary({ start, slot, tz, typeLabel, }: {
+    start: string;
+    slot: PortalAvailabilitySlot | null;
+    tz: string;
+    typeLabel?: string | null;
+}): React.ReactElement;
+interface PortalRescheduleInlineProps {
+    appointment: PortalAppointment;
+    fetchImpl?: FetchLike;
+    /** The re-read list, after a successful move. */
+    onRescheduled: (data: PortalAppointmentsBody) => void;
+    onClose: () => void;
+    /** Test seam: the interaction state a static render should start from. */
+    initialUi?: {
+        context?: PortalRescheduleContext | null;
+        slots?: PortalAvailabilitySlot[] | null;
+        tz?: string;
+        selected?: TimeSlot | null;
+        confirming?: boolean;
+        error?: string | null;
+        /** A blocking answer with no picker behind it — the cutoff. */
+        blocked?: string | null;
+    };
+}
+/**
+ * Rescheduling, expanded IN PLACE under the appointment it moves.
+ *
+ * In place rather than a route or a dialog: the patient is standing on the clinic's own
+ * page, a modal over a layout we do not control is a shape we cannot make safe, and the
+ * row above is the context that makes "move it to when?" a sensible question.
+ */
+declare function PortalRescheduleInline({ appointment, fetchImpl, onRescheduled, onClose, initialUi, }: PortalRescheduleInlineProps): React.ReactElement;
+
+export { AVAILABILITY_FAILED_COPY, BOOK_FAILED_COPY, PORTAL_BOOKING_TYPES_URL, type PortalAvailabilityBody, type PortalAvailabilitySlot, type PortalBookInput, type PortalBookOutcome, type PortalBookingType, type PortalBookingTypesBody, type PortalHold, type PortalRescheduleContext, type PortalRescheduleContextOutcome, PortalRescheduleInline, type PortalRescheduleInlineProps, type PortalRescheduleOutcome, PortalSlotSummary, RESCHEDULE_CUTOFF_COPY, RESCHEDULE_FAILED_COPY, SLOT_TAKEN_COPY, bookPortalAppointment, createPortalHold, loadPortalAvailability, loadPortalBookingTypes, loadPortalRescheduleContext, portalAvailabilityUrl, portalAvailabilityWindow, portalRescheduleContextUrl, portalSlotAt, portalTimeSlots, readPortalAvailability, readPortalBookingTypes, releasePortalHold, rescheduleContextTypeId, reschedulePortalAppointmentAndReload };

package/dist/portal-booking-client.js

@@ -0,0 +1,51 @@
+import {
+  AVAILABILITY_FAILED_COPY,
+  BOOK_FAILED_COPY,
+  PORTAL_BOOKING_TYPES_URL,
+  PortalRescheduleInline,
+  PortalSlotSummary,
+  RESCHEDULE_CUTOFF_COPY,
+  RESCHEDULE_FAILED_COPY,
+  SLOT_TAKEN_COPY,
+  bookPortalAppointment,
+  createPortalHold,
+  loadPortalAvailability,
+  loadPortalBookingTypes,
+  loadPortalRescheduleContext,
+  portalAvailabilityUrl,
+  portalAvailabilityWindow,
+  portalRescheduleContextUrl,
+  portalSlotAt,
+  portalTimeSlots,
+  readPortalAvailability,
+  readPortalBookingTypes,
+  releasePortalHold,
+  rescheduleContextTypeId,
+  reschedulePortalAppointmentAndReload
+} from "./chunk-G3U6EXJM.js";
+import "./chunk-MLKGABMK.js";
+export {
+  AVAILABILITY_FAILED_COPY,
+  BOOK_FAILED_COPY,
+  PORTAL_BOOKING_TYPES_URL,
+  PortalRescheduleInline,
+  PortalSlotSummary,
+  RESCHEDULE_CUTOFF_COPY,
+  RESCHEDULE_FAILED_COPY,
+  SLOT_TAKEN_COPY,
+  bookPortalAppointment,
+  createPortalHold,
+  loadPortalAvailability,
+  loadPortalBookingTypes,
+  loadPortalRescheduleContext,
+  portalAvailabilityUrl,
+  portalAvailabilityWindow,
+  portalRescheduleContextUrl,
+  portalSlotAt,
+  portalTimeSlots,
+  readPortalAvailability,
+  readPortalBookingTypes,
+  releasePortalHold,
+  rescheduleContextTypeId,
+  reschedulePortalAppointmentAndReload
+};

package/dist/script-sources.d.ts

@@ -0,0 +1,11 @@
+/** Kit-authored chunk served beside a published islands site's `main.js`. */
+declare const CONSULT_CHUNK_PATH = "assets/portal-consult.js";
+/** Third-party script origins permitted on published islands sites. */
+declare const TURNSTILE_SCRIPT_ORIGIN = "https://challenges.cloudflare.com";
+declare const BPOINT_SCRIPT_ORIGIN = "https://www.bpoint.com.au";
+declare const THIRD_PARTY_SCRIPT_ORIGINS: readonly ["https://challenges.cloudflare.com", "https://www.bpoint.com.au"];
+/** Provider entry scripts loaded lazily by kit-owned islands. */
+declare const TURNSTILE_SCRIPT_URL = "https://challenges.cloudflare.com/turnstile/v0/api.js";
+declare const BPOINT_SCRIPT_URL = "https://www.bpoint.com.au/rest/clientscripts/api.js";
+
+export { BPOINT_SCRIPT_ORIGIN, BPOINT_SCRIPT_URL, CONSULT_CHUNK_PATH, THIRD_PARTY_SCRIPT_ORIGINS, TURNSTILE_SCRIPT_ORIGIN, TURNSTILE_SCRIPT_URL };

package/dist/script-sources.js

@@ -0,0 +1,17 @@
+import {
+  BPOINT_SCRIPT_ORIGIN,
+  BPOINT_SCRIPT_URL,
+  CONSULT_CHUNK_PATH,
+  THIRD_PARTY_SCRIPT_ORIGINS,
+  TURNSTILE_SCRIPT_ORIGIN,
+  TURNSTILE_SCRIPT_URL
+} from "./chunk-ZOF22TJA.js";
+import "./chunk-MLKGABMK.js";
+export {
+  BPOINT_SCRIPT_ORIGIN,
+  BPOINT_SCRIPT_URL,
+  CONSULT_CHUNK_PATH,
+  THIRD_PARTY_SCRIPT_ORIGINS,
+  TURNSTILE_SCRIPT_ORIGIN,
+  TURNSTILE_SCRIPT_URL
+};