@riverbankcms/sdk 0.88.0 → 0.89.1

package/dist/client/bookings.mjs

@@ -11950,7 +11950,7 @@ function FeedbackMessage({
 }
 
 // ../blocks/src/system/runtime/nodes/booking-form.client.tsx
-import React3, { useRef as useRef7, useState as useState5 } from "react";
+import React3, { useRef as useRef7, useState as useState3 } from "react";
 
 // ../altcha/src/AltchaWidget.tsx
 import { useEffect, useRef } from "react";
@@ -12037,9 +12037,9 @@ import React2, {
   useEffect as useEffect6,
   useLayoutEffect,
   useMemo as useMemo2,
-  useReducer as useReducer2,
+  useReducer as useReducer4,
   useRef as useRef5,
-  useState as useState4
+  useState as useState2
 } from "react";
 
 // ../../node_modules/.pnpm/altcha-lib@1.4.1/node_modules/altcha-lib/dist/helpers.js
@@ -12066,7 +12066,7 @@ function getChallengeUrl() {
 }
 
 // ../blocks/src/system/runtime/hooks/useAvailableDates.ts
-import { useState, useEffect as useEffect3, useCallback, useRef as useRef3 } from "react";
+import { useEffect as useEffect3, useCallback, useReducer, useRef as useRef3 } from "react";
 
 // ../blocks/src/utils/date-formatting.ts
 var BOOKING_FETCH_CHUNK_DAYS = 14;
@@ -12175,6 +12175,75 @@ function useVisibleTabPolling({
   }, [enabled, intervalMs, jitterMs, minVisibleRefreshIntervalMs]);
 }
 
+// ../blocks/src/system/runtime/hooks/useAvailableDates.state.ts
+function createEmptyAvailableDatesData() {
+  return {
+    availableDates: /* @__PURE__ */ new Set(),
+    hasMore: false,
+    loadedRange: null,
+    nextStartDate: null
+  };
+}
+function createInitialAvailableDatesState() {
+  return {
+    tag: "idle",
+    data: createEmptyAvailableDatesData()
+  };
+}
+var initialAvailableDatesState = createInitialAvailableDatesState();
+function getAvailableDates(state) {
+  return state.data.availableDates;
+}
+function getAvailableDatesLoadedRange(state) {
+  return state.data.loadedRange;
+}
+function getAvailableDatesNextStartDate(state) {
+  return state.data.nextStartDate;
+}
+function hasMoreAvailableDates(state) {
+  return state.data.hasMore;
+}
+function isLoadingAvailableDates(state) {
+  return state.tag === "loading";
+}
+function isRefreshingAvailableDates(state) {
+  return state.tag === "refreshing";
+}
+function getAvailableDatesError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function mergeAvailableDates(previous, action) {
+  const availableDates = action.append ? new Set(previous.availableDates) : /* @__PURE__ */ new Set();
+  for (const date of action.dates) {
+    availableDates.add(date);
+  }
+  return {
+    availableDates,
+    hasMore: action.hasMore,
+    loadedRange: {
+      start: action.append && previous.loadedRange ? previous.loadedRange.start : action.startDate,
+      end: action.endDate
+    },
+    nextStartDate: action.nextStartDate
+  };
+}
+function availableDatesReducer(state, action) {
+  switch (action.type) {
+    case "query-cleared":
+      return { tag: "idle", data: createEmptyAvailableDatesData() };
+    case "load-started":
+      return { tag: "loading", data: state.data };
+    case "refresh-started":
+      return { tag: "refreshing", data: state.data };
+    case "load-succeeded":
+      return { tag: "loaded", data: mergeAvailableDates(state.data, action) };
+    case "load-failed":
+      return { tag: "error", data: state.data, message: action.message };
+    default:
+      return assertNever11(action);
+  }
+}
+
 // ../blocks/src/system/runtime/hooks/useAvailableDates.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS = 5e3;
@@ -12187,25 +12256,23 @@ function useAvailableDates({
   initialDays = 30
 }) {
   const api = useBlockApi();
-  const [availableDates, setAvailableDates] = useState(/* @__PURE__ */ new Set());
-  const [isLoading, setIsLoading] = useState(false);
-  const [isRefreshing, setIsRefreshing] = useState(false);
-  const [error, setError] = useState(null);
-  const [hasMore, setHasMore] = useState(false);
-  const [loadedRange, setLoadedRange] = useState(null);
-  const nextStartDateRef = useRef3(null);
+  const [state, dispatch] = useReducer(
+    availableDatesReducer,
+    createInitialAvailableDatesState()
+  );
   const requestIdRef = useRef3(0);
+  const loadedRange = getAvailableDatesLoadedRange(state);
+  const isLoading = isLoadingAvailableDates(state);
+  const nextStartDate = getAvailableDatesNextStartDate(state);
   const fetchDates = useCallback(
     async (startDate, endDate, append = false, mode = "load") => {
       if (!serviceId) return;
       const requestId = ++requestIdRef.current;
       if (mode === "refresh") {
-        setIsRefreshing(true);
+        dispatch({ type: "refresh-started" });
       } else {
-        setIsLoading(true);
-        setIsRefreshing(false);
+        dispatch({ type: "load-started" });
       }
-      setError(null);
       try {
         const data = await api.getAvailableDates({
           serviceId,
@@ -12215,38 +12282,29 @@ function useAvailableDates({
           resourceId
         });
         if (requestId !== requestIdRef.current) return;
-        setAvailableDates((prev) => {
-          const newSet = append ? new Set(prev) : /* @__PURE__ */ new Set();
-          data.dates.forEach((d) => newSet.add(d));
-          return newSet;
+        dispatch({
+          type: "load-succeeded",
+          dates: data.dates,
+          hasMore: data.hasMore,
+          nextStartDate: data.nextStartDate || null,
+          startDate: data.startDate,
+          endDate: data.endDate,
+          append
         });
-        setHasMore(data.hasMore);
-        nextStartDateRef.current = data.nextStartDate || null;
-        setLoadedRange((prev) => ({
-          start: append && prev ? prev.start : data.startDate,
-          end: data.endDate
-        }));
       } catch (err3) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err3 instanceof Error ? err3.message : "Failed to load available dates"
-        );
-      } finally {
-        if (mode === "refresh" && requestId === requestIdRef.current) {
-          setIsRefreshing(false);
-        } else if (requestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
+        dispatch({
+          type: "load-failed",
+          message: err3 instanceof Error ? err3.message : "Failed to load available dates"
+        });
       }
     },
     [api, serviceId, resourceId, timezone]
   );
   useEffect3(() => {
     if (!serviceId) {
-      setAvailableDates(/* @__PURE__ */ new Set());
-      setLoadedRange(null);
-      setHasMore(false);
-      setIsRefreshing(false);
+      requestIdRef.current += 1;
+      dispatch({ type: "query-cleared" });
       return;
     }
     const now = /* @__PURE__ */ new Date();
@@ -12270,8 +12328,8 @@ function useAvailableDates({
     }
   });
   const loadMore = useCallback(() => {
-    if (!nextStartDateRef.current || isLoading) return;
-    const start = nextStartDateRef.current;
+    if (!nextStartDate || isLoading) return;
+    const start = nextStartDate;
     const end = formatLocalScheduleDate(
       addLocalScheduleDays(
         parseBookingLocalDate(start),
@@ -12279,20 +12337,86 @@ function useAvailableDates({
       )
     );
     void fetchDates(start, end, true);
-  }, [fetchDates, isLoading]);
+  }, [fetchDates, isLoading, nextStartDate]);
   return {
-    availableDates,
+    availableDates: getAvailableDates(state),
     isLoading,
-    isRefreshing,
-    error,
-    hasMore,
+    isRefreshing: isRefreshingAvailableDates(state),
+    error: getAvailableDatesError(state),
+    hasMore: hasMoreAvailableDates(state),
     loadMore,
     loadedRange
   };
 }
 
 // ../blocks/src/system/runtime/hooks/useAvailableSlots.ts
-import { useState as useState2, useCallback as useCallback2, useEffect as useEffect4, useRef as useRef4 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useReducer as useReducer2, useRef as useRef4 } from "react";
+
+// ../blocks/src/system/runtime/hooks/useAvailableSlots.state.ts
+var initialAvailableSlotsState = { tag: "idle" };
+function getAvailableSlots(state) {
+  switch (state.tag) {
+    case "idle":
+    case "loading":
+      return [];
+    case "loaded":
+    case "refreshing":
+    case "error":
+      return state.slots;
+    default:
+      return assertNever11(state);
+  }
+}
+function hasLoadedAvailableSlots(state) {
+  switch (state.tag) {
+    case "idle":
+      return false;
+    case "loading":
+    case "refreshing":
+    case "error":
+      return state.hasLoaded;
+    case "loaded":
+      return true;
+    default:
+      return assertNever11(state);
+  }
+}
+function isLoadingAvailableSlots(state) {
+  return state.tag === "loading";
+}
+function isRefreshingAvailableSlots(state) {
+  return state.tag === "refreshing";
+}
+function getAvailableSlotsError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function availableSlotsReducer(state, action) {
+  switch (action.type) {
+    case "query-cleared":
+      return { tag: "idle" };
+    case "load-started":
+      return { tag: "loading", hasLoaded: hasLoadedAvailableSlots(state) };
+    case "refresh-started":
+      return {
+        tag: "refreshing",
+        slots: getAvailableSlots(state),
+        hasLoaded: hasLoadedAvailableSlots(state)
+      };
+    case "load-succeeded":
+      return { tag: "loaded", slots: action.slots };
+    case "load-failed":
+      return {
+        tag: "error",
+        slots: getAvailableSlots(state),
+        hasLoaded: hasLoadedAvailableSlots(state),
+        message: action.message
+      };
+    default:
+      return assertNever11(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/useAvailableSlots.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS2 = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS2 = 5e3;
 function useAvailableSlots({
@@ -12304,31 +12428,23 @@ function useAvailableSlots({
   timezone
 }) {
   const api = useBlockApi();
-  const [slots, setSlots] = useState2([]);
-  const [isLoading, setIsLoading] = useState2(false);
-  const [isRefreshing, setIsRefreshing] = useState2(false);
-  const [hasLoaded, setHasLoaded] = useState2(false);
-  const [error, setError] = useState2(null);
+  const [state, dispatch] = useReducer2(
+    availableSlotsReducer,
+    initialAvailableSlotsState
+  );
   const requestIdRef = useRef4(0);
   const fetchSlots = useCallback2(
     async (mode) => {
       const requestId = ++requestIdRef.current;
       if (!selectedDate || !serviceId) {
-        setSlots([]);
-        setIsLoading(false);
-        setIsRefreshing(false);
-        setHasLoaded(false);
-        setError(null);
+        dispatch({ type: "query-cleared" });
         return;
       }
       if (mode === "refresh") {
-        setIsRefreshing(true);
+        dispatch({ type: "refresh-started" });
       } else {
-        setIsLoading(true);
-        setIsRefreshing(false);
-        setSlots([]);
+        dispatch({ type: "load-started" });
       }
-      setError(null);
       try {
         const result = await api.getAvailableSlots({
           serviceId,
@@ -12338,24 +12454,19 @@ function useAvailableSlots({
           resourceId
         });
         if (requestId !== requestIdRef.current) return;
-        setSlots(
-          result.slots.map((slot) => ({
+        dispatch({
+          type: "load-succeeded",
+          slots: result.slots.map((slot) => ({
             ...slot,
             resourceId: unsafeAsAppointmentResourceId(slot.resourceId)
           }))
-        );
-        setHasLoaded(true);
+        });
       } catch (err3) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err3 instanceof Error ? err3.message : "Failed to load available times"
-        );
-      } finally {
-        if (mode === "refresh" && requestId === requestIdRef.current) {
-          setIsRefreshing(false);
-        } else if (requestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
+        dispatch({
+          type: "load-failed",
+          message: err3 instanceof Error ? err3.message : "Failed to load available times"
+        });
       }
     },
     [selectedDate, serviceId, resourceId, timezone, api]
@@ -12372,11 +12483,17 @@ function useAvailableSlots({
     jitterMs: AVAILABILITY_REFRESH_JITTER_MS2,
     onPoll: () => fetchSlots("refresh")
   });
-  return { slots, isLoading, isRefreshing, hasLoaded, error };
+  return {
+    slots: getAvailableSlots(state),
+    isLoading: isLoadingAvailableSlots(state),
+    isRefreshing: isRefreshingAvailableSlots(state),
+    hasLoaded: hasLoadedAvailableSlots(state),
+    error: getAvailableSlotsError(state)
+  };
 }
 
 // ../blocks/src/system/runtime/hooks/useBookingSubmission.ts
-import { useReducer } from "react";
+import { useReducer as useReducer3 } from "react";
 
 // ../blocks/src/system/runtime/hooks/useBookingSubmission.state.ts
 var initialBookingSubmissionState = {
@@ -12414,7 +12531,7 @@ function selectIsSubmitting(state) {
 // ../blocks/src/system/runtime/hooks/useBookingSubmission.ts
 function useBookingSubmission(_siteId) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer(
+  const [state, dispatch] = useReducer3(
     bookingSubmissionReducer,
     initialBookingSubmissionState
   );
@@ -12469,14 +12586,14 @@ function useBookingSubmission(_siteId) {
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.ts
-import { useEffect as useEffect5, useState as useState3 } from "react";
+import { useEffect as useEffect5, useState } from "react";
 function useDiscountCodeUi(options) {
-  const [discountUiOpen, setDiscountUiOpen] = useState3(false);
-  const [discountCode, setDiscountCode] = useState3("");
-  const [discountsAvailable, setDiscountsAvailable] = useState3(false);
-  const [manualCodeEntryAllowed, setManualCodeEntryAllowed] = useState3(false);
-  const [autoAppliedDiscount, setAutoAppliedDiscount] = useState3(null);
-  const [discountsAvailableLoading, setDiscountsAvailableLoading] = useState3(false);
+  const [discountUiOpen, setDiscountUiOpen] = useState(false);
+  const [discountCode, setDiscountCode] = useState("");
+  const [discountsAvailable, setDiscountsAvailable] = useState(false);
+  const [manualCodeEntryAllowed, setManualCodeEntryAllowed] = useState(false);
+  const [autoAppliedDiscount, setAutoAppliedDiscount] = useState(null);
+  const [discountsAvailableLoading, setDiscountsAvailableLoading] = useState(false);
   useEffect5(() => {
     let cancelled = false;
     async function checkDiscountAvailability() {
@@ -13589,11 +13706,11 @@ function useHeadlessBookingFlow(options) {
     }),
     [defaultResourceId, defaultServiceId, options.initialData]
   );
-  const [state, dispatch] = useReducer2(bookingFlowReducer, initialState);
+  const [state, dispatch] = useReducer4(bookingFlowReducer, initialState);
   const api = useBlockApi();
-  const [resourcesState, setResourcesState] = useState4({ tag: "idle" });
+  const [resourcesState, setResourcesState] = useState2({ tag: "idle" });
   const resourcesRequestIdRef = useRef5(0);
-  const [appointmentPackages, setAppointmentPackages] = useState4({ tag: "idle" });
+  const [appointmentPackages, setAppointmentPackages] = useState2({ tag: "idle" });
   const appointmentPackagesRequestIdRef = useRef5(0);
   const selectedServiceId = state.selectedServiceId ?? defaultServiceId;
   const selectedResourceId = state.selectedResourceId ?? defaultResourceId;
@@ -14166,7 +14283,7 @@ function useLatestRef(value) {
 import { useMemo as useMemo3 } from "react";
 
 // ../blocks/src/system/runtime/hooks/usePolling.ts
-import { useEffect as useEffect7, useCallback as useCallback4, useReducer as useReducer3, useRef as useRef6 } from "react";
+import { useEffect as useEffect7, useCallback as useCallback4, useReducer as useReducer5, useRef as useRef6 } from "react";
 
 // ../blocks/src/system/runtime/hooks/usePolling.state.ts
 function createInitialPollingState() {
@@ -14240,7 +14357,7 @@ function pollingReducer(state, action) {
 var DEFAULT_MAX_ATTEMPTS = 10;
 var DEFAULT_POLL_INTERVAL = 1e3;
 function usePolling(config) {
-  const [state, dispatch] = useReducer3(
+  const [state, dispatch] = useReducer5(
     pollingReducer,
     void 0,
     createInitialPollingState
@@ -15467,7 +15584,7 @@ var BookingFormClient = ({
   const initialResourceId = render.hydration.resourceId ?? void 0;
   const isPortalRebook = render.hydration.rebookContext?.kind === "portal_rebook";
   const hasLoggedRebookCompletionRef = useRef7(false);
-  const [redirectState] = useState5(
+  const [redirectState] = useState3(
     () => getBookingRedirectStateFromLocation(getBookingRedirectLocationSnapshot())
   );
   const showSpamProtection = render.hydration.spamProtectionEnabled ?? isSpamProtectionEnabled();
@@ -16117,7 +16234,7 @@ function findSelectedTicketType(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
-import { useState as useState6, useEffect as useEffect8, useCallback as useCallback5, useRef as useRef8, useReducer as useReducer4 } from "react";
+import { useState as useState4, useEffect as useEffect8, useCallback as useCallback5, useRef as useRef8, useReducer as useReducer6 } from "react";
 
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.state.ts
 var initialEligibilityLookupState = {
@@ -16177,8 +16294,8 @@ function existingRegistrationLookupReducer(state, action) {
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
 function usePortalAuth() {
   const api = useBlockApi();
-  const [authState, setAuthState] = useState6("checking");
-  const [profile, setProfile] = useState6(null);
+  const [authState, setAuthState] = useState4("checking");
+  const [profile, setProfile] = useState4(null);
   useEffect8(() => {
     let cancelled = false;
     async function checkPortalAuth() {
@@ -16225,7 +16342,7 @@ function usePortalAuth() {
 }
 function useEligibility(params) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer4(
+  const [state, dispatch] = useReducer6(
     eligibilityLookupReducer,
     initialEligibilityLookupState
   );
@@ -16284,7 +16401,7 @@ function useExistingEventRegistration({
   occurrenceId
 }) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer4(
+  const [state, dispatch] = useReducer6(
     existingRegistrationLookupReducer,
     initialExistingRegistrationLookupState
   );
@@ -16491,7 +16608,7 @@ function cleanupStaleRegistrations() {
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.ts
-import { useCallback as useCallback6, useEffect as useEffect11, useMemo as useMemo6, useReducer as useReducer5, useState as useState8 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect11, useMemo as useMemo6, useReducer as useReducer8, useState as useState5 } from "react";
 
 // ../blocks/src/system/runtime/nodes/event-registration/validation.ts
 function validateFormData2(formData) {
@@ -16508,7 +16625,55 @@ function validateFormData2(formData) {
 }
 
 // ../blocks/src/system/runtime/shared/useWaitlistClaim.ts
-import { useEffect as useEffect9, useState as useState7, useSyncExternalStore } from "react";
+import { useEffect as useEffect9, useReducer as useReducer7, useSyncExternalStore } from "react";
+
+// ../blocks/src/system/runtime/shared/useWaitlistClaim.state.ts
+var DEFAULT_WAITLIST_CLAIM_ERROR = "Failed to resolve waitlist claim";
+function createInitialWaitlistClaimState(hasToken) {
+  return hasToken ? { kind: "resolving" } : { kind: "idle" };
+}
+function waitlistClaimReducer(_state, action) {
+  switch (action.type) {
+    case "cleared":
+      return { kind: "idle" };
+    case "started":
+      return { kind: "resolving" };
+    case "resolved":
+      return { kind: "resolved", claim: action.claim };
+    case "failed":
+      return action.failure;
+  }
+}
+function toWaitlistClaimResolveFailure(error) {
+  const message = error instanceof Error ? error.message : DEFAULT_WAITLIST_CLAIM_ERROR;
+  if (isUnauthorizedBlockApiError(error)) {
+    return { kind: "portal-login-required", message };
+  }
+  return { kind: "error", message };
+}
+function isUnauthorizedBlockApiError(error) {
+  return error instanceof Error && error.name === "BlockApiError" && hasStatus(error) && error.status === 401;
+}
+function hasStatus(value) {
+  return typeof value === "object" && value !== null && "status" in value;
+}
+function getWaitlistClaim(state) {
+  return state.kind === "resolved" ? state.claim : null;
+}
+function getWaitlistClaimError(state) {
+  return state.kind === "error" ? state.message : null;
+}
+function getWaitlistClaimLoginMessage(state) {
+  return state.kind === "portal-login-required" ? state.message : null;
+}
+function requiresWaitlistClaimPortalLogin(state) {
+  return state.kind === "portal-login-required";
+}
+function isWaitlistClaimLoading(state) {
+  return state.kind === "resolving";
+}
+
+// ../blocks/src/system/runtime/shared/useWaitlistClaim.ts
 var WAITLIST_CLAIM_LOCATION_EVENT = "riverbank:waitlist-claim-location-change";
 var historyPatched = false;
 function emitWaitlistClaimLocationChange() {
@@ -16566,46 +16731,29 @@ function useWaitlistClaim() {
     getWaitlistClaimTokenSnapshot,
     () => null
   );
-  const [claim, setClaim] = useState7(null);
-  const [error, setError] = useState7(null);
-  const [loginMessage, setLoginMessage] = useState7(null);
-  const [requiresPortalLogin, setRequiresPortalLogin] = useState7(false);
-  const [isLoading, setIsLoading] = useState7(() => Boolean(token));
+  const [state, dispatch] = useReducer7(
+    waitlistClaimReducer,
+    Boolean(token),
+    createInitialWaitlistClaimState
+  );
   useEffect9(() => {
     let cancelled = false;
     async function resolveClaim() {
       if (!token) {
-        setClaim(null);
-        setError(null);
-        setLoginMessage(null);
-        setRequiresPortalLogin(false);
-        setIsLoading(false);
+        dispatch({ type: "cleared" });
         return;
       }
-      setIsLoading(true);
-      setClaim(null);
-      setError(null);
-      setLoginMessage(null);
-      setRequiresPortalLogin(false);
+      dispatch({ type: "started" });
       try {
         const result = await api.resolveWaitlistClaim({ claimToken: token });
         if (cancelled) return;
-        setClaim(result);
+        dispatch({ type: "resolved", claim: result });
       } catch (claimError) {
         if (cancelled) return;
-        const message = claimError instanceof Error ? claimError.message : "Failed to resolve waitlist claim";
-        setClaim(null);
-        if (claimError instanceof BlockApiError && claimError.status === 401) {
-          setRequiresPortalLogin(true);
-          setLoginMessage(message);
-          setError(null);
-        } else {
-          setError(message);
-        }
-      } finally {
-        if (!cancelled) {
-          setIsLoading(false);
-        }
+        dispatch({
+          type: "failed",
+          failure: toWaitlistClaimResolveFailure(claimError)
+        });
       }
     }
     void resolveClaim();
@@ -16615,11 +16763,11 @@ function useWaitlistClaim() {
   }, [api, token]);
   return {
     token,
-    claim,
-    error,
-    loginMessage,
-    requiresPortalLogin,
-    isLoading
+    claim: getWaitlistClaim(state),
+    error: getWaitlistClaimError(state),
+    loginMessage: getWaitlistClaimLoginMessage(state),
+    requiresPortalLogin: requiresWaitlistClaimPortalLogin(state),
+    isLoading: isWaitlistClaimLoading(state)
   };
 }
 
@@ -16907,7 +17055,7 @@ function useEventRegistrationWizard(options) {
     [scopedEvents, options.occurrenceContext]
   );
   const hasPreSelectedContext = !!(options.occurrenceContext || preSelectedEvent);
-  const [flowState, dispatchFlow] = useReducer5(
+  const [flowState, dispatchFlow] = useReducer8(
     registrationFlowReducer,
     hasPreSelectedContext,
     createInitialRegistrationFlowState
@@ -16915,24 +17063,24 @@ function useEventRegistrationWizard(options) {
   const step = flowState.step;
   const ticketsCount = flowState.ticketsCount;
   const paymentSelection = flowState.paymentSelection;
-  const [selectedEvent, setSelectedEvent] = useState8(preSelectedEvent ?? null);
-  const [formData, setFormData] = useState8({ name: "", email: "", phone: "", notes: "" });
-  const [errors, setErrors] = useState8({});
-  const [guests, setGuests] = useState8([]);
-  const [guestErrors, setGuestErrors] = useState8({});
-  const [guestSectionShake, setGuestSectionShake] = useState8(false);
-  const [selectedAttendanceMode, setSelectedAttendanceMode] = useState8(
+  const [selectedEvent, setSelectedEvent] = useState5(preSelectedEvent ?? null);
+  const [formData, setFormData] = useState5({ name: "", email: "", phone: "", notes: "" });
+  const [errors, setErrors] = useState5({});
+  const [guests, setGuests] = useState5([]);
+  const [guestErrors, setGuestErrors] = useState5({});
+  const [guestSectionShake, setGuestSectionShake] = useState5(false);
+  const [selectedAttendanceMode, setSelectedAttendanceMode] = useState5(
     preSelectedEvent?.deliveryMode === "online" ? "online" : preSelectedEvent?.deliveryMode === "in_person" ? "in_person" : null
   );
-  const [selectedTicketTypeId, setSelectedTicketTypeId] = useState8(null);
-  const [registrationResult, setRegistrationResult] = useState8(null);
-  const [errorMessage, setErrorMessage] = useState8("");
-  const [altchaSolution, setAltchaSolution] = useState8(null);
+  const [selectedTicketTypeId, setSelectedTicketTypeId] = useState5(null);
+  const [registrationResult, setRegistrationResult] = useState5(null);
+  const [errorMessage, setErrorMessage] = useState5("");
+  const [altchaSolution, setAltchaSolution] = useState5(null);
   const { authState: portalAuthState, profile: portalProfile } = usePortalAuth();
   const waitlistClaim = useWaitlistClaim();
-  const [showMagicLinkModal, setShowMagicLinkModal] = useState8(false);
-  const [pendingAttendeeId, setPendingAttendeeId] = useState8(null);
-  const [paymentStepState, setPaymentStepState] = useState8({
+  const [showMagicLinkModal, setShowMagicLinkModal] = useState5(false);
+  const [pendingAttendeeId, setPendingAttendeeId] = useState5(null);
+  const [paymentStepState, setPaymentStepState] = useState5({
     status: "loading",
     canContinue: false,
     buttonText: "Continue",
@@ -18406,63 +18554,140 @@ function resolvePaymentModel(wizard) {
 }
 
 // ../blocks/src/system/runtime/hooks/useBookingFormConfig.ts
-import { useState as useState9, useEffect as useEffect12 } from "react";
+import { useEffect as useEffect12, useReducer as useReducer9 } from "react";
+
+// ../blocks/src/system/runtime/hooks/useBookingFormConfig.state.ts
+var EMPTY_SNAPSHOT = Object.freeze({
+  formConfig: null,
+  services: []
+});
+function createInitialBookingFormConfigState() {
+  return {
+    tag: "loading",
+    previous: EMPTY_SNAPSHOT
+  };
+}
+function bookingFormConfigReducer(state, action) {
+  switch (action.type) {
+    case "load-started":
+      return {
+        tag: "loading",
+        previous: toBookingFormConfigSnapshot(state)
+      };
+    case "form-loaded": {
+      const previous = toBookingFormConfigSnapshot(state);
+      return {
+        tag: "loading",
+        previous: {
+          formConfig: action.formConfig,
+          services: previous.formConfig?.id === action.formConfig.id ? previous.services : []
+        }
+      };
+    }
+    case "load-succeeded":
+      return {
+        tag: "loaded",
+        formConfig: action.formConfig,
+        services: action.services
+      };
+    case "services-load-failed": {
+      const previous = toBookingFormConfigSnapshot(state);
+      return previous.formConfig ? {
+        tag: "loaded",
+        formConfig: previous.formConfig,
+        services: previous.services
+      } : {
+        tag: "error",
+        message: action.message,
+        previous
+      };
+    }
+    case "load-failed":
+      return {
+        tag: "error",
+        message: action.message,
+        previous: toBookingFormConfigSnapshot(state)
+      };
+    default:
+      return assertNever11(action);
+  }
+}
+function selectBookingFormConfig(state) {
+  return toBookingFormConfigSnapshot(state).formConfig;
+}
+function selectBookingFormServices(state) {
+  return toBookingFormConfigSnapshot(state).services;
+}
+function selectBookingFormConfigIsLoading(state) {
+  return state.tag === "loading";
+}
+function selectBookingFormConfigError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function toBookingFormConfigSnapshot(state) {
+  switch (state.tag) {
+    case "loading":
+    case "error":
+      return state.previous;
+    case "loaded":
+      return {
+        formConfig: state.formConfig,
+        services: state.services
+      };
+    default:
+      return assertNever11(state);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/useBookingFormConfig.ts
 function useBookingFormConfig(siteId, formId) {
   const api = useBlockApi();
-  const [formConfig, setFormConfig] = useState9(null);
-  const [services, setServices] = useState9([]);
-  const [isLoading, setIsLoading] = useState9(true);
-  const [error, setError] = useState9(null);
+  const [state, dispatch] = useReducer9(
+    bookingFormConfigReducer,
+    void 0,
+    createInitialBookingFormConfigState
+  );
+  const formConfig = selectBookingFormConfig(state);
+  const services = selectBookingFormServices(state);
   useEffect12(() => {
     let mounted = true;
     async function loadFormAndServices() {
+      dispatch({ type: "load-started" });
       try {
-        setIsLoading(true);
-        setError(null);
         const formResponse = await api.getForm(formId, siteId);
         if (!mounted) return;
-        const rawData = formResponse.form;
-        const normalizedForm = {
-          id: rawData.id,
-          name: rawData.name,
-          slug: rawData.slug,
-          settings: rawData.settingsJson ?? rawData.settings,
-          schema: rawData.schemaJson ?? rawData.schema
-        };
-        setFormConfig(normalizedForm);
-        if (!normalizedForm.settings?.serviceId && !normalizedForm.settings?.serviceIds) {
-          try {
-            const servicesData = await api.getBookingServices();
-            if (mounted) {
-              setServices(servicesData.services || []);
-            }
-          } catch {
-          }
-        } else if (normalizedForm.settings?.serviceIds && normalizedForm.settings.serviceIds.length > 0) {
-          try {
-            const servicesData = await api.getBookingServices({ ids: normalizedForm.settings.serviceIds });
-            if (mounted) {
-              setServices(servicesData.services || []);
-            }
-          } catch {
-          }
-        } else if (normalizedForm.settings?.serviceId) {
-          try {
-            const serviceData = await api.getBookingService(normalizedForm.settings.serviceId);
-            if (mounted) {
-              setServices([serviceData.service]);
-            }
-          } catch {
+        const normalizedForm = normalizeBookingFormConfig(formResponse.form);
+        if (!normalizedForm) {
+          throw new Error("Invalid booking form response.");
+        }
+        dispatch({
+          type: "form-loaded",
+          formConfig: normalizedForm
+        });
+        try {
+          const services2 = await loadBookingFormServices(api, normalizedForm);
+          if (!mounted) return;
+          dispatch({
+            type: "load-succeeded",
+            formConfig: normalizedForm,
+            services: services2
+          });
+        } catch (err3) {
+          console.warn("Failed to load booking form services:", err3);
+          if (mounted) {
+            dispatch({
+              type: "services-load-failed",
+              message: "Failed to load booking services."
+            });
           }
         }
       } catch (err3) {
         console.error("Failed to load form:", err3);
         if (mounted) {
-          setError("Failed to load booking form. Please try again later.");
-        }
-      } finally {
-        if (mounted) {
-          setIsLoading(false);
+          dispatch({
+            type: "load-failed",
+            message: "Failed to load booking form. Please try again later."
+          });
         }
       }
     }
@@ -18471,7 +18696,27 @@ function useBookingFormConfig(siteId, formId) {
       mounted = false;
     };
   }, [siteId, formId, api]);
-  return { formConfig, services, isLoading, error };
+  return {
+    formConfig,
+    services,
+    isLoading: selectBookingFormConfigIsLoading(state),
+    error: selectBookingFormConfigError(state)
+  };
+}
+async function loadBookingFormServices(api, formConfig) {
+  if (!formConfig.settings?.serviceId && !formConfig.settings?.serviceIds) {
+    const servicesData = await api.getBookingServices();
+    return normalizeBookingServices(servicesData.services);
+  }
+  if (formConfig.settings?.serviceIds && formConfig.settings.serviceIds.length > 0) {
+    const servicesData = await api.getBookingServices({ ids: [...formConfig.settings.serviceIds] });
+    return normalizeBookingServices(servicesData.services);
+  }
+  if (formConfig.settings?.serviceId) {
+    const serviceData = await api.getBookingService(formConfig.settings.serviceId);
+    return normalizeBookingServices([serviceData.service]);
+  }
+  return [];
 }
 
 // src/bookings/index.ts