@patientos/website-kit 0.2.6 → 0.2.8

package/dist/chunk-S3ZQQOQT.js

@@ -0,0 +1,2057 @@
+import {
+  BPOINT_SCRIPT_URL
+} from "./chunk-ZOF22TJA.js";
+import {
+  createStoreClient,
+  formatMoney
+} from "./chunk-7BUDUYXN.js";
+import {
+  cartToWireLines,
+  mutateCart,
+  normalizeCartLines,
+  readCart,
+  subtractPurchasedCartLines,
+  withCartLock
+} from "./chunk-4NF7SSIX.js";
+
+// src/checkout-block.client.tsx
+import * as React from "react";
+
+// src/address-picker.tsx
+import { useCallback, useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEBOUNCE_MS = 300;
+var MIN_QUERY = 3;
+function nextActiveIndex(current, count, delta) {
+  if (count <= 0) return -1;
+  const next = current + delta;
+  if (next < 0) return count - 1;
+  if (next >= count) return 0;
+  return next;
+}
+function AddressPicker({
+  value,
+  onChange,
+  search,
+  validate,
+  idPrefix,
+  disabled,
+  error,
+  label = "Address"
+}) {
+  const [query, setQuery] = useState("");
+  const [suggestions, setSuggestions] = useState([]);
+  const [active, setActive] = useState(-1);
+  const [open, setOpen] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [checking, setChecking] = useState(false);
+  const [refused, setRefused] = useState(null);
+  const live = useRef({ search, validate });
+  live.current = { search, validate };
+  const seq = useRef(0);
+  useEffect(() => {
+    const q = query.trim();
+    setRefused(null);
+    if (q.length < MIN_QUERY) {
+      setSuggestions([]);
+      setOpen(false);
+      return;
+    }
+    setBusy(true);
+    const mine = ++seq.current;
+    const timer = setTimeout(() => {
+      live.current.search(q).then((next) => {
+        if (mine !== seq.current) return;
+        setSuggestions(next);
+        setActive(-1);
+        setOpen(next.length > 0);
+      }).catch(() => {
+        if (mine !== seq.current) return;
+        setSuggestions([]);
+        setOpen(false);
+      }).finally(() => {
+        if (mine === seq.current) setBusy(false);
+      });
+    }, DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [query]);
+  const choose = useCallback(
+    (s) => {
+      onChange({ address: s.label, placeId: s.placeId });
+      setQuery("");
+      setSuggestions([]);
+      setOpen(false);
+    },
+    [onChange]
+  );
+  const checkTyped = useCallback(async () => {
+    const address = query.trim();
+    if (!address || checking) return;
+    setChecking(true);
+    setRefused(null);
+    try {
+      const confirmed = await live.current.validate(address);
+      if (!confirmed) {
+        setRefused("We couldn\u2019t verify that address. Check it and try again.");
+        return;
+      }
+      onChange(confirmed);
+      setQuery("");
+      setSuggestions([]);
+      setOpen(false);
+    } catch {
+      setRefused("We couldn\u2019t verify that address. Check it and try again.");
+    } finally {
+      setChecking(false);
+    }
+  }, [query, checking, onChange]);
+  const inputId = `${idPrefix}-address`;
+  const errorId = `${idPrefix}-address-error`;
+  const listId = `${idPrefix}-address-list`;
+  if (value) {
+    return /* @__PURE__ */ jsxs("div", { className: "sk-address sk-address--picked", children: [
+      /* @__PURE__ */ jsx("span", { className: "sk-address__label", children: label }),
+      /* @__PURE__ */ jsx("p", { className: "sk-address__chosen", children: value.address }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "sk-address__change",
+          disabled,
+          onClick: () => onChange(null),
+          children: "Change"
+        }
+      )
+    ] });
+  }
+  function onKeyDown(e) {
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      if (!open || suggestions.length === 0) return;
+      e.preventDefault();
+      setActive((i) => nextActiveIndex(i, suggestions.length, e.key === "ArrowDown" ? 1 : -1));
+      return;
+    }
+    if (e.key === "Escape" && open) {
+      e.preventDefault();
+      setOpen(false);
+      return;
+    }
+    if (e.key === "Enter") {
+      e.preventDefault();
+      const chosen = open && active >= 0 ? suggestions[active] : void 0;
+      if (chosen) choose(chosen);
+      else if (suggestions.length === 0) void checkTyped();
+    }
+  }
+  const showNoMatches = query.trim().length >= MIN_QUERY && !busy && suggestions.length === 0;
+  const status = checking ? "Checking that address\u2026" : busy ? "Searching\u2026" : open && suggestions.length > 0 ? `${suggestions.length} ${suggestions.length === 1 ? "address" : "addresses"} found. Use the arrow keys to review them.` : showNoMatches ? "No matches for that search." : "";
+  return /* @__PURE__ */ jsxs("div", { className: "sk-address", children: [
+    /* @__PURE__ */ jsx("label", { className: "sk-address__label", htmlFor: inputId, children: label }),
+    /* @__PURE__ */ jsxs("div", { className: "sk-address__box", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          id: inputId,
+          type: "text",
+          role: "combobox",
+          className: "sk-address__input",
+          autoComplete: "off",
+          "aria-expanded": open,
+          "aria-controls": listId,
+          "aria-autocomplete": "list",
+          "aria-activedescendant": active >= 0 ? `${listId}-${active}` : void 0,
+          "aria-busy": busy || void 0,
+          "aria-invalid": error || refused ? true : void 0,
+          "aria-describedby": error || refused ? errorId : void 0,
+          placeholder: "Start typing your address\u2026",
+          disabled,
+          value: query,
+          onChange: (e) => setQuery(e.target.value),
+          onKeyDown
+        }
+      ),
+      open && /* @__PURE__ */ jsx(
+        "ul",
+        {
+          className: "sk-address__list",
+          id: listId,
+          role: "listbox",
+          "aria-label": "Address suggestions",
+          children: suggestions.map((s, i) => /* @__PURE__ */ jsx(
+            "li",
+            {
+              id: `${listId}-${i}`,
+              role: "option",
+              "aria-selected": i === active,
+              className: ["sk-address__option", i === active ? "sk-address__option--active" : null].filter(Boolean).join(" "),
+              onMouseDown: (e) => {
+                e.preventDefault();
+                choose(s);
+              },
+              children: s.label
+            },
+            s.placeId
+          ))
+        }
+      )
+    ] }),
+    showNoMatches && /* @__PURE__ */ jsxs("div", { className: "sk-address__empty", children: [
+      /* @__PURE__ */ jsx("p", { children: "No matches for that search." }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "sk-address__check",
+          disabled: checking,
+          onClick: () => void checkTyped(),
+          children: checking ? "Checking\u2026" : "Check this address"
+        }
+      )
+    ] }),
+    (error || refused) && /* @__PURE__ */ jsx("p", { className: "sk-address__error", id: errorId, children: refused ?? error }),
+    /* @__PURE__ */ jsx("p", { className: "sk-address__status", role: "status", "aria-live": "polite", children: status })
+  ] });
+}
+
+// src/checkout-attempt-token.ts
+var CHECKOUT_ATTEMPT_TOKEN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isCheckoutAttemptToken(value) {
+  return typeof value === "string" && CHECKOUT_ATTEMPT_TOKEN.test(value);
+}
+
+// src/checkout-completion.ts
+function checkoutCompletionUrl(configuredHref, orderId, siteOrigin) {
+  const fallback = new URL("/checkout/complete", siteOrigin);
+  let destination;
+  try {
+    destination = new URL(configuredHref || fallback.pathname, siteOrigin);
+  } catch {
+    destination = fallback;
+  }
+  if (destination.origin !== fallback.origin || destination.protocol !== "http:" && destination.protocol !== "https:") {
+    destination = fallback;
+  }
+  destination.searchParams.set("order", orderId);
+  return `${destination.pathname}${destination.search}${destination.hash}`;
+}
+
+// src/bpoint-client.ts
+function bpoint() {
+  return globalThis.BPOINT;
+}
+var loadPromise = null;
+var SCRIPT_TIMEOUT_MS = 15e3;
+var CALLBACK_TIMEOUT_MS = 3e4;
+function loadBpointScript() {
+  if (loadPromise) return loadPromise;
+  loadPromise = new Promise((resolve, reject) => {
+    if (typeof window !== "undefined" && bpoint()) {
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = BPOINT_SCRIPT_URL;
+    script.type = "text/javascript";
+    const timer = setTimeout(
+      () => reject(new Error("The payment gateway did not load. Please try again.")),
+      SCRIPT_TIMEOUT_MS
+    );
+    script.onload = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    script.onerror = () => {
+      clearTimeout(timer);
+      reject(new Error("Failed to load BPOINT script"));
+    };
+    document.head.appendChild(script);
+  });
+  loadPromise = loadPromise.catch((err) => {
+    loadPromise = null;
+    throw err;
+  });
+  return loadPromise;
+}
+async function attachCardToAuthKey(authKey, card) {
+  await loadBpointScript();
+  const digits = card.number.replace(/\D/g, "");
+  const exp = card.expiry.replace(/\D/g, "");
+  const api = bpoint();
+  if (!api) throw new Error("The payment gateway did not load. Please try again.");
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("The payment gateway did not respond. Please try again.")),
+      CALLBACK_TIMEOUT_MS
+    );
+    api.txn.authkey.attachPaymentMethod(
+      authKey,
+      {
+        card: {
+          number: digits,
+          expiry: { month: exp.slice(0, 2), year: exp.slice(2, 4) },
+          name: card.name.trim(),
+          cvn: card.cvn
+        }
+      },
+      (code) => {
+        clearTimeout(timer);
+        if (code === "success") resolve();
+        else
+          reject(
+            new Error(
+              "We couldn't validate your card. Check the number, expiry and security code, then try again."
+            )
+          );
+      }
+    );
+  });
+}
+
+// src/checkout-block.client.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var BOTH_FULFILMENT_METHODS = { pickup: true, delivery: true };
+function readFulfilmentPolicy(value) {
+  if (!value || typeof value !== "object") return BOTH_FULFILMENT_METHODS;
+  const raw = value;
+  return {
+    pickup: raw.pickup !== false,
+    delivery: raw.delivery !== false
+  };
+}
+function formatSavedAddress(a) {
+  const locality = [a.suburb, a.state, a.postcode].map((part) => (part ?? "").trim()).filter(Boolean).join(" ");
+  return [(a.line1 ?? "").trim(), (a.line2 ?? "").trim(), locality].filter(Boolean).join(", ");
+}
+var CHECKOUT_RECOVERY_PREFIX = "patientos.store.checkout-order.v1";
+function checkoutRecoveryKey(apiOrigin) {
+  const identity = apiOrigin || (typeof window === "undefined" ? "same-origin" : window.location.origin);
+  let hash = 2166136261;
+  for (let index = 0; index < identity.length; index += 1) {
+    hash ^= identity.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${CHECKOUT_RECOVERY_PREFIX}:${(hash >>> 0).toString(16)}`;
+}
+function discardCheckoutRecovery(key) {
+  try {
+    window.localStorage.removeItem(key);
+  } catch {
+    return;
+  }
+}
+function readCheckoutRecovery(key) {
+  try {
+    const value = window.localStorage.getItem(key);
+    if (!value) return null;
+    if (isCheckoutAttemptToken(value))
+      return { v: 2, attemptToken: value, lines: null };
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      discardCheckoutRecovery(key);
+      return null;
+    }
+    const record = parsed;
+    if (record.v !== 1 && record.v !== 2 || !isCheckoutAttemptToken(record.attemptToken)) {
+      discardCheckoutRecovery(key);
+      return null;
+    }
+    if (record.v !== 2 || !Array.isArray(record.lines)) {
+      return { v: 2, attemptToken: record.attemptToken, lines: null };
+    }
+    const rawLines = record.lines;
+    const lines = normalizeCartLines(rawLines);
+    if (lines.length === 0 || lines.some(
+      (line) => !rawLines.some(
+        (candidate) => candidate !== null && typeof candidate === "object" && !Array.isArray(candidate) && candidate.lineId === line.lineId
+      )
+    )) {
+      return { v: 2, attemptToken: record.attemptToken, lines: null };
+    }
+    return { v: 2, attemptToken: record.attemptToken, lines };
+  } catch {
+    discardCheckoutRecovery(key);
+    return null;
+  }
+}
+function sameRecoveryRecord(left, right) {
+  return left?.attemptToken === right.attemptToken && left.lines !== null && right.lines !== null && JSON.stringify(left.lines) === JSON.stringify(right.lines);
+}
+function writeCheckoutRecovery(key, record, expectedToken) {
+  try {
+    const existing = readCheckoutRecovery(key);
+    if ((existing?.attemptToken ?? null) !== expectedToken) return false;
+    window.localStorage.setItem(key, JSON.stringify(record));
+    return sameRecoveryRecord(readCheckoutRecovery(key), record);
+  } catch {
+    return false;
+  }
+}
+function removeCheckoutRecovery(key, attemptToken) {
+  try {
+    const existing = readCheckoutRecovery(key);
+    if (!existing) return true;
+    if (existing.attemptToken !== attemptToken) return false;
+    window.localStorage.removeItem(key);
+    return readCheckoutRecovery(key)?.attemptToken !== attemptToken;
+  } catch {
+    return false;
+  }
+}
+function snapshotPurchasedCartLines(cartLines, quotedLines) {
+  const cartByVariant = new Map(
+    cartLines.filter((line) => line.kind === "retail").map((line) => [line.variantId, line])
+  );
+  const snapshot = [];
+  for (const quoted of quotedLines) {
+    const line = cartByVariant.get(quoted.variantId);
+    if (!line) return null;
+    snapshot.push({ ...line, quantity: quoted.quantity });
+  }
+  return snapshot.length > 0 ? snapshot : null;
+}
+function sameCartLineSnapshot(left, right) {
+  if (left.length !== right.length) return false;
+  const rightById = new Map(right.map((line) => [line.lineId, line]));
+  return left.every((line) => {
+    const expected = rightById.get(line.lineId);
+    return expected?.kind === line.kind && expected.variantId === line.variantId && expected.quantity === line.quantity;
+  });
+}
+function samePayableQuote(left, right, shippingOptionId) {
+  return JSON.stringify(expectedQuote(left, shippingOptionId)) === JSON.stringify(expectedQuote(right, shippingOptionId));
+}
+function expectedQuote(quote, shippingOptionId) {
+  return {
+    shippingOptionId,
+    lines: quote.lines.map(({ variantId, quantity, unitPrice, lineTotal }) => ({
+      variantId,
+      quantity,
+      unitPrice,
+      lineTotal
+    })),
+    subtotal: quote.subtotal,
+    shippingTotal: quote.shippingTotal,
+    taxTotal: quote.taxTotal,
+    total: quote.total,
+    currency: quote.currency
+  };
+}
+var StoreRequestError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "StoreRequestError";
+  }
+  code;
+};
+async function searchStoreAddresses(query, client) {
+  const q = query.trim();
+  if (q.length < 3) return [];
+  const result = await client.get(`/api/address/autocomplete?q=${encodeURIComponent(q)}`);
+  return result.ok ? result.data.suggestions ?? [] : [];
+}
+async function validateStoreAddress(address, client) {
+  const result = await client.post("/api/address/validate", { address });
+  if (!result.ok || result.data.error || !result.data.formattedAddress)
+    return null;
+  return {
+    address: result.data.formattedAddress,
+    placeId: result.data.googlePlaceId ?? null
+  };
+}
+function CheckoutClient({
+  storeApiOrigin,
+  ordersHref = "/portal/orders",
+  completionHref = "/checkout/complete"
+}) {
+  const client = React.useMemo(
+    () => createStoreClient({ apiOrigin: storeApiOrigin }),
+    [storeApiOrigin]
+  );
+  const [stage, setStage] = React.useState("loading");
+  const [givenName, setGivenName] = React.useState(null);
+  const [cart] = React.useState(() => readCart());
+  const recoveryKey = React.useMemo(
+    () => checkoutRecoveryKey(client.apiOrigin),
+    [client]
+  );
+  const [initialRecovery] = React.useState(
+    () => readCheckoutRecovery(recoveryKey)
+  );
+  const recoveryRef = React.useRef(
+    initialRecovery
+  );
+  const attemptTokenRef = React.useRef(
+    initialRecovery?.attemptToken ?? null
+  );
+  const [checkoutLines, setCheckoutLines] = React.useState(
+    () => cartToWireLines(cart)
+  );
+  const checkoutCartSnapshotRef = React.useRef(cart.lines);
+  const [quote, setQuote] = React.useState(null);
+  const [pendingQuote, setPendingQuote] = React.useState(null);
+  const [pendingQuoteBaseline, setPendingQuoteBaseline] = React.useState(null);
+  const [shippingOptions, setShippingOptions] = React.useState([]);
+  const [error, setError] = React.useState(null);
+  const [resumableCheckout, setResumableCheckout] = React.useState(null);
+  const [fulfilmentPolicy, setFulfilmentPolicy] = React.useState(
+    BOTH_FULFILMENT_METHODS
+  );
+  const [fulfilment, setFulfilment] = React.useState(
+    "pickup"
+  );
+  const [savedAddresses, setSavedAddresses] = React.useState(null);
+  const [savedAddressId, setSavedAddressId] = React.useState(
+    null
+  );
+  const [addingAddress, setAddingAddress] = React.useState(false);
+  const [savingAddress, setSavingAddress] = React.useState(false);
+  const [addressBookError, setAddressBookError] = React.useState(
+    null
+  );
+  const addressBookRequested = React.useRef(false);
+  const usingSavedAddress = !addingAddress && savedAddresses !== null && savedAddressId !== null;
+  const offersBothMethods = fulfilmentPolicy.pickup && fulfilmentPolicy.delivery;
+  const offersEitherMethod = fulfilmentPolicy.pickup || fulfilmentPolicy.delivery;
+  const [shippingOptionId, setShippingOptionId] = React.useState(
+    null
+  );
+  const [address, setAddress] = React.useState(null);
+  const [card, setCard] = React.useState({
+    number: "",
+    expiry: "",
+    name: "",
+    cvn: ""
+  });
+  const orderRef = React.useRef(null);
+  const [iframeUrl, setIframeUrl] = React.useState(null);
+  const iframeOriginRef = React.useRef(null);
+  const iframeElRef = React.useRef(null);
+  const ownsCheckoutRef = React.useRef(false);
+  const ownershipClaimRef = React.useRef(null);
+  const releaseCheckoutOwnershipRef = React.useRef(null);
+  async function claimCheckoutOwnership() {
+    if (ownsCheckoutRef.current) return true;
+    if (ownershipClaimRef.current) return ownershipClaimRef.current;
+    const locks = navigator.locks;
+    if (!locks) return false;
+    const claim = new Promise((resolveClaim) => {
+      let resolveHold = null;
+      const hold = new Promise((resolve) => {
+        resolveHold = resolve;
+      });
+      void locks.request(
+        `patientos-store-checkout:${recoveryKey}`,
+        { mode: "exclusive", ifAvailable: true },
+        async (lock) => {
+          if (!lock) {
+            resolveClaim(false);
+            return;
+          }
+          ownsCheckoutRef.current = true;
+          releaseCheckoutOwnershipRef.current = () => {
+            if (!ownsCheckoutRef.current) return;
+            ownsCheckoutRef.current = false;
+            releaseCheckoutOwnershipRef.current = null;
+            resolveHold?.();
+          };
+          resolveClaim(true);
+          await hold;
+        }
+      ).catch(() => resolveClaim(false));
+    });
+    ownershipClaimRef.current = claim;
+    const acquired = await claim;
+    ownershipClaimRef.current = null;
+    return acquired;
+  }
+  function releaseCheckoutOwnership() {
+    releaseCheckoutOwnershipRef.current?.();
+  }
+  function goToCompletion(orderId) {
+    window.location.assign(
+      checkoutCompletionUrl(completionHref, orderId, window.location.origin)
+    );
+  }
+  React.useEffect(
+    () => () => {
+      releaseCheckoutOwnership();
+    },
+    []
+  );
+  function releaseOwnedAttempt(attemptToken) {
+    const removed = removeCheckoutRecovery(recoveryKey, attemptToken);
+    if (removed && recoveryRef.current?.attemptToken === attemptToken) {
+      recoveryRef.current = null;
+      attemptTokenRef.current = null;
+    }
+    return removed;
+  }
+  async function finishPaidAttemptWhileLocked(attemptToken) {
+    const stored = readCheckoutRecovery(recoveryKey);
+    if (stored?.attemptToken !== attemptToken || stored.lines === null)
+      return "snapshot_unavailable";
+    const settled = await subtractPurchasedCartLines(
+      stored.lines,
+      attemptToken
+    );
+    if (!settled.persisted) return "storage_unavailable";
+    return releaseOwnedAttempt(attemptToken) ? "settled" : "storage_unavailable";
+  }
+  async function finishPaidAttempt(attemptToken) {
+    if (ownsCheckoutRef.current) {
+      const result = await finishPaidAttemptWhileLocked(attemptToken);
+      if (result === "settled") releaseCheckoutOwnership();
+      return result;
+    }
+    const locks = navigator.locks;
+    if (!locks) return "storage_unavailable";
+    return locks.request(
+      `patientos-store-checkout:${recoveryKey}`,
+      () => finishPaidAttemptWhileLocked(attemptToken)
+    );
+  }
+  function paidReconciliationPending(result) {
+    setError(
+      result === "snapshot_unavailable" ? "Payment was received, but this browser no longer has a safe cart snapshot. Review your cart and order before checking out again." : "Payment was received, but your cart update could not be saved. Allow site storage, then try again."
+    );
+    setStage("reconciliation_pending");
+  }
+  async function completePaidAttempt(attemptToken, orderId, alreadyLocked = false) {
+    const result = alreadyLocked ? await finishPaidAttemptWhileLocked(attemptToken) : await finishPaidAttempt(attemptToken);
+    if (result !== "settled") {
+      paidReconciliationPending(result);
+      return false;
+    }
+    if (alreadyLocked) releaseCheckoutOwnership();
+    setStage("paid");
+    goToCompletion(orderId);
+    return true;
+  }
+  async function retryPaidReconciliation() {
+    const attemptToken = attemptTokenRef.current;
+    if (!attemptToken) return;
+    await completePaidAttempt(
+      attemptToken,
+      orderRef.current?.orderId ?? attemptToken
+    );
+  }
+  function recoverySnapshotUnavailable() {
+    releaseCheckoutOwnership();
+    setError(
+      "This checkout can\u2019t be safely continued in this browser. Review My orders and your cart before trying again."
+    );
+    setStage("closed");
+  }
+  function storageUnavailable() {
+    releaseCheckoutOwnership();
+    setError(
+      "Your browser couldn\u2019t safely save and coordinate checkout progress. Allow site storage, then reload and try again."
+    );
+    setStage("storage_error");
+  }
+  React.useEffect(() => {
+    let alive = true;
+    void (async () => {
+      const locks = navigator.locks;
+      if (!locks) {
+        if (!alive) return;
+        storageUnavailable();
+        return;
+      }
+      const storedAttemptToken = attemptTokenRef.current;
+      let bootRecovery = {
+        status: "continue"
+      };
+      if (storedAttemptToken) {
+        const acquired = await claimCheckoutOwnership();
+        if (acquired) {
+          const recovered = await client.post(
+            "/api/store/checkout/recover",
+            { attemptToken: storedAttemptToken }
+          );
+          if (recovered.ok && recovered.data.status === "paid") {
+            await completePaidAttempt(
+              storedAttemptToken,
+              recovered.data.orderId ?? storedAttemptToken,
+              true
+            );
+            return;
+          } else if (recovered.ok && recovered.data.status === "active") {
+            releaseCheckoutOwnership();
+            bootRecovery = { status: "active" };
+          } else if (recovered.ok && recovered.data.status === "resumable" && !Array.isArray(readCheckoutRecovery(recoveryKey)?.lines)) {
+            recoverySnapshotUnavailable();
+            return;
+          } else if (recovered.ok && recovered.data.status === "resumable" && Array.isArray(readCheckoutRecovery(recoveryKey)?.lines) && recovered.data.orderId && recovered.data.sessionId && recovered.data.sessionStatus && recovered.data.providerKey && recovered.data.amount && recovered.data.clientArtifacts) {
+            bootRecovery = {
+              status: "resumable",
+              session: recovered.data
+            };
+          } else if (recovered.ok && recovered.data.status === "processing") {
+            releaseCheckoutOwnership();
+            bootRecovery = { status: "processing" };
+          } else if (recovered.ok) {
+            if (!releaseOwnedAttempt(storedAttemptToken)) {
+              recoverySnapshotUnavailable();
+              return;
+            }
+            releaseCheckoutOwnership();
+          } else {
+            releaseCheckoutOwnership();
+            bootRecovery = {
+              status: recovered.error === "sign_in_required" ? "continue" : "error"
+            };
+          }
+        } else {
+          bootRecovery = { status: "active_elsewhere" };
+        }
+      }
+      if (!alive) return;
+      if (bootRecovery.status === "active") {
+        setStage("active");
+        return;
+      }
+      if (bootRecovery.status === "active_elsewhere") {
+        setStage("active_elsewhere");
+        return;
+      }
+      if (bootRecovery.status === "resumable") {
+        setResumableCheckout(bootRecovery.session);
+        setStage("resume");
+        return;
+      }
+      if (bootRecovery.status === "processing") {
+        setStage("pending");
+        return;
+      }
+      if (bootRecovery.status === "error") {
+        setError(
+          "We couldn\u2019t recover your previous checkout. Please try again."
+        );
+        setStage("quote_error");
+        return;
+      }
+      if (cart.lines.length === 0) {
+        if (!alive) return;
+        setStage("empty");
+        return;
+      }
+      const [sessionResult, quoteResult, catalogResult] = await Promise.all([
+        client.get("/api/store/session"),
+        client.post("/api/store/quote", {
+          lines: checkoutLines
+        }),
+        client.get("/api/store/catalog")
+      ]);
+      if (!alive) return;
+      const session = sessionResult.ok && typeof sessionResult.data.signedIn === "boolean" ? sessionResult.data : null;
+      const unsupportedQuote = quoteResult.ok && quoteResult.data.problems.some(
+        (problem) => problem.code === "not_purchasable"
+      );
+      const payableQuote = quoteResult.ok && quoteResult.data.lines.length > 0 && !unsupportedQuote ? quoteResult.data : null;
+      const catalogLoaded = catalogResult.ok && Array.isArray(catalogResult.data.shippingOptions);
+      setQuote(payableQuote);
+      setShippingOptions(
+        catalogLoaded ? catalogResult.data.shippingOptions : []
+      );
+      if (catalogLoaded) {
+        const policy = readFulfilmentPolicy(catalogResult.data.fulfilment);
+        setFulfilmentPolicy(policy);
+        if (!policy.pickup && policy.delivery) setFulfilment("ship");
+        if (!policy.delivery) setFulfilment("pickup");
+      }
+      setGivenName(session?.givenName ?? null);
+      if (!session) {
+        setError("We couldn\u2019t load your checkout. Please try again.");
+        setStage("quote_error");
+      } else if (unsupportedQuote) {
+        setError(
+          "Remove unsupported items from your cart before starting retail checkout."
+        );
+        setStage("unsupported");
+      } else if (quoteResult.ok && quoteResult.data.lines.length === 0) {
+        setError(null);
+        setStage("empty");
+      } else if (session.signedIn === false) {
+        setStage("signed_out");
+      } else if (!catalogLoaded) {
+        setError("We couldn\u2019t load delivery options. Please try again.");
+        setStage("quote_error");
+      } else if (quoteResult.ok) {
+        setError(null);
+        setStage("details");
+      } else {
+        setError("We couldn\u2019t load your checkout. Please try again.");
+        setStage("quote_error");
+      }
+    })();
+    return () => {
+      alive = false;
+    };
+  }, [cart, client]);
+  const loadSavedAddresses = React.useCallback(
+    async (selectId) => {
+      const result = await client.get("/api/store/addresses").catch(() => null);
+      if (!result || !result.ok || !Array.isArray(result.data.items)) {
+        setSavedAddresses(null);
+        return;
+      }
+      const items = result.data.items.filter(
+        (item) => item && typeof item.id === "string"
+      );
+      if (items.length === 0) {
+        setSavedAddresses(null);
+        return;
+      }
+      setSavedAddresses(items);
+      setSavedAddressId((current) => {
+        const wanted = selectId ?? current;
+        if (wanted && items.some((item) => item.id === wanted)) return wanted;
+        return (items.find((item) => item.isPrimary) ?? items[0]).id;
+      });
+    },
+    [client]
+  );
+  React.useEffect(() => {
+    if (stage !== "details" || fulfilment !== "ship") return;
+    if (addressBookRequested.current) return;
+    addressBookRequested.current = true;
+    void loadSavedAddresses();
+  }, [stage, fulfilment, loadSavedAddresses]);
+  async function saveNewAddress() {
+    if (!address || savingAddress) return;
+    setSavingAddress(true);
+    setAddressBookError(null);
+    const result = await client.post("/api/store/addresses", {
+      address: address.address,
+      placeId: address.placeId ?? null
+    }).catch(() => null);
+    setSavingAddress(false);
+    if (!result || !result.ok || typeof result.data.id !== "string") {
+      setAddressBookError(
+        (result && !result.ok ? result.message : null) ?? "We couldn\u2019t save that address. You can still use it for this order."
+      );
+      return;
+    }
+    await loadSavedAddresses(result.data.id);
+    setAddingAddress(false);
+    setAddress(null);
+  }
+  React.useEffect(() => {
+    if (stage !== "details" || cart.lines.length === 0) return;
+    let alive = true;
+    setQuote(null);
+    setError(null);
+    void client.post("/api/store/quote", {
+      lines: checkoutLines,
+      shippingOptionId: fulfilment === "ship" ? shippingOptionId : null
+    }).then((result) => {
+      if (!alive) return;
+      if (result.ok && result.data.lines.length > 0) {
+        setQuote(result.data);
+      } else if (result.ok) {
+        setQuote(null);
+        setStage("empty");
+      } else {
+        setError("We couldn\u2019t update your checkout total. Please try again.");
+        setStage("quote_error");
+      }
+    });
+    return () => {
+      alive = false;
+    };
+  }, [client, fulfilment, shippingOptionId]);
+  React.useEffect(() => {
+    if (stage !== "three_ds") return;
+    let terminalHandled = false;
+    function onMessage(event) {
+      if (iframeOriginRef.current && event.origin !== iframeOriginRef.current)
+        return;
+      const iframe = iframeElRef.current;
+      if (!iframe || event.source !== iframe.contentWindow) return;
+      const type = event.data?.type;
+      if (type === "AuthenticationUserInteractionRequired") {
+        if (iframe) {
+          iframe.style.visibility = "visible";
+          iframe.style.height = "500px";
+        }
+        return;
+      }
+      if (type === "AuthenticationUserInteractionFinished") {
+        if (iframe) {
+          iframe.style.visibility = "hidden";
+          iframe.style.height = "1px";
+        }
+        return;
+      }
+      if (type !== "AuthenticationInternalError" && type !== "AuthenticationComplete")
+        return;
+      if (terminalHandled) return;
+      terminalHandled = true;
+      window.removeEventListener("message", onMessage);
+      setIframeUrl(null);
+      if (type === "AuthenticationInternalError") {
+        void cancelFailedChallenge();
+        return;
+      }
+      void afterChallenge();
+    }
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [stage]);
+  async function post(path, body) {
+    const result = await client.post(path, body);
+    if (!result.ok) {
+      if (result.error === "sign_in_required") {
+        setStage("signed_out");
+        throw new Error("sign_in_required");
+      }
+      throw new StoreRequestError(
+        result.message ?? "Something went wrong.",
+        result.error
+      );
+    }
+    return result.data;
+  }
+  function showChallenge(artifacts) {
+    if (!artifacts.iframeUrl) return false;
+    const iframeUrl2 = client.url(artifacts.iframeUrl);
+    try {
+      const parsedIframeUrl = new URL(iframeUrl2, window.location.href);
+      const ownedMockUrl = new URL(
+        client.url("/api/store/mock-3ds-challenge"),
+        window.location.href
+      );
+      const isOwnedMock = parsedIframeUrl.origin === ownedMockUrl.origin && parsedIframeUrl.pathname === ownedMockUrl.pathname && parsedIframeUrl.search === "" && parsedIframeUrl.hash === "";
+      if (parsedIframeUrl.username || parsedIframeUrl.password) return false;
+      if (isOwnedMock) {
+        const allowedProtocol = parsedIframeUrl.protocol === "https:" || parsedIframeUrl.protocol === "http:" && parsedIframeUrl.hostname === "localhost";
+        if (!allowedProtocol) return false;
+        iframeOriginRef.current = parsedIframeUrl.origin;
+      } else {
+        if (parsedIframeUrl.protocol !== "https:" || !artifacts.iframeOrigin)
+          return false;
+        const suppliedOrigin = new URL(artifacts.iframeOrigin);
+        if (suppliedOrigin.protocol !== "https:" || suppliedOrigin.username || suppliedOrigin.password || suppliedOrigin.pathname !== "/" || suppliedOrigin.search || suppliedOrigin.hash)
+          return false;
+        if (parsedIframeUrl.origin !== suppliedOrigin.origin) return false;
+        iframeOriginRef.current = suppliedOrigin.origin;
+      }
+    } catch {
+      return false;
+    }
+    setIframeUrl(iframeUrl2);
+    setStage("three_ds");
+    return true;
+  }
+  async function cancelFailedChallenge() {
+    const orderId = orderRef.current?.orderId;
+    if (!orderId) {
+      setStage("pending");
+      return;
+    }
+    setStage("paying");
+    try {
+      await post("/api/store/checkout/cancel-challenge", { orderId });
+      const attemptToken = attemptTokenRef.current;
+      if (attemptToken) releaseOwnedAttempt(attemptToken);
+      setError("The card check could not be completed. Please try again.");
+      setStage(quote ? "details" : "closed");
+      releaseCheckoutOwnership();
+    } catch {
+      setError(
+        "We couldn\u2019t safely close the failed card check. Go to your orders before trying again."
+      );
+      setStage("pending");
+    }
+  }
+  async function recoverAttemptWhileLocked(attemptToken, continueRestart = false) {
+    const recovered = await client.post(
+      "/api/store/checkout/recover",
+      { attemptToken }
+    );
+    if (recovered.ok && recovered.data.status === "active") {
+      setStage("active");
+      releaseCheckoutOwnership();
+      return "active";
+    }
+    if (recovered.ok && recovered.data.status === "resumable" && !Array.isArray(readCheckoutRecovery(recoveryKey)?.lines)) {
+      recoverySnapshotUnavailable();
+      return "blocked";
+    }
+    if (recovered.ok && recovered.data.status === "resumable" && Array.isArray(readCheckoutRecovery(recoveryKey)?.lines) && recovered.data.orderId && recovered.data.sessionId && recovered.data.sessionStatus && recovered.data.providerKey && recovered.data.amount && recovered.data.clientArtifacts) {
+      setResumableCheckout(recovered.data);
+      setStage("resume");
+      return "active";
+    }
+    if (recovered.ok && recovered.data.status === "processing") {
+      setStage("pending");
+      releaseCheckoutOwnership();
+      return "processing";
+    }
+    if (recovered.ok && recovered.data.status === "paid") {
+      return await completePaidAttempt(
+        attemptToken,
+        recovered.data.orderId ?? attemptToken,
+        true
+      ) ? "paid" : "blocked";
+    }
+    if (recovered.ok) {
+      if (!releaseOwnedAttempt(attemptToken)) {
+        recoverySnapshotUnavailable();
+        return "blocked";
+      }
+      if (!continueRestart) {
+        releaseCheckoutOwnership();
+        setError(
+          "Your previous checkout was closed. Review the total and try again."
+        );
+        setStage("details");
+      }
+      return "restart";
+    }
+    setError(
+      "We couldn\u2019t safely close your previous checkout. Go to your orders before trying again."
+    );
+    setStage("closed");
+    releaseCheckoutOwnership();
+    return "blocked";
+  }
+  async function recoverAttemptForRestart(attemptToken) {
+    if (!await claimCheckoutOwnership()) {
+      setStage("active_elsewhere");
+      return "active";
+    }
+    return recoverAttemptWhileLocked(attemptToken);
+  }
+  async function transitionRetryableDecline(message) {
+    const orderId = orderRef.current?.orderId;
+    if (!orderId) {
+      const attemptToken = attemptTokenRef.current;
+      if (attemptToken) await recoverAttemptWhileLocked(attemptToken);
+      else setStage("pending");
+      return;
+    }
+    setError(message);
+    setStage("loading");
+    const result = await client.post("/api/store/checkout/retry-payment", {
+      orderId
+    }).catch(() => null);
+    const retryData = result?.ok && result.data !== null && typeof result.data === "object" && !Array.isArray(result.data) ? result.data : null;
+    const retryArtifacts = retryData?.clientArtifacts !== null && typeof retryData?.clientArtifacts === "object" && !Array.isArray(retryData.clientArtifacts) ? retryData.clientArtifacts : null;
+    if (retryData?.status !== "ready" || retryData.orderId !== orderId || typeof retryData.sessionId !== "string" || typeof retryData.providerKey !== "string" || typeof retryData.amount !== "string" || !retryArtifacts) {
+      await recoverAttemptWhileLocked(orderId);
+      return;
+    }
+    setResumableCheckout({
+      orderId,
+      sessionId: retryData.sessionId,
+      sessionStatus: "pending",
+      providerKey: retryData.providerKey,
+      amount: retryData.amount,
+      expiresAt: typeof retryData.expiresAt === "string" ? retryData.expiresAt : null,
+      clientArtifacts: retryArtifacts
+    });
+    setStage("resume_payment");
+  }
+  async function handlePaymentRequestError(error2) {
+    if (!(error2 instanceof StoreRequestError)) return false;
+    if (error2.code === "payment_in_progress" || error2.code === "payment_initializing") {
+      setStage("pending");
+      releaseCheckoutOwnership();
+      return true;
+    }
+    if (error2.code === "payment_failed") {
+      await transitionRetryableDecline(
+        "This payment attempt failed. Please check the details or try another card."
+      );
+      return true;
+    }
+    if (error2.code === "payment_cancelled") {
+      setError(
+        "This payment attempt is closed. Go to your orders before trying again."
+      );
+      setStage("closed");
+      releaseCheckoutOwnership();
+      return true;
+    }
+    return false;
+  }
+  async function applyConfirm(result) {
+    const status = result.status;
+    if (status === "paid") {
+      const orderId = orderRef.current?.orderId ?? "";
+      const attemptToken = attemptTokenRef.current;
+      if (!attemptToken) {
+        paidReconciliationPending("snapshot_unavailable");
+        return;
+      }
+      await completePaidAttempt(attemptToken, orderId);
+      return;
+    }
+    if (status === "requires_action") {
+      const artifacts = result.clientArtifacts ?? {};
+      if (!showChallenge(artifacts)) await cancelFailedChallenge();
+      return;
+    }
+    if (status === "declined") {
+      await transitionRetryableDecline(
+        "Your card was declined. Please check the details or try another card."
+      );
+      return;
+    }
+    setStage("pending");
+    releaseCheckoutOwnership();
+  }
+  async function dispatchConfirm(orderId) {
+    try {
+      await applyConfirm(
+        await post("/api/store/checkout/confirm", { orderId })
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message === "sign_in_required") return;
+      const attemptToken = attemptTokenRef.current;
+      if (attemptToken && err instanceof StoreRequestError && err.code === "checkout_paid") {
+        await completePaidAttempt(attemptToken, orderId);
+        return;
+      }
+      if (await handlePaymentRequestError(err)) return;
+      setError(null);
+      setStage("pending");
+      releaseCheckoutOwnership();
+    }
+  }
+  async function afterChallenge() {
+    const orderId = orderRef.current?.orderId;
+    if (!orderId) return;
+    setStage("paying");
+    try {
+      const auth = await post("/api/store/checkout/authenticate", { orderId });
+      if (auth.status === "payment_failed") {
+        await transitionRetryableDecline(
+          "The card check failed. Please try another card."
+        );
+        return;
+      }
+      if (auth.status === "requires_action") {
+        const artifacts = auth.clientArtifacts ?? {};
+        if (showChallenge(artifacts)) return;
+        await cancelFailedChallenge();
+        return;
+      }
+      await dispatchConfirm(orderId);
+    } catch (err) {
+      if (err instanceof Error && err.message === "sign_in_required") return;
+      if (await handlePaymentRequestError(err)) return;
+      setError(err instanceof Error ? err.message : "Something went wrong.");
+      setStage(resumableCheckout ? "pending" : "details");
+      if (resumableCheckout) releaseCheckoutOwnership();
+    }
+  }
+  async function initializeCheckoutAttempt(currentQuote) {
+    if (!ownsCheckoutRef.current) return null;
+    while (true) {
+      const ownedToken = attemptTokenRef.current;
+      const stored = readCheckoutRecovery(recoveryKey);
+      if (ownedToken) {
+        if (stored?.attemptToken !== ownedToken || stored.lines === null) {
+          recoverySnapshotUnavailable();
+          return null;
+        }
+        recoveryRef.current = stored;
+        break;
+      }
+      if (stored) {
+        recoveryRef.current = stored;
+        attemptTokenRef.current = stored.attemptToken;
+        const disposition = await recoverAttemptWhileLocked(
+          stored.attemptToken,
+          true
+        );
+        if (disposition !== "restart") return null;
+        continue;
+      }
+      break;
+    }
+    const existingToken = attemptTokenRef.current;
+    const expectedLines = recoveryRef.current?.lines ?? checkoutCartSnapshotRef.current;
+    if (expectedLines === null) {
+      recoverySnapshotUnavailable();
+      return null;
+    }
+    const selectedShippingOptionId = fulfilment === "ship" ? shippingOptionId : null;
+    const coordinated = await withCartLock(async (latest, signal) => {
+      const wireLines = cartToWireLines(latest);
+      const quoteResult = await client.post(
+        "/api/store/quote",
+        {
+          lines: wireLines,
+          shippingOptionId: selectedShippingOptionId
+        },
+        { signal }
+      );
+      if (!quoteResult.ok || signal.aborted)
+        return { status: "quote_error" };
+      const freshQuote = quoteResult.data;
+      const purchasedLines = snapshotPurchasedCartLines(
+        latest.lines,
+        freshQuote.lines
+      );
+      if (!purchasedLines || freshQuote.lines.length === 0 || freshQuote.problems.length > 0 || !sameCartLineSnapshot(latest.lines, expectedLines) || !samePayableQuote(currentQuote, freshQuote, selectedShippingOptionId)) {
+        return {
+          status: "cart_changed",
+          quote: freshQuote,
+          baseline: latest
+        };
+      }
+      const attemptToken = existingToken ?? crypto.randomUUID();
+      if (existingToken) {
+        if (!sameCartLineSnapshot(purchasedLines, expectedLines)) {
+          return {
+            status: "cart_changed",
+            quote: freshQuote,
+            baseline: latest
+          };
+        }
+      } else {
+        const recovery = {
+          v: 2,
+          attemptToken,
+          lines: purchasedLines
+        };
+        if (!writeCheckoutRecovery(recoveryKey, recovery, null))
+          return { status: "storage_error" };
+        recoveryRef.current = recovery;
+        attemptTokenRef.current = attemptToken;
+      }
+      const initPromise = post("/api/store/checkout/init", {
+        lines: wireLines,
+        attemptToken,
+        expectedQuote: expectedQuote(freshQuote, selectedShippingOptionId),
+        fulfilmentMethod: fulfilment,
+        shippingOptionId: selectedShippingOptionId,
+        // Exactly one of these carries the destination. A SAVED address is named by
+        // id and resolved server-side under this shopper's own scope; a fresh pick
+        // is a Google reference. Neither is address components — the client has
+        // never been allowed to supply those (PAT-850).
+        shippingAddressId: fulfilment === "ship" && usingSavedAddress ? savedAddressId : null,
+        shippingPlace: fulfilment === "ship" && !usingSavedAddress && address ? { address: address.address, placeId: address.placeId ?? null } : null
+      });
+      return {
+        status: "ready",
+        attemptToken,
+        initPromise
+      };
+    });
+    if (coordinated.status === "cart_storage_unavailable") {
+      storageUnavailable();
+      return null;
+    }
+    if (coordinated.status === "not_completed") {
+      setError("We couldn\u2019t confirm your checkout total. Please try again.");
+      setStage("quote_error");
+      releaseCheckoutOwnership();
+      return null;
+    }
+    const result = coordinated.result;
+    if (result.status === "storage_error") {
+      storageUnavailable();
+      return null;
+    }
+    if (result.status === "quote_error") {
+      setError("We couldn\u2019t confirm your checkout total. Please try again.");
+      setStage("quote_error");
+      releaseCheckoutOwnership();
+      return null;
+    }
+    if (result.status === "cart_changed") {
+      if (existingToken) {
+        const disposition = await recoverAttemptWhileLocked(
+          existingToken,
+          true
+        );
+        if (disposition !== "restart") return null;
+      }
+      setPendingQuote(result.quote);
+      setPendingQuoteBaseline(result.baseline);
+      setQuote(null);
+      setError(null);
+      setStage("cart_changed");
+      return null;
+    }
+    return {
+      attemptToken: result.attemptToken,
+      init: await result.initPromise
+    };
+  }
+  async function beginResume() {
+    if (!resumableCheckout) return;
+    if (!await claimCheckoutOwnership()) {
+      setStage("active_elsewhere");
+      return;
+    }
+    orderRef.current = {
+      orderId: resumableCheckout.orderId,
+      providerKey: resumableCheckout.providerKey
+    };
+    if (resumableCheckout.sessionStatus === "requires_action") {
+      if (!showChallenge(resumableCheckout.clientArtifacts))
+        await cancelFailedChallenge();
+      return;
+    }
+    setError(null);
+    setStage("resume_payment");
+  }
+  async function onResumePayment(e) {
+    e.preventDefault();
+    if (!resumableCheckout) return;
+    if (!await claimCheckoutOwnership()) {
+      setStage("active_elsewhere");
+      return;
+    }
+    setError(null);
+    setStage("paying");
+    orderRef.current = {
+      orderId: resumableCheckout.orderId,
+      providerKey: resumableCheckout.providerKey
+    };
+    try {
+      if (resumableCheckout.providerKey !== "mock") {
+        const { authKey } = resumableCheckout.clientArtifacts;
+        if (!authKey) {
+          setStage("pending");
+          releaseCheckoutOwnership();
+          return;
+        }
+        await loadBpointScript();
+        await attachCardToAuthKey(authKey, card);
+      }
+      await dispatchConfirm(resumableCheckout.orderId);
+    } catch (err) {
+      if (err instanceof Error && err.message === "sign_in_required") {
+        releaseCheckoutOwnership();
+        return;
+      }
+      if (await handlePaymentRequestError(err)) return;
+      setError(err instanceof Error ? err.message : "Something went wrong.");
+      setStage("resume_payment");
+    }
+  }
+  async function onPay(e) {
+    e.preventDefault();
+    if (!quote || quote.lines.length === 0) {
+      setQuote(null);
+      setError(
+        quote ? null : "We couldn\u2019t confirm your checkout total. Please try again."
+      );
+      setStage(quote ? "empty" : "quote_error");
+      return;
+    }
+    if (!await claimCheckoutOwnership()) {
+      setStage("active_elsewhere");
+      return;
+    }
+    setError(null);
+    setStage("paying");
+    let attemptToken = attemptTokenRef.current;
+    try {
+      const initialized = await initializeCheckoutAttempt(quote);
+      if (!initialized) return;
+      attemptToken = initialized.attemptToken;
+      const { init } = initialized;
+      setError(null);
+      if (init.status === "cart_changed") {
+        const changedQuote = init.quote;
+        setPendingQuote(changedQuote);
+        const baselineLines = recoveryRef.current?.lines;
+        if (!baselineLines) {
+          recoverySnapshotUnavailable();
+          return;
+        }
+        setPendingQuoteBaseline({ v: 1, lines: baselineLines });
+        setQuote(null);
+        setError(null);
+        setStage("cart_changed");
+        return;
+      }
+      const orderId = String(init.orderId);
+      const providerKey = String(init.providerKey);
+      orderRef.current = { orderId, providerKey };
+      if (providerKey !== "mock") {
+        const artifacts = init.clientArtifacts ?? {};
+        if (!artifacts.authKey)
+          throw new Error(
+            "We couldn\u2019t start a secure payment. Please try again."
+          );
+        await loadBpointScript();
+        await attachCardToAuthKey(artifacts.authKey, card);
+      }
+      await dispatchConfirm(orderId);
+    } catch (err) {
+      if (err instanceof Error && err.message === "sign_in_required") {
+        releaseCheckoutOwnership();
+        return;
+      }
+      const failedAttemptToken = attemptToken ?? attemptTokenRef.current;
+      if (failedAttemptToken && err instanceof StoreRequestError && err.code === "checkout_paid") {
+        await completePaidAttempt(failedAttemptToken, failedAttemptToken);
+        return;
+      }
+      if (await handlePaymentRequestError(err)) return;
+      if (failedAttemptToken && err instanceof StoreRequestError && (err.code === "checkout_attempt_changed" || err.code === "checkout_attempt_closed" || err.code === "checkout_init_failed" || err.code === "invalid_checkout_attempt")) {
+        await recoverAttemptForRestart(failedAttemptToken);
+        return;
+      }
+      setError(err instanceof Error ? err.message : "Something went wrong.");
+      setStage("details");
+    }
+  }
+  async function retryQuote() {
+    setError(null);
+    setStage("loading");
+    const sessionResult = await client.get("/api/store/session");
+    if (!sessionResult.ok || typeof sessionResult.data.signedIn !== "boolean") {
+      setQuote(null);
+      setPendingQuote(null);
+      setPendingQuoteBaseline(null);
+      setError("We couldn\u2019t load your checkout. Please try again.");
+      setStage("quote_error");
+      return;
+    }
+    const session = sessionResult.data;
+    setGivenName(session.givenName ?? null);
+    if (session.signedIn === false) {
+      setQuote(null);
+      setPendingQuote(null);
+      setPendingQuoteBaseline(null);
+      setStage("signed_out");
+      return;
+    }
+    const [result, catalogResult] = await Promise.all([
+      client.post("/api/store/quote", {
+        lines: checkoutLines,
+        shippingOptionId: fulfilment === "ship" ? shippingOptionId : null
+      }),
+      client.get("/api/store/catalog")
+    ]);
+    const catalogLoaded = catalogResult.ok && Array.isArray(catalogResult.data.shippingOptions);
+    if (catalogLoaded) {
+      const policy = readFulfilmentPolicy(catalogResult.data.fulfilment);
+      setFulfilmentPolicy(policy);
+      if (!policy.pickup && policy.delivery) setFulfilment("ship");
+      if (!policy.delivery) setFulfilment("pickup");
+    }
+    if (!catalogLoaded) {
+      setQuote(null);
+      setShippingOptions([]);
+      setError("We couldn\u2019t load delivery options. Please try again.");
+      setStage("quote_error");
+    } else if (result.ok && result.data.problems.some((problem) => problem.code === "not_purchasable")) {
+      setQuote(null);
+      setError(
+        "Remove unsupported items from your cart before starting retail checkout."
+      );
+      setStage("unsupported");
+    } else if (result.ok && result.data.lines.length > 0) {
+      setShippingOptions(catalogResult.data.shippingOptions);
+      setQuote(result.data);
+      setStage("details");
+    } else if (result.ok) {
+      setQuote(null);
+      setStage("empty");
+    } else {
+      setQuote(null);
+      setError("We couldn\u2019t load your checkout. Please try again.");
+      setStage("quote_error");
+    }
+  }
+  async function acceptHealedQuote() {
+    if (!pendingQuote) return;
+    const locks = navigator.locks;
+    if (!locks) {
+      storageUnavailable();
+      return;
+    }
+    const attemptedRetail = new Map(
+      (pendingQuoteBaseline?.lines ?? checkoutLines).filter((line) => line.kind === "retail").map((line) => [line.variantId, line.quantity])
+    );
+    const healedRetail = new Map(
+      pendingQuote.lines.map((line) => [line.variantId, line.quantity])
+    );
+    const optionUnavailable = pendingQuote.problems.some(
+      (problem) => problem.code === "shipping_option_unavailable"
+    );
+    const nextShippingOptionId = optionUnavailable ? null : shippingOptionId;
+    setPendingQuote(null);
+    setPendingQuoteBaseline(null);
+    setQuote(null);
+    setError(null);
+    setStage("loading");
+    const outcome = {
+      confirmedQuote: null,
+      nextProblemQuote: null,
+      nextProblemBaseline: null,
+      quoteFailed: false
+    };
+    const continueWhileCoordinated = async () => {
+      const attemptToken = attemptTokenRef.current;
+      const stored = readCheckoutRecovery(recoveryKey);
+      if (attemptToken && (stored?.attemptToken !== attemptToken || stored.lines === null) || !attemptToken && stored)
+        return null;
+      return mutateCart(
+        (latest) => ({
+          v: 1,
+          lines: latest.lines.flatMap((line) => {
+            if (line.kind !== "retail") return [line];
+            const attemptedQuantity = attemptedRetail.get(line.variantId);
+            if (attemptedQuantity === void 0) return [line];
+            const healedQuantity = healedRetail.get(line.variantId);
+            if (healedQuantity === void 0) return [];
+            return [
+              {
+                ...line,
+                quantity: line.quantity <= attemptedQuantity ? Math.min(line.quantity, healedQuantity) : Math.min(
+                  99,
+                  healedQuantity + (line.quantity - attemptedQuantity)
+                )
+              }
+            ];
+          })
+        }),
+        async (proposed, signal) => {
+          const payableLines = cartToWireLines({
+            v: 1,
+            lines: proposed.lines.filter((line) => line.kind === "retail")
+          });
+          const result = await client.post(
+            "/api/store/quote",
+            {
+              lines: payableLines,
+              shippingOptionId: fulfilment === "ship" ? nextShippingOptionId : null
+            },
+            { signal }
+          );
+          if (!result.ok) {
+            outcome.quoteFailed = true;
+            return false;
+          }
+          if (result.data.lines.length === 0 || result.data.problems.length > 0) {
+            outcome.nextProblemQuote = result.data;
+            outcome.nextProblemBaseline = proposed;
+            return false;
+          }
+          const purchasedLines = snapshotPurchasedCartLines(
+            proposed.lines,
+            result.data.lines
+          );
+          if (!purchasedLines) return false;
+          if (attemptToken) {
+            const recovery = {
+              v: 2,
+              attemptToken,
+              lines: purchasedLines
+            };
+            if (!writeCheckoutRecovery(recoveryKey, recovery, attemptToken))
+              return false;
+            recoveryRef.current = recovery;
+          }
+          outcome.confirmedQuote = result.data;
+          return true;
+        }
+      );
+    };
+    const persisted = ownsCheckoutRef.current ? await continueWhileCoordinated() : await locks.request(
+      `patientos-store-checkout:${recoveryKey}`,
+      continueWhileCoordinated
+    );
+    if (!persisted || persisted.status === "cart_storage_unavailable") {
+      storageUnavailable();
+      return;
+    }
+    if (persisted.status === "not_committed") {
+      if (outcome.quoteFailed) {
+        setError("We couldn\u2019t load your checkout. Please try again.");
+        setStage("quote_error");
+      } else if (outcome.nextProblemQuote?.lines.length === 0) {
+        setStage("empty");
+      } else if (outcome.nextProblemQuote && outcome.nextProblemBaseline) {
+        setPendingQuote(outcome.nextProblemQuote);
+        setPendingQuoteBaseline(outcome.nextProblemBaseline);
+        setStage("cart_changed");
+      } else {
+        storageUnavailable();
+      }
+      return;
+    }
+    if (optionUnavailable) setShippingOptionId(null);
+    if (!outcome.confirmedQuote) {
+      storageUnavailable();
+      return;
+    }
+    checkoutCartSnapshotRef.current = persisted.cart.lines;
+    setCheckoutLines(
+      outcome.confirmedQuote.lines.map((line) => ({
+        kind: "retail",
+        variantId: line.variantId,
+        quantity: line.quantity
+      }))
+    );
+    setQuote(outcome.confirmedQuote);
+    setStage("details");
+  }
+  if (stage === "loading") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__placeholder", role: "status", children: "Loading your order\u2026" })
+    ] });
+  }
+  if (stage === "empty") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__placeholder", role: "status", children: "Your cart is empty." }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: "/store", children: "Browse the shop" })
+    ] });
+  }
+  if (stage === "signed_out") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", children: "Please sign in to finish your order. Your order is kept with your clinic record so you can see it later." }),
+      /* @__PURE__ */ jsx2(
+        "a",
+        {
+          className: "sk-checkout__signin",
+          href: client.signInHref("/checkout"),
+          children: "Sign in to continue"
+        }
+      )
+    ] });
+  }
+  if (stage === "unsupported") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Update your cart" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "alert", children: error }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: "/cart", children: "Return to cart" })
+    ] });
+  }
+  if (stage === "quote_error") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: givenName ? `Checkout \u2014 hello, ${givenName}` : "Checkout" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__error", role: "alert", children: error ?? "We couldn\u2019t load your checkout. Please try again." }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "sk-checkout__pay",
+          onClick: () => void retryQuote(),
+          children: "Try again"
+        }
+      )
+    ] });
+  }
+  if (stage === "cart_changed" && pendingQuote) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Your cart was updated" }),
+      /* @__PURE__ */ jsx2("div", { className: "sk-checkout__error", role: "alert", children: pendingQuote.problems.length > 0 ? /* @__PURE__ */ jsx2("ul", { children: pendingQuote.problems.map((problem, index) => /* @__PURE__ */ jsx2("li", { children: problem.message }, `${problem.code}-${index}`)) }) : /* @__PURE__ */ jsx2("p", { children: "Prices or delivery details changed while you were checking out." }) }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "sk-checkout__pay",
+          onClick: () => void acceptHealedQuote(),
+          children: "Continue with updated cart"
+        }
+      )
+    ] });
+  }
+  if (stage === "reconciliation_pending") {
+    const persistedRecovery = readCheckoutRecovery(recoveryKey);
+    const canRetry = persistedRecovery?.attemptToken === attemptTokenRef.current && persistedRecovery.lines !== null;
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Payment received, cart update pending" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "alert", children: error }),
+      canRetry ? /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "sk-checkout__pay",
+          onClick: () => void retryPaidReconciliation(),
+          children: "Try updating cart again"
+        }
+      ) : /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: "/cart", children: "Review cart" }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "View My orders" })
+    ] });
+  }
+  if (stage === "paid") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Payment received" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "status", children: "Taking you to your order\u2026" })
+    ] });
+  }
+  if (stage === "storage_error") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout unavailable" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "alert", children: error })
+    ] });
+  }
+  if (stage === "closed") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Payment not completed" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "status", children: error }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "Go to my orders" })
+    ] });
+  }
+  if (stage === "resume" && resumableCheckout) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Resume checkout" }),
+      /* @__PURE__ */ jsxs2("p", { className: "sk-checkout__note", role: "status", children: [
+        "Your checkout for ",
+        formatMoney(resumableCheckout.amount),
+        " is ready to continue."
+      ] }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "sk-checkout__pay",
+          onClick: beginResume,
+          children: "Resume checkout"
+        }
+      ),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "Go to my orders" })
+    ] });
+  }
+  if (stage === "resume_payment" && resumableCheckout) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Resume checkout" }),
+      error ? /* @__PURE__ */ jsx2("p", { className: "sk-checkout__error", role: "alert", children: error }) : null,
+      /* @__PURE__ */ jsxs2("p", { className: "sk-checkout__note", role: "status", children: [
+        "Order total: ",
+        formatMoney(resumableCheckout.amount)
+      ] }),
+      /* @__PURE__ */ jsxs2("form", { className: "sk-checkout__form", onSubmit: onResumePayment, children: [
+        /* @__PURE__ */ jsxs2("fieldset", { className: "sk-checkout__fieldset", children: [
+          /* @__PURE__ */ jsx2("legend", { children: "Card details" }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Name on card" }),
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                required: true,
+                autoComplete: "cc-name",
+                value: card.name,
+                onChange: (e) => setCard({ ...card, name: e.target.value })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Card number" }),
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                required: true,
+                inputMode: "numeric",
+                autoComplete: "cc-number",
+                value: card.number,
+                onChange: (e) => setCard({ ...card, number: e.target.value })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Expiry (MM/YY)" }),
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                required: true,
+                inputMode: "numeric",
+                autoComplete: "cc-exp",
+                placeholder: "MM/YY",
+                value: card.expiry,
+                onChange: (e) => setCard({ ...card, expiry: e.target.value })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Security code" }),
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                required: true,
+                inputMode: "numeric",
+                autoComplete: "cc-csc",
+                value: card.cvn,
+                onChange: (e) => setCard({ ...card, cvn: e.target.value })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", children: "Your card details go straight to our payment provider \u2014 they never reach this clinic's systems." })
+        ] }),
+        /* @__PURE__ */ jsxs2("button", { type: "submit", className: "sk-checkout__pay", children: [
+          "Pay ",
+          formatMoney(resumableCheckout.amount)
+        ] })
+      ] })
+    ] });
+  }
+  if (stage === "active_elsewhere") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout active elsewhere" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "status", children: "Finish checkout in your other tab, or close it and reload this page." }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "Go to my orders" })
+    ] });
+  }
+  if (stage === "active") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Checkout is still opening" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "status", children: "Wait a moment, then reload this page before trying again." }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "Go to my orders" })
+    ] });
+  }
+  if (stage === "pending") {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Confirming your payment" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", role: "status", children: error ?? "Your bank hasn't confirmed the result yet. We're checking with them \u2014 please don't pay again. You'll see the order in your account once it's confirmed." }),
+      /* @__PURE__ */ jsx2("a", { className: "sk-checkout__link", href: ordersHref, children: "Go to my orders" })
+    ] });
+  }
+  if (stage === "three_ds" && iframeUrl) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: "Your bank needs to check this payment" }),
+      /* @__PURE__ */ jsx2(
+        "iframe",
+        {
+          ref: iframeElRef,
+          className: "sk-checkout__3ds",
+          src: iframeUrl,
+          style: { visibility: "hidden", height: "1px" },
+          title: "Card verification"
+        }
+      )
+    ] });
+  }
+  const busy = stage === "paying";
+  if (!quote) {
+    return /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: givenName ? `Checkout \u2014 hello, ${givenName}` : "Checkout" }),
+      /* @__PURE__ */ jsx2("p", { className: "sk-checkout__placeholder", role: "status", children: "Updating your order total\u2026" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx2("h2", { className: "sk-checkout__heading", children: givenName ? `Checkout \u2014 hello, ${givenName}` : "Checkout" }),
+    error ? /* @__PURE__ */ jsx2("p", { className: "sk-checkout__error", role: "alert", children: error }) : null,
+    /* @__PURE__ */ jsxs2("div", { className: "sk-checkout__summary", children: [
+      /* @__PURE__ */ jsx2("ul", { className: "sk-checkout__lines", children: quote.lines.map((l) => /* @__PURE__ */ jsxs2("li", { children: [
+        /* @__PURE__ */ jsxs2("span", { children: [
+          l.title,
+          " \xD7 ",
+          l.quantity
+        ] }),
+        /* @__PURE__ */ jsx2("span", { children: formatMoney(l.lineTotal) })
+      ] }, l.variantId)) }),
+      /* @__PURE__ */ jsxs2("dl", { className: "sk-checkout__totals", children: [
+        /* @__PURE__ */ jsxs2("div", { children: [
+          /* @__PURE__ */ jsx2("dt", { children: "Subtotal" }),
+          /* @__PURE__ */ jsx2("dd", { children: formatMoney(quote.subtotal) })
+        ] }),
+        Number(quote.shippingTotal) > 0 ? /* @__PURE__ */ jsxs2("div", { children: [
+          /* @__PURE__ */ jsx2("dt", { children: "Delivery" }),
+          /* @__PURE__ */ jsx2("dd", { children: formatMoney(quote.shippingTotal) })
+        ] }) : null,
+        /* @__PURE__ */ jsxs2("div", { children: [
+          /* @__PURE__ */ jsx2("dt", { children: "GST included" }),
+          /* @__PURE__ */ jsx2("dd", { children: formatMoney(quote.taxTotal) })
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "sk-checkout__total-row", children: [
+          /* @__PURE__ */ jsx2("dt", { children: "Total" }),
+          /* @__PURE__ */ jsx2("dd", { children: formatMoney(quote.total) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2("form", { className: "sk-checkout__form", onSubmit: onPay, children: [
+      quote.requiresShipping && !offersEitherMethod ? /* @__PURE__ */ jsx2("p", { className: "sk-checkout__notice", role: "status", children: "This clinic isn\u2019t taking online orders for delivery or collection right now. Please contact the clinic." }) : null,
+      quote.requiresShipping && offersEitherMethod ? /* @__PURE__ */ jsxs2("fieldset", { className: "sk-checkout__fieldset", children: [
+        offersBothMethods ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx2("legend", { children: "How would you like to get this?" }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                type: "radio",
+                name: "fulfilment",
+                checked: fulfilment === "pickup",
+                onChange: () => setFulfilment("pickup")
+              }
+            ),
+            "Collect from the clinic"
+          ] }),
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                type: "radio",
+                name: "fulfilment",
+                checked: fulfilment === "ship",
+                onChange: () => setFulfilment("ship")
+              }
+            ),
+            "Deliver to me"
+          ] })
+        ] }) : /* @__PURE__ */ jsx2("legend", { children: fulfilmentPolicy.delivery ? "Delivery" : "Collection" }),
+        fulfilment === "ship" ? /* @__PURE__ */ jsxs2("div", { className: "sk-checkout__ship", children: [
+          /* @__PURE__ */ jsxs2("label", { children: [
+            /* @__PURE__ */ jsx2("span", { children: "Delivery option" }),
+            /* @__PURE__ */ jsxs2(
+              "select",
+              {
+                required: true,
+                value: shippingOptionId ?? "",
+                onChange: (e) => setShippingOptionId(e.target.value || null),
+                children: [
+                  /* @__PURE__ */ jsx2("option", { value: "", children: "Choose\u2026" }),
+                  shippingOptions.map((o) => /* @__PURE__ */ jsxs2("option", { value: o.id, children: [
+                    o.name,
+                    " \u2014 ",
+                    formatMoney(o.price)
+                  ] }, o.id))
+                ]
+              }
+            )
+          ] }),
+          savedAddresses && !addingAddress ? /* @__PURE__ */ jsxs2("div", { className: "sk-checkout__addresses", children: [
+            /* @__PURE__ */ jsx2("span", { className: "sk-checkout__addresses-label", children: "Delivery address" }),
+            savedAddresses.map((saved) => /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "sk-checkout-saved-address",
+                  checked: savedAddressId === saved.id,
+                  onChange: () => setSavedAddressId(saved.id)
+                }
+              ),
+              /* @__PURE__ */ jsxs2("span", { children: [
+                formatSavedAddress(saved),
+                saved.isPrimary ? " \xB7 Default" : ""
+              ] })
+            ] }, saved.id)),
+            /* @__PURE__ */ jsx2(
+              "button",
+              {
+                type: "button",
+                className: "sk-checkout__link-button",
+                onClick: () => {
+                  setAddressBookError(null);
+                  setAddingAddress(true);
+                },
+                children: "Add a new address"
+              }
+            )
+          ] }) : null,
+          !usingSavedAddress ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx2(
+              AddressPicker,
+              {
+                idPrefix: "sk-checkout",
+                label: "Delivery address",
+                value: address,
+                onChange: setAddress,
+                search: (query) => searchStoreAddresses(query, client),
+                validate: (value) => validateStoreAddress(value, client)
+              }
+            ),
+            addingAddress ? /* @__PURE__ */ jsxs2("div", { className: "sk-checkout__address-actions", children: [
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  type: "button",
+                  className: "sk-checkout__link-button",
+                  disabled: !address || savingAddress,
+                  onClick: () => void saveNewAddress(),
+                  children: savingAddress ? "Saving\u2026" : "Save address"
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  type: "button",
+                  className: "sk-checkout__link-button",
+                  onClick: () => {
+                    setAddingAddress(false);
+                    setAddressBookError(null);
+                    setAddress(null);
+                  },
+                  children: "Cancel"
+                }
+              )
+            ] }) : null,
+            addressBookError ? /* @__PURE__ */ jsx2("p", { className: "sk-checkout__notice", role: "status", children: addressBookError }) : null
+          ] }) : null
+        ] }) : null
+      ] }) : null,
+      /* @__PURE__ */ jsxs2("fieldset", { className: "sk-checkout__fieldset", children: [
+        /* @__PURE__ */ jsx2("legend", { children: "Card details" }),
+        /* @__PURE__ */ jsxs2("label", { children: [
+          /* @__PURE__ */ jsx2("span", { children: "Name on card" }),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              required: true,
+              autoComplete: "cc-name",
+              value: card.name,
+              onChange: (e) => setCard({ ...card, name: e.target.value })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs2("label", { children: [
+          /* @__PURE__ */ jsx2("span", { children: "Card number" }),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              required: true,
+              inputMode: "numeric",
+              autoComplete: "cc-number",
+              value: card.number,
+              onChange: (e) => setCard({ ...card, number: e.target.value })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs2("label", { children: [
+          /* @__PURE__ */ jsx2("span", { children: "Expiry (MM/YY)" }),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              required: true,
+              inputMode: "numeric",
+              autoComplete: "cc-exp",
+              placeholder: "MM/YY",
+              value: card.expiry,
+              onChange: (e) => setCard({ ...card, expiry: e.target.value })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs2("label", { children: [
+          /* @__PURE__ */ jsx2("span", { children: "Security code" }),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              required: true,
+              inputMode: "numeric",
+              autoComplete: "cc-csc",
+              value: card.cvn,
+              onChange: (e) => setCard({ ...card, cvn: e.target.value })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx2("p", { className: "sk-checkout__note", children: "Your card details go straight to our payment provider \u2014 they never reach this clinic's systems." })
+      ] }),
+      /* @__PURE__ */ jsx2("button", { type: "submit", className: "sk-checkout__pay", disabled: busy, children: busy ? "Processing\u2026" : `Pay ${formatMoney(quote.total)}` })
+    ] })
+  ] });
+}
+
+export {
+  AddressPicker,
+  loadBpointScript,
+  attachCardToAuthKey,
+  CheckoutClient
+};