@patientos/website-kit 0.2.4 → 0.2.5

package/dist/{chunk-S7U2HOV7.js → chunk-75FJ5AJB.js}

@@ -59,11 +59,13 @@ import {
   portalSend,
   readPortalSignedInHint,
   resetSession,
+  restoreApplicationRunToken,
+  saveApplicationRunToken,
   saveFlowRecord,
   signOutOfPortal,
   writePortalSignedInHint,
   zoneAbbr
-} from "./chunk-BHVDY6SC.js";
+} from "./chunk-FSZ726DM.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -525,7 +527,7 @@ function toSessionInput(v) {
     dateOfBirth: v.dateOfBirth
   };
 }
-function SignInRamp({ redirect }) {
+function SignInRamp({ redirect, prepareRedirect }) {
   const portal = usePortalClient();
   const [open, setOpen] = React2.useState(false);
   const [email, setEmail] = React2.useState("");
@@ -587,7 +589,7 @@ function SignInRamp({ redirect }) {
           onClick: () => {
             if (busy) return;
             setBusy(true);
-            void portal.requestMagicLink(email.trim(), redirect ?? portal.returnPath()).then((reached) => setOutcome(reached ? "sent" : "failed")).catch(() => setOutcome("failed")).finally(() => {
+            void (prepareRedirect ? prepareRedirect() : Promise.resolve(redirect ?? portal.returnPath())).then((target) => portal.requestMagicLink(email.trim(), target)).then((reached) => setOutcome(reached ? "sent" : "failed")).catch(() => setOutcome("failed")).finally(() => {
               setBusy(false);
             });
           },
@@ -1181,18 +1183,56 @@ function Booking({
 
 // src/certificate-funnel.client.tsx
 import * as React16 from "react";
+import {
+  PatientOSApiError as PatientOSApiError2
+} from "@patientos/public-sdk";
+
+// src/application-run-command.ts
+var inMemoryPromotionKeys = /* @__PURE__ */ new Map();
+function retainedPromotionCommandKey(applicationRunId, storage2, createKey = () => crypto.randomUUID()) {
+  const memoryKey = inMemoryPromotionKeys.get(applicationRunId);
+  if (memoryKey) return memoryKey;
+  const storageKey = `patientos:application-promotion:${applicationRunId}`;
+  try {
+    const retained = storage2?.getItem(storageKey);
+    if (retained) {
+      inMemoryPromotionKeys.set(applicationRunId, retained);
+      return retained;
+    }
+    const created = createKey();
+    inMemoryPromotionKeys.set(applicationRunId, created);
+    storage2?.setItem(storageKey, created);
+    return created;
+  } catch {
+    const created = createKey();
+    inMemoryPromotionKeys.set(applicationRunId, created);
+    return created;
+  }
+}
+var ApplicationRunCommandRetrier = class {
+  keys = /* @__PURE__ */ new Map();
+  async act(client, applicationRunId, input) {
+    const fingerprint = JSON.stringify({ applicationRunId, ...input });
+    const idempotencyKey = this.keys.get(fingerprint) ?? crypto.randomUUID();
+    this.keys.set(fingerprint, idempotencyKey);
+    const command = { ...input, idempotencyKey };
+    const run = await client.actApplicationRun(applicationRunId, command);
+    this.keys.delete(fingerprint);
+    return run;
+  }
+};
 
 // src/certificate-funnel-machine.ts
 var FUNNEL_STEPS = [
   "service",
   "preflight",
+  "intake",
+  "slot",
   "identity",
   "confirm-identity",
-  "intake",
   "medicare",
   "consent",
   "payment",
-  "slot",
   "submitted",
   "unavailable",
   "blocked",
@@ -1201,14 +1241,18 @@ var FUNNEL_STEPS = [
   "session-expired"
 ];
 var REQUIRES_REQUEST = /* @__PURE__ */ new Set([
-  "intake",
   "medicare",
   "consent",
   "payment",
-  "slot",
   "submitted"
 ]);
-var REQUIRES_PREFLIGHT = /* @__PURE__ */ new Set(["identity", "confirm-identity"]);
+var REQUIRES_APPLICATION_RUN = /* @__PURE__ */ new Set([
+  "intake",
+  "slot",
+  "identity",
+  "confirm-identity"
+]);
+var REQUIRES_PREFLIGHT = /* @__PURE__ */ new Set(["identity", "confirm-identity", "intake", "slot"]);
 var REQUIRES_SERVICE = /* @__PURE__ */ new Set([
   "preflight",
   "identity",
@@ -1225,15 +1269,6 @@ var DEFAULT_SHAPE = {
   scheduled: true,
   intakeSteps: 1
 };
-var SPINE_OFFSET = {
-  preflight: 1,
-  identity: 2,
-  // The signed-in confirmation REPLACES the anonymous form; it is the same step.
-  "confirm-identity": 2,
-  intake: 3,
-  medicare: 4,
-  consent: 5
-};
 function intakeSpan(shape) {
   return Math.max(1, Math.trunc(shape.intakeSteps ?? 1) || 1);
 }
@@ -1248,14 +1283,17 @@ function totalSteps(shape) {
 }
 function stepNumberFor(step, shape) {
   const picker = shape.pinned ? 0 : 1;
-  const extra = intakeSpan(shape) - 1;
+  const intake = intakeSpan(shape);
   if (step === "service") return shape.pinned ? void 0 : 1;
-  if (step === "payment") return shape.paid ? picker + 6 + extra : void 0;
-  if (step === "slot")
-    return shape.scheduled ? picker + 5 + extra + (shape.paid ? 2 : 1) : void 0;
-  const offset = SPINE_OFFSET[step];
-  if (offset === void 0) return void 0;
-  return picker + offset + (offset > SPINE_OFFSET.intake ? extra : 0);
+  if (step === "preflight") return picker + 1;
+  if (step === "intake") return picker + 2;
+  if (step === "slot") return shape.scheduled ? picker + 2 + intake : void 0;
+  const identity = picker + 2 + intake + (shape.scheduled ? 1 : 0);
+  if (step === "identity" || step === "confirm-identity") return identity;
+  if (step === "medicare") return identity + 1;
+  if (step === "consent") return identity + 2;
+  if (step === "payment") return shape.paid ? identity + 3 : void 0;
+  return void 0;
 }
 function stepProgress(step, shape = DEFAULT_SHAPE, questionIndex = 0) {
   const total = totalSteps(shape);
@@ -1275,7 +1313,9 @@ function initialFunnelState(serviceKey) {
     // safety check, never past it: pinning chooses the product, not the screening.
     step: serviceKey ? "preflight" : "service",
     serviceKey: serviceKey ?? null,
+    applicationRunId: null,
     requestId: null,
+    scheduled: null,
     gate: null,
     failure: null
   };
@@ -1296,9 +1336,13 @@ function reduceFunnel(state, event) {
     case "SELECT_SERVICE":
       if (state.step !== "service") return stay2(state);
       return go2(state, { step: "preflight", serviceKey: event.serviceKey });
-    case "PREFLIGHT_CONFIRMED":
+    case "RUN_STARTED":
       if (state.step !== "preflight") return stay2(state);
-      return go2(state, { step: "identity" });
+      return go2(state, {
+        step: "intake",
+        applicationRunId: event.applicationRunId,
+        scheduled: event.scheduled
+      });
     case "NEED_DIFFERENT":
       return go2(state, { step: "unavailable" });
     case "SIGNED_IN":
@@ -1311,7 +1355,7 @@ function reduceFunnel(state, event) {
     }
     case "REQUEST_STARTED":
       if (state.step !== "identity" && state.step !== "confirm-identity") return stay2(state);
-      return go2(state, { step: "intake", requestId: event.requestId });
+      return go2(state, { step: "medicare", requestId: event.requestId });
     case "GATE":
       return go2(state, {
         step: event.gate.kind === "escalate" ? "escalate" : "blocked",
@@ -1319,7 +1363,10 @@ function reduceFunnel(state, event) {
       });
     case "ANSWERS_COMPLETE":
       if (state.step !== "intake") return stay2(state);
-      return go2(state, { step: "medicare" });
+      return go2(state, { step: state.scheduled ? "slot" : "identity" });
+    case "RESERVED":
+      if (state.step !== "slot") return stay2(state);
+      return go2(state, { step: "identity" });
     case "MEDICARE_DONE":
       if (state.step !== "medicare") return stay2(state);
       return go2(state, { step: "consent" });
@@ -1348,12 +1395,21 @@ function reduceFunnel(state, event) {
     case "BOOKED":
       if (state.step !== "slot") return stay2(state);
       return go2(state, { step: "submitted" });
+    case "RESERVATION_LOST":
+      if (state.step !== "consent" && state.step !== "payment") return stay2(state);
+      return go2(state, { step: "slot" });
     case "SESSION_EXPIRED":
       if (state.step === "session-expired") return stay2(state);
       return go2(state, { step: "session-expired" });
     case "RETRY_PAYMENT":
       if (state.step !== "payment-failed") return stay2(state);
-      return go2(state, { step: "preflight", requestId: null, failure: null });
+      return go2(state, {
+        step: "preflight",
+        applicationRunId: null,
+        requestId: null,
+        scheduled: null,
+        failure: null
+      });
     case "RESTART": {
       const next = go2(initialFunnelState(), { serviceKey: null });
       return next;
@@ -1366,14 +1422,16 @@ function back(state) {
   switch (state.step) {
     case "preflight":
       return go2(state, { step: "service", serviceKey: null });
+    case "intake":
+      return go2(state, { step: "preflight", applicationRunId: null, scheduled: null });
+    case "slot":
+      return go2(state, { step: "intake" });
     case "identity":
-      return go2(state, { step: "preflight" });
+      return go2(state, { step: state.scheduled ? "slot" : "intake" });
     case "confirm-identity":
       return go2(state, { step: "identity" });
-    case "intake":
-      return go2(state, { step: "identity" });
     case "medicare":
-      return go2(state, { step: "intake" });
+      return go2(state, { step: "identity" });
     case "consent":
       return go2(state, { step: "medicare" });
     case "payment":
@@ -1381,7 +1439,13 @@ function back(state) {
     case "unavailable":
       return go2(state, { step: "service" });
     case "payment-failed":
-      return go2(state, { step: "preflight", requestId: null, failure: null });
+      return go2(state, {
+        step: "preflight",
+        applicationRunId: null,
+        requestId: null,
+        scheduled: null,
+        failure: null
+      });
     default:
       return stay2(state);
   }
@@ -1390,10 +1454,6 @@ function canGoBack(state, opts = {}) {
   if (state.step === "preflight" && opts.pinnedService) return false;
   return back(state).effects.length > 0;
 }
-function resumableRequestId(requestId, submittedSnapshot, currentSnapshot) {
-  if (!requestId || !submittedSnapshot || !currentSnapshot) return null;
-  return submittedSnapshot === currentSnapshot ? requestId : null;
-}
 var TERMINAL_WALL = /* @__PURE__ */ new Set([
   "escalate",
   "blocked",
@@ -1414,18 +1474,26 @@ function popAction(current, search, pinnedService) {
   if (TERMINAL_WALL.has(current.step)) return { type: "refuse" };
   return { type: "restore", state: stepFromUrl(search, pinnedService) };
 }
-var URL_KEYS = { step: "cf", requestId: "cfid", serviceKey: "cfsvc" };
+var URL_KEYS = {
+  step: "cf",
+  requestId: "cfid",
+  applicationRunId: "cfrun",
+  serviceKey: "cfsvc"
+};
 function stepFromUrl(search, pinnedService) {
   const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
   const rawStep = params.get(URL_KEYS.step) ?? "";
   const requestId = params.get(URL_KEYS.requestId) || null;
+  const applicationRunId = params.get(URL_KEYS.applicationRunId) || null;
   const urlService = params.get(URL_KEYS.serviceKey) || null;
   const serviceKey = pinnedService ?? urlService;
   const known = FUNNEL_STEPS.includes(rawStep) ? rawStep : null;
   const base2 = {
     step: known ?? initialFunnelState(serviceKey).step,
     serviceKey,
+    applicationRunId,
     requestId,
+    scheduled: null,
     // Gate + failure detail are NOT in the URL: they are server verdicts with clinical
     // copy attached, and a URL that could assert "you are blocked" (or, worse, that you
     // are not) would be a forgeable claim about a safety decision.
@@ -1433,6 +1501,9 @@ function stepFromUrl(search, pinnedService) {
     failure: null
   };
   if (REQUIRES_REQUEST.has(base2.step) && !base2.requestId) {
+    return { ...base2, step: applicationRunId ? "identity" : serviceKey ? "preflight" : "service" };
+  }
+  if (REQUIRES_APPLICATION_RUN.has(base2.step) && !base2.applicationRunId) {
     return { ...base2, step: serviceKey ? "preflight" : "service" };
   }
   if (base2.step === "payment-failed" && !base2.requestId) {
@@ -1444,7 +1515,7 @@ function stepFromUrl(search, pinnedService) {
   if (REQUIRES_SERVICE.has(base2.step) && !base2.serviceKey) {
     return { ...base2, step: "service" };
   }
-  if (REQUIRES_PREFLIGHT.has(base2.step)) {
+  if (REQUIRES_PREFLIGHT.has(base2.step) && !base2.applicationRunId) {
     return { ...base2, step: base2.serviceKey ? "preflight" : "service" };
   }
   if (base2.step === "blocked" || base2.step === "escalate") {
@@ -1456,6 +1527,7 @@ function urlFromState(state, opts = {}) {
   const params = new URLSearchParams();
   params.set(URL_KEYS.step, state.step);
   if (state.requestId) params.set(URL_KEYS.requestId, state.requestId);
+  if (state.applicationRunId) params.set(URL_KEYS.applicationRunId, state.applicationRunId);
   if (state.serviceKey && !opts.pinnedService) params.set(URL_KEYS.serviceKey, state.serviceKey);
   return params.toString();
 }
@@ -1685,17 +1757,17 @@ function PaymentStep({
       const res = await client.payConfirm(requestId);
       switch (res.status) {
         case "awaiting_slot":
-          onOutcome({ kind: "awaiting_slot" });
+          await onOutcome({ kind: "awaiting_slot" });
           return;
         case "ready":
-          onOutcome({ kind: "ready" });
+          await onOutcome({ kind: "ready" });
           return;
         case "requires_action":
           setError("Your bank needs to verify this card. Please try again.");
           setPhase("ready");
           return;
         case "payment_failed":
-          onOutcome({
+          await onOutcome({
             kind: "failed",
             message: "Your card was declined and the pre-authorisation could not be completed."
           });
@@ -2291,13 +2363,43 @@ function IdentityStep(props) {
     },
     [client]
   );
+  const promotionIdempotencyRef = React8.useRef(null);
+  const promotionIdempotencyKey = React8.useCallback((applicationRunId) => {
+    if (promotionIdempotencyRef.current) return promotionIdempotencyRef.current;
+    const retained = retainedPromotionCommandKey(
+      applicationRunId,
+      typeof window === "undefined" ? null : window.sessionStorage
+    );
+    promotionIdempotencyRef.current = retained;
+    return retained;
+  }, []);
   const startRequest = React8.useCallback(
-    async (capturedIdentity) => {
-      const { requestId } = await client.startRequest({ serviceKey: props.serviceKey });
-      onStarted(requestId, capturedIdentity);
+    async (promotion) => {
+      if (!props.applicationRunId) {
+        return (await client.startRequest({ serviceKey: props.serviceKey })).requestId;
+      }
+      const result = await client.promoteApplicationRun(props.applicationRunId, {
+        ...promotion,
+        idempotencyKey: promotionIdempotencyKey(props.applicationRunId)
+      });
+      return result.requestId;
     },
-    [client, props.serviceKey, onStarted]
+    [client, promotionIdempotencyKey, props.applicationRunId, props.serviceKey]
   );
+  const prepareSignInRedirect = React8.useCallback(async () => {
+    if (!props.applicationRunId || typeof window === "undefined") return portal.returnPath();
+    const { handoffId } = await client.createApplicationRunHandoff(props.applicationRunId);
+    let target;
+    try {
+      target = new URL(window.location.href);
+    } catch {
+      return portal.returnPath();
+    }
+    target.searchParams.set("cf", "confirm-identity");
+    target.searchParams.set("cfrun", props.applicationRunId);
+    target.searchParams.set("cfhandoff", handoffId);
+    return portal.returnPath(target.href);
+  }, [client, portal, props.applicationRunId]);
   async function handleConfirmSignedIn() {
     if (busy) return;
     setBusy(true);
@@ -2311,13 +2413,15 @@ function IdentityStep(props) {
         return;
       }
       adoptClaimToken(client, claim.claimToken);
-      await startRequest({
+      const confirmedIdentity = {
         givenName: prefill?.givenName ?? "",
         familyName: prefill?.familyName ?? "",
         email: prefill?.email ?? "",
         phone: prefill?.phone ?? "",
         dateOfBirth: prefill?.dateOfBirth ?? ""
-      });
+      };
+      const requestId = await startRequest();
+      onStarted(requestId, confirmedIdentity);
     } catch (err) {
       setBusy(false);
       setError(errorMessage(err, "We could not start your request. Please try again."));
@@ -2342,17 +2446,29 @@ function IdentityStep(props) {
     setBusy(true);
     setError(null);
     try {
-      await client.startSession({
-        // SPLIT names — never a joined `fullName` (PAT-776).
-        ...toSessionInput(identity),
-        turnstileToken: turnstileToken ?? void 0
-      });
-      persistClaimToken(client);
-      const { requestId } = await client.startRequest({ serviceKey: props.serviceKey });
-      await client.saveAddress(requestId, {
-        address: address.place.address,
-        placeId: address.place?.placeId ?? null
-      });
+      let requestId;
+      if (props.applicationRunId) {
+        requestId = await startRequest({
+          identity: toSessionInput(identity),
+          address: {
+            address: address.place.address,
+            placeId: address.place?.placeId ?? null
+          },
+          turnstileToken: turnstileToken ?? void 0
+        });
+        persistClaimToken(client);
+      } else {
+        await client.startSession({
+          ...toSessionInput(identity),
+          turnstileToken: turnstileToken ?? void 0
+        });
+        persistClaimToken(client);
+        requestId = await startRequest();
+        await client.saveAddress(requestId, {
+          address: address.place.address,
+          placeId: address.place?.placeId ?? null
+        });
+      }
       onStarted(requestId, identity);
     } catch (err) {
       setBusy(false);
@@ -2376,6 +2492,10 @@ function IdentityStep(props) {
       setError(errorMessage(err, "We could not start your request. Please try again."));
     }
   }
+  const reservationNote = props.reservationExpiresAt ? ` Your appointment time is reserved until ${new Intl.DateTimeFormat("en-AU", {
+    hour: "numeric",
+    minute: "2-digit"
+  }).format(new Date(props.reservationExpiresAt))}.` : "";
   if (mode === "confirm-identity") {
     return /* @__PURE__ */ jsxs8(
       FlowShell,
@@ -2383,7 +2503,7 @@ function IdentityStep(props) {
         ...progress,
         stepKey: "confirm-identity",
         heading: "Confirm your details",
-        subheading: detailsSubheading(props.serviceLabel),
+        subheading: `${detailsSubheading(props.serviceLabel)}${reservationNote}`,
         onBack,
         documentTitle,
         children: [
@@ -2408,12 +2528,12 @@ function IdentityStep(props) {
       ...progress,
       stepKey: "identity",
       heading: "Your details",
-      subheading: detailsSubheading(props.serviceLabel),
+      subheading: `${detailsSubheading(props.serviceLabel)}${reservationNote}`,
       onBack,
       documentTitle,
       footer: probing ? void 0 : /* @__PURE__ */ jsx10(FlowButton, { type: "submit", form: "sk-cf-identity", variant: "primary", busy, children: busy ? "Starting\u2026" : "Continue" }),
       children: probing ? /* @__PURE__ */ jsx10(FlowLoading, { message: "Checking if you\u2019re signed in\u2026" }) : /* @__PURE__ */ jsxs8(Fragment3, { children: [
-        /* @__PURE__ */ jsx10(SignInRamp, { redirect: props.returnUrl }),
+        /* @__PURE__ */ jsx10(SignInRamp, { redirect: props.returnUrl, prepareRedirect: prepareSignInRedirect }),
         /* @__PURE__ */ jsx10(FlowErrorSummary, { fields: invalid }),
         /* @__PURE__ */ jsxs8("form", { id: "sk-cf-identity", onSubmit: (e) => void handleSubmitAnonymous(e), noValidate: true, children: [
           /* @__PURE__ */ jsx10(SummarisedFieldErrors, { children: /* @__PURE__ */ jsx10(
@@ -2743,6 +2863,9 @@ function intakeRowsAction(rows) {
 function IntakeStep({
   client,
   requestId,
+  applicationRunId,
+  applicationRunRevision = 0,
+  onApplicationRunChange,
   questionSetId,
   resolveError,
   onGate,
@@ -2756,6 +2879,15 @@ function IntakeStep({
   const [draft, setDraft] = React10.useState(null);
   const [busy, setBusy] = React10.useState(false);
   const [error2, setError] = React10.useState(null);
+  const [runRevision, setRunRevision] = React10.useState(applicationRunRevision);
+  const [completed, setCompleted] = React10.useState(false);
+  const [emptyCompletionRetry, setEmptyCompletionRetry] = React10.useState(0);
+  const commandRetrier = React10.useRef(new ApplicationRunCommandRetrier()).current;
+  const pendingCompletionRevision = React10.useRef(null);
+  const emptyCompletionAttempted = React10.useRef(false);
+  React10.useEffect(() => {
+    setRunRevision(applicationRunRevision);
+  }, [applicationRunRevision]);
   const [reload2, setReload] = React10.useState(0);
   const progress = useStepProgress("intake", index);
   React10.useEffect(() => {
@@ -2784,8 +2916,28 @@ function IntakeStep({
     };
   }, [client, questionSetId, reload2]);
   React10.useEffect(() => {
-    if (questions && questions.length === 0 && !busy) onComplete();
-  }, [questions, busy, onComplete]);
+    if (!questions || questions.length !== 0 || busy || completed || emptyCompletionAttempted.current) return;
+    emptyCompletionAttempted.current = true;
+    if (!applicationRunId) {
+      setCompleted(true);
+      onComplete();
+      return;
+    }
+    setBusy(true);
+    void commandRetrier.act(client, applicationRunId, {
+      expectedRevision: runRevision,
+      action: { type: "complete_screening" }
+    }).then((run) => {
+      setRunRevision(run.revision);
+      onApplicationRunChange?.(run);
+      const exit = gateToExit(run.gate);
+      if (exit) onGate(exit);
+      else {
+        setCompleted(true);
+        onComplete();
+      }
+    }).catch((e) => setError(errorMessage(e, "We could not complete the screening. Please try again."))).finally(() => setBusy(false));
+  }, [questions, busy, completed, emptyCompletionRetry, applicationRunId, client, runRevision, onApplicationRunChange, onGate, onComplete]);
   const visible = React10.useMemo(
     () => questions ? visibleQuestions(questions, answers) : [],
     [questions, answers]
@@ -2795,17 +2947,60 @@ function IntakeStep({
   React10.useEffect(() => {
     setDraft(current ? answers[current.key] ?? null : null);
   }, [current?.key]);
+  async function retryPendingCompletion() {
+    if (busy || !applicationRunId || pendingCompletionRevision.current == null) return;
+    setBusy(true);
+    setError(null);
+    try {
+      const completedRun = await commandRetrier.act(client, applicationRunId, {
+        expectedRevision: pendingCompletionRevision.current,
+        action: { type: "complete_screening" }
+      });
+      pendingCompletionRevision.current = null;
+      setRunRevision(completedRun.revision);
+      onApplicationRunChange?.(completedRun);
+      const completedExit = gateToExit(completedRun.gate);
+      if (completedExit) onGate(completedExit);
+      else {
+        setCompleted(true);
+        onComplete();
+      }
+    } catch (e) {
+      setError(errorMessage(e, "We could not complete the screening. Please try again."));
+    } finally {
+      setBusy(false);
+    }
+  }
   async function record(value) {
     if (!current || busy) return;
-    const next = { ...answers, [current.key]: value };
-    setAnswers(next);
+    if (applicationRunId && pendingCompletionRevision.current != null) {
+      await retryPendingCompletion();
+      return;
+    }
     setBusy(true);
     setError(null);
+    const next = { ...answers, [current.key]: value };
+    setAnswers(next);
     try {
-      const { gate } = await client.saveAnswers(
-        requestId,
-        next
-      );
+      let savedRun = null;
+      let gate;
+      if (applicationRunId) {
+        savedRun = await commandRetrier.act(client, applicationRunId, {
+          expectedRevision: runRevision,
+          action: {
+            type: "save_answers",
+            answers: next
+          }
+        });
+        setRunRevision(savedRun.revision);
+        onApplicationRunChange?.(savedRun);
+        gate = savedRun.gate;
+      } else {
+        gate = (await client.saveAnswers(
+          requestId ?? "",
+          next
+        )).gate;
+      }
       const exit = gateToExit(gate);
       if (exit) {
         onGate(exit);
@@ -2813,7 +3008,25 @@ function IntakeStep({
       }
       const nextVisible = questions ? visibleQuestions(questions, next) : [];
       if (index + 1 >= nextVisible.length) {
-        onComplete();
+        if (applicationRunId && savedRun) {
+          pendingCompletionRevision.current = savedRun.revision;
+          const completedRun = await commandRetrier.act(client, applicationRunId, {
+            expectedRevision: savedRun.revision,
+            action: { type: "complete_screening" }
+          });
+          pendingCompletionRevision.current = null;
+          setRunRevision(completedRun.revision);
+          onApplicationRunChange?.(completedRun);
+          const completedExit = gateToExit(completedRun.gate);
+          if (completedExit) onGate(completedExit);
+          else {
+            setCompleted(true);
+            onComplete();
+          }
+        } else {
+          setCompleted(true);
+          onComplete();
+        }
         return;
       }
       setIndex(index + 1);
@@ -2859,6 +3072,23 @@ function IntakeStep({
       }
     );
   }
+  if (questions.length === 0) {
+    return /* @__PURE__ */ jsx12(
+      IntakeInterstitial,
+      {
+        progress,
+        documentTitle,
+        onBack,
+        error: error2,
+        message: busy || !error2 ? "Completing your screening\u2026" : void 0,
+        onRetry: error2 ? () => {
+          emptyCompletionAttempted.current = false;
+          setError(null);
+          setEmptyCompletionRetry((value) => value + 1);
+        } : void 0
+      }
+    );
+  }
   if (!current) {
     return /* @__PURE__ */ jsx12(
       IntakeInterstitial,
@@ -2906,7 +3136,17 @@ function IntakeStep({
             idPrefix: `sk-cf-${index}`
           }
         ),
-        /* @__PURE__ */ jsx12(FlowError, { children: error2 })
+        /* @__PURE__ */ jsx12(FlowError, { children: error2 }),
+        error2 && pendingCompletionRevision.current != null && /* @__PURE__ */ jsx12(
+          FlowButton,
+          {
+            type: "button",
+            variant: "primary",
+            busy,
+            onClick: () => void retryPendingCompletion(),
+            children: "Try again"
+          }
+        )
       ]
     }
   );
@@ -3310,7 +3550,7 @@ function ConsentStep({
         onGate(gate ?? { kind: "block" });
         return;
       }
-      onSubmitted(result.status, gate);
+      await onSubmitted(result.status, gate);
     } catch (err) {
       setBusy(false);
       setError(errorMessage(err, "We could not submit your request. Please try again."));
@@ -3415,6 +3655,10 @@ function SlotCancelControl({
 function SlotStep({
   client,
   requestId,
+  applicationRunId,
+  applicationRunRevision = 0,
+  onApplicationRunChange,
+  replacementReservation = false,
   appointmentTypeId,
   isFree,
   onBooked,
@@ -3425,13 +3669,15 @@ function SlotStep({
   const [cancelling, setCancelling] = React13.useState(false);
   const [confirmCancel, setConfirmCancel] = React13.useState(false);
   const [cancelError, setCancelError] = React13.useState(null);
+  const commandRetrier = React13.useRef(new ApplicationRunCommandRetrier()).current;
   const progress = useStepProgress("slot");
   async function releaseAndExit() {
     if (cancelling) return;
     setCancelling(true);
     setCancelError(null);
     try {
-      await client.cancelRequest(requestId);
+      if (applicationRunId) await client.closeApplicationRun(applicationRunId);
+      else await client.cancelRequest(requestId ?? "");
       onCancelled();
     } catch (err) {
       setCancelling(false);
@@ -3457,18 +3703,33 @@ function SlotStep({
             appointmentTypeId,
             mode: "request",
             onConfirm: async (slot, tz) => {
-              const hold = await client.createHold({
-                practitionerId: slot.practitionerId,
-                appointmentTypeId,
-                slotStart: slot.start,
-                serviceRequestId: requestId
-              });
-              await client.bookRequest(requestId, {
-                practitionerId: slot.practitionerId,
-                slotStart: slot.start,
-                holdId: hold.holdId,
-                holderToken: hold.holderToken
-              });
+              if (applicationRunId) {
+                const run = await commandRetrier.act(client, applicationRunId, {
+                  expectedRevision: applicationRunRevision,
+                  action: {
+                    type: "reserve_slot",
+                    practitionerId: slot.practitionerId,
+                    slotStart: slot.start
+                  }
+                });
+                onApplicationRunChange?.(run);
+              } else {
+                const hold = replacementReservation ? await client.replaceRequestSlot(requestId ?? "", {
+                  practitionerId: slot.practitionerId,
+                  slotStart: slot.start
+                }) : await client.createHold({
+                  practitionerId: slot.practitionerId,
+                  appointmentTypeId,
+                  slotStart: slot.start,
+                  serviceRequestId: requestId
+                });
+                await client.bookRequest(requestId ?? "", {
+                  practitionerId: slot.practitionerId,
+                  slotStart: slot.start,
+                  holdId: hold.holdId,
+                  holderToken: hold.holderToken
+                });
+              }
               onBooked(formatBookedFor(slot.start, tz));
             }
           }
@@ -3485,11 +3746,12 @@ function SlotStep({
               clinicPhone
             ] })
           ] }),
-          isFree === false && /* @__PURE__ */ jsxs13("p", { className: "sk-slots__empty-note", children: [
+          isFree === false && !applicationRunId && /* @__PURE__ */ jsxs13("p", { className: "sk-slots__empty-note", children: [
             "You haven\u2019t been charged \u2014 only a hold was placed on your card.",
             " ",
             HOLD_RELEASE_NOTE
-          ] })
+          ] }),
+          applicationRunId && /* @__PURE__ */ jsx15("p", { className: "sk-slots__empty-note", children: "We\u2019ll reserve this time for 10 minutes while you confirm your details and payment." })
         ] }),
         /* @__PURE__ */ jsx15(
           SlotCancelControl,
@@ -4035,6 +4297,13 @@ function CertificateFunnelClient(props) {
   }
   return /* @__PURE__ */ jsx19(PortalProvider, { client: portalClient, children: /* @__PURE__ */ jsx19(Funnel, { ...props }) });
 }
+var RESERVATION_REQUIRED_STEPS = /* @__PURE__ */ new Set([
+  "identity",
+  "confirm-identity",
+  "medicare",
+  "consent",
+  "payment"
+]);
 function Funnel({
   publicApi,
   services = [],
@@ -4044,6 +4313,7 @@ function Funnel({
   serviceKey: pinnedService
 }) {
   const api = publicApi;
+  const portalClient = usePortalClient();
   const rawClient = React16.useMemo(
     () => patientos({ publishableKey: api.publishableKey, apiBase: api.apiBase }),
     [api.publishableKey, api.apiBase]
@@ -4051,15 +4321,17 @@ function Funnel({
   const pinned = React16.useMemo(() => ({ pinnedService: !!pinnedService }), [pinnedService]);
   const [state, setState] = React16.useState(null);
   const [flow, setFlow] = React16.useState(null);
+  const [applicationRun, setApplicationRun] = React16.useState(null);
   const [flowChecked, setFlowChecked] = React16.useState(false);
   const [capturing, setCapturing] = React16.useState(false);
   const [cancellingLostSlot, setCancellingLostSlot] = React16.useState(false);
   const [lostSlotCancelError, setLostSlotCancelError] = React16.useState(null);
   const [resolveError, setResolveError] = React16.useState(null);
+  const [reopeningScreening, setReopeningScreening] = React16.useState(false);
+  const [reopenScreeningError, setReopenScreeningError] = React16.useState(null);
+  const applicationRunCommands = React16.useRef(new ApplicationRunCommandRetrier()).current;
+  const beginAttemptRef = React16.useRef(null);
   const [identityDraft, setIdentityDraft] = React16.useState(null);
-  const [submittedIdentitySnapshot, setSubmittedIdentitySnapshot] = React16.useState(
-    null
-  );
   const onDraftChange = React16.useCallback((draft) => setIdentityDraft(draft), []);
   const [medicareDraft, setMedicareDraft] = React16.useState(null);
   const onMedicareDraftChange = React16.useCallback(
@@ -4097,6 +4369,7 @@ function Funnel({
     null
   );
   const [questionCounts, setQuestionCounts] = React16.useState({});
+  const [enabledServiceKeys, setEnabledServiceKeys] = React16.useState(null);
   React16.useEffect(() => {
     let alive = true;
     void (async () => {
@@ -4109,7 +4382,10 @@ function Funnel({
         const nextFees = {};
         const nextDeliveryModes = {};
         const nextCounts = {};
+        const nextEnabledKeys = /* @__PURE__ */ new Set();
         for (const svc of svcs) {
+          if (svc.anonymousApplicationRuns === false) continue;
+          nextEnabledKeys.add(svc.key);
           const option = pickDeliveryOption(options, svc.id);
           nextFees[svc.key] = effectiveFee(svc, option);
           if (option) nextDeliveryModes[svc.key] = option.deliveryMode;
@@ -4118,10 +4394,12 @@ function Funnel({
         setFees(nextFees);
         setDeliveryModes(nextDeliveryModes);
         setQuestionCounts(nextCounts);
+        setEnabledServiceKeys(nextEnabledKeys);
       } catch {
         if (alive) {
           setFees({});
           setDeliveryModes({});
+          setEnabledServiceKeys(/* @__PURE__ */ new Set());
         }
       }
     })();
@@ -4148,66 +4426,221 @@ function Funnel({
     return () => window.removeEventListener("popstate", onPop);
   }, [dispatch, pinnedService, pinned]);
   const requestId = state?.requestId ?? null;
+  const applicationRunId = state?.applicationRunId ?? null;
+  const flowId = requestId ?? applicationRunId;
   React16.useEffect(() => {
-    if (!requestId) {
+    if (!flowId) {
       setFlow(null);
       setFlowChecked(false);
+      setApplicationRun(null);
       return;
     }
-    if (flow) {
-      setFlowChecked(true);
+    if (!flow) setFlow(loadFlowRecord(flowId));
+    setFlowChecked(true);
+  }, [flowId, flow]);
+  const hydrateRunFlow = React16.useCallback(async (run) => {
+    const existing = loadFlowRecord(run.id);
+    if (existing) {
+      setFlow(existing);
       return;
     }
-    setFlow(loadFlowRecord(requestId));
-    setFlowChecked(true);
-  }, [requestId, flow]);
-  const captureFlow = React16.useCallback(
-    async (newRequestId, serviceKey, identity) => {
+    const [svc, options] = await Promise.all([
+      findServiceByKey(client, run.serviceKey),
+      once(client.subscribeDeliveryOptions)
+    ]);
+    const option = options.find((candidate) => candidate.id === run.serviceDeliveryOptionId);
+    if (!svc || !option) throw new Error("This application option is no longer available.");
+    const record = {
+      serviceId: svc.id,
+      serviceKey: svc.key,
+      serviceLabel: svc.label,
+      deliveryOptionId: option.id,
+      appointmentTypeId: run.appointmentTypeId ?? "",
+      feeAmount: option.feeOverride ?? svc.feeAmount,
+      requiresPayment: svc.requiresPayment,
+      deliveryMode: run.deliveryMode,
+      givenName: "",
+      familyName: "",
+      dateOfBirth: null,
+      questionSetId: run.questionSetId,
+      bookedFor: void 0
+    };
+    saveFlowRecord(run.id, record);
+    setFlow(record);
+  }, [client]);
+  React16.useEffect(() => {
+    if (!applicationRunId || applicationRun?.id === applicationRunId) return;
+    let alive = true;
+    void (async () => {
+      const params = new URLSearchParams(window.location.search);
+      const handoffId = params.get("cfhandoff");
+      if (handoffId) {
+        const redeemed = await portalClient.redeemApplicationRunHandoff(handoffId);
+        if (!redeemed || !alive) throw new Error("This sign-in continuation has expired.");
+        rawClient.setApplicationRunToken(applicationRunId, redeemed.capabilityToken);
+        saveApplicationRunToken(rawClient, applicationRunId);
+        setApplicationRun(redeemed.run);
+        await hydrateRunFlow(redeemed.run);
+        const next = {
+          ...stateRef.current ?? initialFunnelState(pinnedService),
+          step: redeemed.run.deliveryMode === "scheduled" && !redeemed.run.reservation ? "slot" : "confirm-identity",
+          applicationRunId,
+          serviceKey: redeemed.run.serviceKey,
+          scheduled: redeemed.run.deliveryMode === "scheduled"
+        };
+        dispatch({ type: "RESTORE", state: next });
+        params.delete("cfhandoff");
+        window.history.replaceState(null, "", `${window.location.pathname}?${params.toString()}${window.location.hash}`);
+        return;
+      }
+      if (!restoreApplicationRunToken(rawClient, applicationRunId)) {
+        throw new Error("This application can only be resumed from its secure sign-in link.");
+      }
+      const resumed = await rawClient.resumeApplicationRun(applicationRunId);
+      if (!alive) return;
+      setApplicationRun(resumed);
+      await hydrateRunFlow(resumed);
+      const current = stateRef.current;
+      if (current) {
+        dispatch({
+          type: "RESTORE",
+          state: {
+            ...current,
+            step: resumed.deliveryMode === "scheduled" && !resumed.reservation && RESERVATION_REQUIRED_STEPS.has(current.step) ? "slot" : current.step,
+            serviceKey: resumed.serviceKey,
+            scheduled: resumed.deliveryMode === "scheduled",
+            gate: resumed.gate ? { kind: resumed.gate.verdict === "escalate" ? "escalate" : "block", ruleId: resumed.gate.ruleId, message: resumed.gate.message } : current.gate
+          }
+        });
+      }
+    })().catch((err) => {
+      if (alive) setResolveError(err instanceof Error ? err.message : "We could not resume this application.");
+    });
+    return () => {
+      alive = false;
+    };
+  }, [applicationRunId, applicationRun?.id, dispatch, hydrateRunFlow, pinnedService, portalClient, rawClient]);
+  const reopenScreening = React16.useCallback(async () => {
+    if (!applicationRunId || !applicationRun || applicationRun.status !== "screening_complete" && applicationRun.status !== "reserved") {
+      return;
+    }
+    setReopeningScreening(true);
+    setReopenScreeningError(null);
+    try {
+      const run = await applicationRunCommands.act(client, applicationRunId, {
+        expectedRevision: applicationRun.revision,
+        action: { type: "reopen_screening" }
+      });
+      setApplicationRun(run);
+    } catch (err) {
+      setReopenScreeningError(
+        errorMessage(err, "We could not reopen your screening. Please try again.")
+      );
+    } finally {
+      setReopeningScreening(false);
+    }
+  }, [applicationRun, applicationRunCommands, applicationRunId, client]);
+  React16.useEffect(() => {
+    if (state?.step === "intake") void reopenScreening();
+  }, [reopenScreening, state?.step]);
+  const beginRun = React16.useCallback(async (serviceKey) => {
+    if (capturing) return;
+    setCapturing(true);
+    setResolveError(null);
+    try {
       const svc = await findServiceByKey(client, serviceKey);
-      if (!svc) throw new Error("This certificate type is not currently available.");
+      if (!svc || svc.anonymousApplicationRuns === false) {
+        throw new Error("This certificate type is not currently available.");
+      }
       const option = await findDeliveryOption(client, svc.id);
       if (!option) throw new Error("No booking option is available for this service.");
+      let attempt = beginAttemptRef.current;
+      if (!attempt || attempt.serviceKey !== serviceKey || attempt.serviceDeliveryOptionId !== option.id) {
+        const bytes = new Uint8Array(32);
+        crypto.getRandomValues(bytes);
+        attempt = {
+          serviceKey,
+          serviceDeliveryOptionId: option.id,
+          idempotencyKey: crypto.randomUUID(),
+          capabilityToken: Array.from(
+            bytes,
+            (b) => b.toString(16).padStart(2, "0")
+          ).join("")
+        };
+        beginAttemptRef.current = attempt;
+      }
+      const result = await client.beginApplicationRun(attempt);
+      beginAttemptRef.current = null;
+      saveApplicationRunToken(client, result.run.id);
       const record = {
         serviceId: svc.id,
         serviceKey: svc.key,
         serviceLabel: svc.label,
         deliveryOptionId: option.id,
         appointmentTypeId: option.appointmentTypeId ?? "",
-        // The EFFECTIVE fee: the option's override wins over the service base (PAT-710).
         feeAmount: option.feeOverride ?? svc.feeAmount,
-        // Whether money is taken AT ALL — a separate fact from the amount, and the one
-        // the consent wording branches on. A null fee alone could not distinguish
-        // "bulk billed" from "not resolved yet" (PAT-853).
         requiresPayment: svc.requiresPayment,
         deliveryMode: option.deliveryMode,
-        givenName: identity.givenName,
-        familyName: identity.familyName,
-        dateOfBirth: identity.dateOfBirth || null,
+        givenName: "",
+        familyName: "",
+        dateOfBirth: null,
         questionSetId: svc.questionSetId
       };
-      saveFlowRecord(newRequestId, record);
+      saveFlowRecord(result.run.id, record);
       setFlow(record);
-    },
-    [client]
-  );
-  const back2 = React16.useCallback(() => dispatch({ type: "BACK" }), [dispatch]);
+      setApplicationRun(result.run);
+      dispatch({
+        type: "RUN_STARTED",
+        applicationRunId: result.run.id,
+        scheduled: result.run.deliveryMode === "scheduled"
+      });
+    } catch (err) {
+      setResolveError(err instanceof Error ? err.message : "We could not start your application.");
+    } finally {
+      setCapturing(false);
+    }
+  }, [capturing, client, dispatch]);
+  const back2 = React16.useCallback(() => {
+    const runId = state?.applicationRunId;
+    if (state?.step === "intake" && runId) {
+      void client.closeApplicationRun(runId).finally(() => dispatch({ type: "BACK" }));
+      return;
+    }
+    const returnsToIntake = state?.step === "slot" || state?.step === "identity" && state.scheduled === false;
+    if (returnsToIntake && runId && applicationRun && (applicationRun.status === "screening_complete" || applicationRun.status === "reserved")) {
+      void applicationRunCommands.act(client, runId, {
+        expectedRevision: applicationRun.revision,
+        action: { type: "reopen_screening" }
+      }).then((run) => {
+        setApplicationRun(run);
+        dispatch({ type: "BACK" });
+      }).catch((err) => {
+        setResolveError(errorMessage(err, "We could not reopen your screening. Please try again."));
+      });
+      return;
+    }
+    dispatch({ type: "BACK" });
+  }, [applicationRun, applicationRunCommands, client, dispatch, state]);
   const restart = React16.useCallback(() => {
     setIdentityDraft(null);
-    setSubmittedIdentitySnapshot(null);
     setMedicareDraft(null);
     dispatch({ type: "RESTART" });
   }, [dispatch]);
   const retryPayment = React16.useCallback(() => {
-    setSubmittedIdentitySnapshot(null);
     dispatch({ type: "RETRY_PAYMENT" });
   }, [dispatch]);
   const cancelLostSlot = React16.useCallback(async () => {
     const id = state?.requestId;
-    if (!id || cancellingLostSlot) return;
+    const runId = state?.applicationRunId;
+    if (!id && !runId || cancellingLostSlot) return;
     setCancellingLostSlot(true);
     setLostSlotCancelError(null);
     try {
-      await cancelRequestThenRestart(client, id, restart);
+      if (id) await cancelRequestThenRestart(client, id, restart);
+      else if (runId) {
+        await client.closeApplicationRun(runId);
+        restart();
+      }
       setCancellingLostSlot(false);
     } catch (err) {
       setCancellingLostSlot(false);
@@ -4215,7 +4648,7 @@ function Funnel({
         errorCode(err) === "not_cancellable" ? "This request can no longer be cancelled \u2014 please call the clinic." : "We could not cancel your request. Please try again."
       );
     }
-  }, [cancellingLostSlot, client, restart, state?.requestId]);
+  }, [cancellingLostSlot, client, restart, state?.applicationRunId, state?.requestId]);
   const chosenKey = state?.serviceKey ?? null;
   const step = state?.step;
   const shape = React16.useMemo(() => {
@@ -4241,16 +4674,32 @@ function Funnel({
   }, [flow, fees, pinnedService, chosenKey, step, questionCounts]);
   if (!state) return /* @__PURE__ */ jsx19(FlowLoading, {});
   const title = stepTitle(state.step, clinicName);
-  const service = services.find((s) => s.key === state.serviceKey) ?? null;
+  const selectableServices = enabledServiceKeys ? services.filter((candidate) => enabledServiceKeys.has(candidate.key)) : [];
+  const service = selectableServices.find((candidate) => candidate.key === state.serviceKey) ?? null;
   const serviceLabel = service?.label ?? "certificate";
-  const identitySnapshot = identityDraft ? JSON.stringify(identityDraft) : null;
-  const resumeRequestId = resumableRequestId(
-    state.requestId,
-    submittedIdentitySnapshot,
-    identitySnapshot
-  );
   const showBack = canGoBack(state, pinned);
   const flowLost = slotFlowIsLost(flowChecked, flow, capturing);
+  const reservationWasLost = (err) => {
+    const code2 = errorCode(err);
+    return code2 === "reservation_expired" || code2 === "slot_taken";
+  };
+  async function bookReservedSlot() {
+    const id = requestId;
+    const reservation = applicationRun?.reservation;
+    if (!id || !reservation) {
+      throw new PatientOSApiError2({
+        status: 409,
+        code: "reservation_expired",
+        message: "Your appointment reservation has expired. Please choose another time.",
+        path: `/requests/${id ?? "unknown"}/book`
+      });
+    }
+    await client.bookRequest(id, {
+      practitionerId: reservation.practitionerId,
+      slotStart: reservation.slotStart,
+      holdId: reservation.holdId
+    });
+  }
   const quietMoney = HOLDLESS_STEPS.has(state.step) || state.step === "consent" || state.step === "payment";
   const rail = /* @__PURE__ */ jsx19(
     TrustRail,
@@ -4265,7 +4714,7 @@ function Funnel({
         return /* @__PURE__ */ jsx19(
           ServiceStep,
           {
-            services,
+            services: selectableServices,
             fees,
             deliveryModes,
             heading: heading2,
@@ -4276,69 +4725,111 @@ function Funnel({
           }
         );
       case "preflight":
-        return /* @__PURE__ */ jsx19(
-          PreflightStep,
-          {
-            documentTitle: title,
-            onConfirm: () => dispatch({ type: "PREFLIGHT_CONFIRMED" }),
-            onExit: (gate) => dispatch({ type: "GATE", gate }),
-            onOutOfScope: () => dispatch({ type: "NEED_DIFFERENT" }),
-            onBack: showBack ? back2 : void 0
-          }
-        );
+        if (!enabledServiceKeys) return /* @__PURE__ */ jsx19(FlowLoading, {});
+        if (!state.serviceKey || !enabledServiceKeys.has(state.serviceKey)) {
+          return /* @__PURE__ */ jsxs17(
+            FlowShell,
+            {
+              ...stepProgress("preflight", shape),
+              stepKey: "preflight:unavailable",
+              heading: "This certificate type is unavailable",
+              documentTitle: title,
+              onBack: showBack ? back2 : void 0,
+              children: [
+                /* @__PURE__ */ jsx19(FlowError, { children: "This certificate type is not currently available through this website." }),
+                /* @__PURE__ */ jsx19(
+                  FlowButton,
+                  {
+                    type: "button",
+                    variant: "primary",
+                    onClick: () => dispatch({ type: "NEED_DIFFERENT" }),
+                    children: "Choose another option"
+                  }
+                )
+              ]
+            }
+          );
+        }
+        return /* @__PURE__ */ jsxs17("div", { children: [
+          /* @__PURE__ */ jsx19(
+            PreflightStep,
+            {
+              documentTitle: title,
+              onConfirm: () => void beginRun(state.serviceKey ?? ""),
+              onExit: (gate) => dispatch({ type: "GATE", gate }),
+              onOutOfScope: () => dispatch({ type: "NEED_DIFFERENT" }),
+              onBack: showBack ? back2 : void 0
+            }
+          ),
+          /* @__PURE__ */ jsx19(FlowError, { children: resolveError })
+        ] });
       case "identity":
       case "confirm-identity":
-        return /* @__PURE__ */ jsxs17(
-          "div",
-          {
-            onSubmitCapture: (event) => {
-              if (!resumeRequestId) return;
-              event.preventDefault();
-              event.stopPropagation();
-              setResolveError(null);
-              dispatch({ type: "REQUEST_STARTED", requestId: resumeRequestId });
-            },
-            children: [
-              /* @__PURE__ */ jsx19(
-                IdentityStep,
-                {
-                  client,
-                  turnstileSiteKey: api.turnstileSiteKey,
-                  serviceKey: state.serviceKey ?? "",
-                  serviceLabel,
-                  mode: state.step,
-                  documentTitle: title,
-                  onSignedIn: () => dispatch({ type: "SIGNED_IN" }),
-                  onRejected: () => {
-                    setIdentityDraft(null);
-                    setMedicareDraft(null);
-                    dispatch({ type: "IDENTITY_REJECTED" });
-                  },
-                  onBack: showBack ? back2 : void 0,
-                  draft: identityDraft ?? void 0,
-                  onDraftChange,
-                  onStarted: (newRequestId, identity) => {
-                    const capturedDraft = capturedIdentityDraft(identity, identityDraft);
-                    setCapturing(true);
-                    setIdentityDraft(capturedDraft);
-                    setSubmittedIdentitySnapshot(JSON.stringify(capturedDraft));
-                    dispatch({ type: "REQUEST_STARTED", requestId: newRequestId });
-                    void captureFlow(newRequestId, state.serviceKey ?? "", identity).catch(
-                      (e) => setResolveError(e instanceof Error ? e.message : "Something went wrong.")
-                    ).finally(() => setCapturing(false));
-                  }
+        return /* @__PURE__ */ jsxs17("div", { children: [
+          /* @__PURE__ */ jsx19(
+            IdentityStep,
+            {
+              client,
+              turnstileSiteKey: api.turnstileSiteKey,
+              serviceKey: state.serviceKey ?? "",
+              serviceLabel,
+              applicationRunId: state.applicationRunId ?? void 0,
+              reservationExpiresAt: applicationRun?.reservation?.expiresAt ?? null,
+              mode: state.step,
+              documentTitle: title,
+              onSignedIn: () => dispatch({ type: "SIGNED_IN" }),
+              onRejected: () => {
+                setIdentityDraft(null);
+                setMedicareDraft(null);
+                dispatch({ type: "IDENTITY_REJECTED" });
+              },
+              onBack: showBack ? back2 : void 0,
+              draft: identityDraft ?? void 0,
+              onDraftChange,
+              onStarted: (newRequestId, identity) => {
+                const capturedDraft = capturedIdentityDraft(identity, identityDraft);
+                setIdentityDraft(capturedDraft);
+                if (flow) {
+                  const next = {
+                    ...flow,
+                    givenName: identity.givenName,
+                    familyName: identity.familyName,
+                    dateOfBirth: identity.dateOfBirth || null
+                  };
+                  saveFlowRecord(newRequestId, next);
+                  setFlow(next);
                 }
-              ),
-              /* @__PURE__ */ jsx19(FlowError, { children: resolveError })
-            ]
-          }
-        );
+                dispatch({ type: "REQUEST_STARTED", requestId: newRequestId });
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx19(FlowError, { children: resolveError })
+        ] });
       case "intake":
+        if (reopeningScreening || reopenScreeningError || applicationRun?.status === "screening_complete" || applicationRun?.status === "reserved") {
+          return /* @__PURE__ */ jsxs17(
+            FlowShell,
+            {
+              ...stepProgress("intake", shape),
+              stepKey: "intake:reopening",
+              heading: "Review your screening",
+              documentTitle: title,
+              onBack: showBack ? back2 : void 0,
+              children: [
+                reopeningScreening && /* @__PURE__ */ jsx19(FlowLoading, { message: "Reopening your screening\u2026" }),
+                /* @__PURE__ */ jsx19(FlowError, { children: reopenScreeningError }),
+                reopenScreeningError && /* @__PURE__ */ jsx19(FlowButton, { type: "button", variant: "primary", onClick: () => void reopenScreening(), children: "Try again" })
+              ]
+            }
+          );
+        }
         return /* @__PURE__ */ jsx19(
           IntakeStep,
           {
             client,
-            requestId: state.requestId ?? "",
+            applicationRunId: state.applicationRunId ?? void 0,
+            applicationRunRevision: applicationRun?.revision ?? 0,
+            onApplicationRunChange: setApplicationRun,
             questionSetId: flow ? flow.questionSetId ?? null : void 0,
             resolveError,
             documentTitle: title,
@@ -4389,7 +4880,22 @@ function Funnel({
             phone: identityDraft?.identity.phone ?? "",
             serviceLabel: service?.label ?? "",
             documentTitle: title,
-            onSubmitted: (status, gate) => dispatch({ type: "SUBMITTED", status, gate }),
+            onSubmitted: async (status, gate) => {
+              if (status === "awaiting_slot") {
+                try {
+                  await bookReservedSlot();
+                  dispatch({ type: "SUBMITTED", status: "ready", gate });
+                } catch (err) {
+                  if (reservationWasLost(err)) {
+                    dispatch({ type: "RESERVATION_LOST" });
+                    return;
+                  }
+                  throw err;
+                }
+              } else {
+                dispatch({ type: "SUBMITTED", status, gate });
+              }
+            },
             onGate: (gate) => dispatch({ type: "GATE", gate }),
             onBack: showBack ? back2 : void 0
           }
@@ -4412,7 +4918,22 @@ function Funnel({
                 feeAmount: flow?.feeAmount ?? null,
                 serviceLabel,
                 clinicPhone,
-                onOutcome: (outcome) => dispatch({ type: "PAY_OUTCOME", outcome })
+                onOutcome: async (outcome) => {
+                  if (outcome.kind === "awaiting_slot") {
+                    try {
+                      await bookReservedSlot();
+                      dispatch({ type: "PAY_OUTCOME", outcome: { kind: "ready" } });
+                    } catch (err) {
+                      if (reservationWasLost(err)) {
+                        dispatch({ type: "RESERVATION_LOST" });
+                        return;
+                      }
+                      throw err;
+                    }
+                  } else {
+                    dispatch({ type: "PAY_OUTCOME", outcome });
+                  }
+                }
               }
             )
           }
@@ -4422,20 +4943,24 @@ function Funnel({
           SlotStep,
           {
             client,
-            requestId: state.requestId ?? "",
+            requestId: state.requestId ?? void 0,
+            applicationRunId: state.requestId ? void 0 : state.applicationRunId ?? void 0,
+            applicationRunRevision: applicationRun?.revision ?? 0,
+            onApplicationRunChange: setApplicationRun,
+            replacementReservation: Boolean(state.requestId && state.applicationRunId),
             appointmentTypeId: flow.appointmentTypeId,
             isFree: flowIsFree(flow),
             clinicPhone,
             onCancelled: restart,
             documentTitle: title,
             onBooked: (bookedFor) => {
-              const id = state.requestId;
+              const id = state.requestId ?? state.applicationRunId;
               if (id && flow) {
                 const next = { ...flow, bookedFor };
                 saveFlowRecord(id, next);
                 setFlow(next);
               }
-              dispatch({ type: "BOOKED" });
+              dispatch({ type: state.requestId ? "BOOKED" : "RESERVED" });
             }
           }
         ) : flowLost ? (
@@ -4557,14 +5082,14 @@ function SessionExpiredState({
       stepKey: "session-expired",
       heading: "Your secure session ended",
       documentTitle,
-      footer: portalUrl ? /* @__PURE__ */ jsx19("a", { className: "sk-flow__btn sk-flow__btn--primary", href: portalUrl, children: "Continue in the patient portal" }) : !requestStarted ? /* @__PURE__ */ jsx19(FlowButton, { type: "button", variant: "primary", onClick: onRestart, children: "Start again securely" }) : void 0,
+      footer: portalUrl ? /* @__PURE__ */ jsx19("a", { className: "sk-flow__btn sk-flow__btn--primary", href: portalUrl, children: "Continue in the patient portal" }) : requestStarted ? void 0 : /* @__PURE__ */ jsx19(FlowButton, { type: "button", variant: "primary", onClick: onRestart, children: "Start again securely" }),
       children: [
         /* @__PURE__ */ jsxs17("p", { className: "sk-cf__body", children: [
           "This secure session is no longer available.",
           " ",
           requestStarted ? "Your request is still with the clinic." : "You can start again securely."
         ] }),
-        clinicPhone ? /* @__PURE__ */ jsx19(ClinicPhone, { clinicPhone }) : !portalUrl ? /* @__PURE__ */ jsx19("p", { className: "sk-cf__aside", children: "Please contact the clinic using the details on this website." }) : null
+        clinicPhone ? /* @__PURE__ */ jsx19(ClinicPhone, { clinicPhone }) : portalUrl ? null : /* @__PURE__ */ jsx19("p", { className: "sk-cf__aside", children: "Please contact the clinic using the details on this website." })
       ]
     }
   );
@@ -10954,14 +11479,10 @@ function PortalAccountSurfaceClient({
   portalUrl,
   bookHref,
   initialState,
-  fetchImpl: rawFetchImpl,
   openUrl
 }) {
   const portalClient = usePortalClient();
-  const fetchImpl = React21.useMemo(
-    () => portalFetchForClient(portalClient, rawFetchImpl),
-    [portalClient, rawFetchImpl]
-  );
+  const fetchImpl = React21.useMemo(() => portalFetchForClient(portalClient), [portalClient]);
   const [state, setState] = React21.useState(
     // `readPortalSignedInHint` is in the initialiser (not an effect) on purpose: the
     // whole point is that the FIRST paint already knows, so there is no placeholder