@riverbankcms/sdk 0.88.0 → 0.90.0

package/dist/client/{bookingForm-2HLRTEYS.mjs → bookingForm-STLUJ36H.mjs}

@@ -1,16 +1,15 @@
 "use client";
-import { usePolling } from './chunk-H4MHEXYS.mjs';
-import { SpinnerNode } from './chunk-6DVPO44G.mjs';
-import { useDiscountCodeUi } from './chunk-ZFHRN6W2.mjs';
+import { buildBookingPaymentSelectionViewModel, usePolling } from './chunk-4RTFGHZN.mjs';
+import { SpinnerNode } from './chunk-FHU6PFPM.mjs';
 import { buildRouteIslandApiConfig } from './chunk-L4J5Y62O.mjs';
-import { scrollToBlock, buildCheckoutReturnUrls, DiscountCodeDisclosure, formatPrice } from './chunk-X7GVFB7Y.mjs';
+import { scrollToBlock, useDiscountCodeUi, buildCheckoutReturnUrls, DiscountCodeDisclosure } from './chunk-NBFRJ5NB.mjs';
 import { FieldValidationMessage, getFieldValidationControlProps } from './chunk-3DCJ45Z2.mjs';
 import './chunk-WBQG7VJA.mjs';
-import { isSpamProtectionEnabled, getChallengeUrl, AltchaWidget } from './chunk-SDIYSQAY.mjs';
-import { BlockApiProvider, useBlockApi, FeedbackMessage } from './chunk-GOFO7HRH.mjs';
+import { isSpamProtectionEnabled, getChallengeUrl, AltchaWidget } from './chunk-HIHOQGIP.mjs';
+import { BlockApiProvider, useBlockApi, FeedbackMessage } from './chunk-WHZQDPBZ.mjs';
 import { mountReactIsland } from './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder, resolveBookingSiteId, resolveDefaultBookingServiceId, getBookingRedirectStateFromLocation, deriveBookingFormViewState, logger, getBookingSuccessMessage, resolveAppointmentCheckoutVerificationState, themeButtonClassName, toSelectedCollectionOptionKind, assertNever11, prepareBookingSubmission, formatBookingSubmissionPreparationError, resolveBookingPaymentStep, BOOKING_FORM_DATA_RESERVED_KEYS, clearWorkflowFeedback, reportWorkflowError, reportWorkflowSuccess, okWith2, err2 } from './chunk-DIRW2LNG.mjs';
-import { resolveBookingTimeZoneId, DEFAULT_BOOKING_TIME_ZONE, unsafeAsFormId, unsafeAsAppointmentResourceId, unsafeAsCustomerPassId, unsafeAsAppointmentServiceId, formatLocalScheduleDate, addLocalScheduleDays, parseBookingLocalDate, resolveFlexibleBalanceInitialPaymentCents, resolveFlexibleBalanceDueAt, getBookingInstalmentDepositRefundability, unsafeAsPassId, splitAmountWithRemainderInFirst, addIntervalPreservingMonthAnchor, clampConfiguredAmount, getBookingInstalmentPlanIntervalCount, omitZeroAmountFutureRows, formatBookingInstant } from './chunk-LI2C6M5O.mjs';
+import { defineIslandPropsDecoder, resolveBookingSiteId, resolveDefaultBookingServiceId, getBookingRedirectStateFromLocation, deriveBookingFormViewState, logger, getBookingSuccessMessage, resolveAppointmentCheckoutVerificationState, themeButtonClassName, toSelectedCollectionOptionKind, assertNever, prepareBookingSubmission, formatBookingSubmissionPreparationError, resolveBookingPaymentStep, BOOKING_FORM_DATA_RESERVED_KEYS, clearWorkflowFeedback, reportWorkflowError, reportWorkflowSuccess, okWith, err } from './chunk-6DPXDOIL.mjs';
+import { resolveBookingTimeZoneId, DEFAULT_BOOKING_TIME_ZONE, unsafeAsFormId, unsafeAsAppointmentResourceId, unsafeAsCustomerPassId, unsafeAsAppointmentServiceId, formatLocalScheduleDate, addLocalScheduleDays, parseBookingLocalDate, unsafeAsPassId, formatBookingInstant } from './chunk-25W2EQUN.mjs';
 import React2, { useRef, useState, useMemo, useReducer, useEffect, useCallback, useLayoutEffect } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
@@ -141,6 +140,74 @@ 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()
+  };
+}
+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 assertNever(action);
+  }
+}
+
 // ../blocks/src/system/runtime/hooks/useAvailableDates.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS = 5e3;
@@ -153,25 +220,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 = useRef(null);
+  const [state, dispatch] = useReducer(
+    availableDatesReducer,
+    createInitialAvailableDatesState()
+  );
   const requestIdRef = useRef(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,
@@ -181,38 +246,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 (err) {
+      } catch (err2) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err instanceof Error ? err.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: err2 instanceof Error ? err2.message : "Failed to load available dates"
+        });
       }
     },
     [api, serviceId, resourceId, timezone]
   );
   useEffect(() => {
     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();
@@ -236,8 +292,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),
@@ -245,17 +301,83 @@ 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.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 assertNever(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 assertNever(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 assertNever(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/useAvailableSlots.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS2 = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS2 = 5e3;
 function useAvailableSlots({
@@ -267,31 +389,23 @@ function useAvailableSlots({
   timezone
 }) {
   const api = useBlockApi();
-  const [slots, setSlots] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [isRefreshing, setIsRefreshing] = useState(false);
-  const [hasLoaded, setHasLoaded] = useState(false);
-  const [error, setError] = useState(null);
+  const [state, dispatch] = useReducer(
+    availableSlotsReducer,
+    initialAvailableSlotsState
+  );
   const requestIdRef = useRef(0);
   const fetchSlots = useCallback(
     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,
@@ -301,24 +415,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 (err) {
+        });
+      } catch (err2) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err instanceof Error ? err.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: err2 instanceof Error ? err2.message : "Failed to load available times"
+        });
       }
     },
     [selectedDate, serviceId, resourceId, timezone, api]
@@ -335,7 +444,13 @@ 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.state.ts
@@ -364,7 +479,7 @@ function bookingSubmissionReducer(state, action) {
     case "feedback-cleared":
       return clearWorkflowFeedback(state);
     default:
-      return assertNever11(action);
+      return assertNever(action);
   }
 }
 function selectIsSubmitting(state) {
@@ -408,7 +523,7 @@ function useBookingSubmission(_siteId) {
         type: "submission-succeeded",
         message: response.type === "checkout_redirect" ? "Redirecting to secure checkout..." : "Booking submitted successfully."
       });
-      return okWith2(response);
+      return okWith(response);
     } catch (error) {
       console.error("Booking submission error:", error);
       const message = error instanceof Error ? error.message : "Failed to book appointment";
@@ -416,7 +531,7 @@ function useBookingSubmission(_siteId) {
         type: "submission-failed",
         message
       });
-      return err2(message);
+      return err(message);
     }
   };
   return {
@@ -428,253 +543,6 @@ function useBookingSubmission(_siteId) {
   };
 }
 
-// ../blocks/src/system/runtime/shared/bookingPaymentOptionCopy.ts
-function buildUpfrontBookingPaymentOptionCopy(formattedTotal) {
-  return {
-    title: "Pay in full",
-    description: "Pay everything today and your booking is confirmed.",
-    ctaLabel: `Pay ${formattedTotal} now`
-  };
-}
-function buildDeferredManualBookingPaymentOptionCopy() {
-  return {
-    title: "Pay offline",
-    description: "Book now and pay the business later, outside the platform.",
-    helperText: "Nothing is due today.",
-    ctaLabel: "Book now"
-  };
-}
-function buildInstalmentBookingPaymentOptionCopy(input) {
-  return {
-    title: "Payment plan",
-    description: describeInstalmentPlanCopy(input),
-    helperText: "You can pay the rest early any time in your customer portal.",
-    ctaLabel: `Pay ${input.formattedDueToday} now`
-  };
-}
-function describeInstalmentPlanCopy(input) {
-  if (input.depositRefundability) {
-    return `Pay ${input.formattedDueToday} today, then continue with scheduled payments. Your deposit is ${formatDepositRefundabilityLabel(input.depositRefundability)}.`;
-  }
-  if (input.futurePaymentCount === 0) {
-    return `Pay ${input.formattedDueToday} today.`;
-  }
-  if (input.futurePaymentCount === 1) {
-    return `Pay ${input.formattedDueToday} today, then one more payment later.`;
-  }
-  const formattedFirstFuture = input.formattedFirstFuture ?? input.formattedDueToday;
-  return `Pay ${input.formattedDueToday} today, then ${input.futurePaymentCount} more ${input.cadenceLabel} payments from ${formattedFirstFuture}.`;
-}
-function buildFlexibleBalanceBookingPaymentOptionCopy(input) {
-  return {
-    title: "Deposit now, pay the rest later",
-    description: `Pay ${input.formattedDueToday} today, then pay the remaining balance any time before ${input.dueDateLabel}. Your deposit is ${formatDepositRefundabilityLabel(input.depositRefundability)}.`,
-    helperText: "You can return in your customer portal to pay the rest before the due date.",
-    ctaLabel: `Pay ${input.formattedDueToday} now`
-  };
-}
-function formatDepositRefundabilityLabel(depositRefundability) {
-  return depositRefundability === "non_refundable" ? "non-refundable" : "refundable";
-}
-
-// ../blocks/src/system/runtime/shared/bookingPaymentOptions.ts
-function buildBookingPaymentSelectionViewModel(input) {
-  const currency = input.priceCurrency ?? "USD";
-  const totalCents = Math.max(0, input.priceAmount ?? 0);
-  const allowedOptions = input.paymentTerms?.allowedOptions ?? [{ kind: "upfront" }];
-  const mode = allowedOptions.length > 1 ? "choice_required" : "single_option";
-  return {
-    mode,
-    sectionTitle: mode === "choice_required" ? "Choose how you'd like to pay" : "Payment",
-    serviceTitle: input.serviceTitle,
-    options: allowedOptions.map((option) => buildBookingPaymentOptionViewModel({
-      option,
-      totalCents,
-      currency,
-      bookingStartAt: input.bookingStartAt,
-      locale: input.locale
-    }))
-  };
-}
-function buildBookingPaymentOptionViewModel(input) {
-  switch (input.option.kind) {
-    case "upfront": {
-      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
-      const copy = buildUpfrontBookingPaymentOptionCopy(formattedTotal);
-      return {
-        kind: "upfront",
-        title: copy.title,
-        description: copy.description,
-        summaryRows: [
-          { label: "Total", value: formattedTotal },
-          { label: "Due today", value: formattedTotal }
-        ],
-        ctaLabel: copy.ctaLabel
-      };
-    }
-    case "deferred_manual": {
-      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
-      const copy = buildDeferredManualBookingPaymentOptionCopy();
-      return {
-        kind: "deferred_manual",
-        title: copy.title,
-        description: copy.description,
-        summaryRows: [
-          { label: "Total", value: formattedTotal },
-          { label: "Due today", value: formatPrice(0, input.currency, input.locale) }
-        ],
-        helperText: copy.helperText,
-        ctaLabel: copy.ctaLabel
-      };
-    }
-    case "instalment_plan": {
-      const schedulePreview = buildInstalmentSchedulePreview({
-        totalCents: input.totalCents,
-        option: input.option,
-        bookingStartAt: input.bookingStartAt
-      });
-      const dueToday = schedulePreview[0]?.amountCents ?? input.totalCents;
-      const futureRows = schedulePreview.slice(1);
-      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
-      const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
-      const depositRefundability = getBookingInstalmentDepositRefundability(input.option.plan);
-      const copy = buildInstalmentBookingPaymentOptionCopy({
-        formattedDueToday,
-        futurePaymentCount: futureRows.length,
-        formattedFirstFuture: futureRows[0] ? formatPrice(futureRows[0].amountCents, input.currency, input.locale) : null,
-        cadenceLabel: getPaymentCadenceLabel(input.option.plan),
-        depositRefundability
-      });
-      return {
-        kind: "instalment_plan",
-        title: copy.title,
-        description: copy.description,
-        summaryRows: [
-          { label: "Total", value: formattedTotal },
-          { label: "Due today", value: formattedDueToday },
-          ...depositRefundability ? [{
-            label: "Deposit policy",
-            value: depositRefundability === "non_refundable" ? "Non-refundable" : "Refundable"
-          }] : [],
-          ...futureRows.map((row) => ({
-            label: formatScheduleDate(row.dueAt, input.locale),
-            value: formatPrice(row.amountCents, input.currency, input.locale)
-          }))
-        ],
-        helperText: copy.helperText,
-        ctaLabel: copy.ctaLabel
-      };
-    }
-    case "flexible_balance": {
-      const dueToday = resolveFlexibleBalanceInitialPaymentCents({
-        totalAmountCents: input.totalCents,
-        config: input.option.config
-      });
-      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
-      const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
-      const dueAt = resolveFlexibleBalanceDueAt({
-        bookingStartAt: input.bookingStartAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-        dueDateRule: input.option.config.dueDateRule
-      });
-      const copy = buildFlexibleBalanceBookingPaymentOptionCopy({
-        formattedDueToday,
-        dueDateLabel: formatScheduleDate(dueAt, input.locale),
-        depositRefundability: input.option.config.depositRefundability
-      });
-      return {
-        kind: "flexible_balance",
-        title: copy.title,
-        description: copy.description,
-        summaryRows: [
-          { label: "Total", value: formattedTotal },
-          { label: "Due today", value: formattedDueToday },
-          { label: "Balance due by", value: formatScheduleDate(dueAt, input.locale) },
-          {
-            label: "Deposit policy",
-            value: input.option.config.depositRefundability === "non_refundable" ? "Non-refundable" : "Refundable"
-          }
-        ],
-        helperText: copy.helperText,
-        ctaLabel: copy.ctaLabel
-      };
-    }
-    default:
-      return assertNever11(input.option);
-  }
-}
-function buildInstalmentSchedulePreview(input) {
-  const startAt = input.bookingStartAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  switch (input.option.plan.kind) {
-    case "deposit_plus_one_remainder": {
-      const deposit = clampConfiguredAmount(input.option.plan.depositAmountCents, input.totalCents);
-      const remainder = Math.max(0, input.totalCents - deposit);
-      return compactSchedulePreview([
-        { dueAt: startAt, amountCents: deposit },
-        {
-          dueAt: addIntervalPreservingMonthAnchor(
-            startAt,
-            input.option.plan.remainderDueCount,
-            input.option.plan.intervalUnit
-          ),
-          amountCents: remainder
-        }
-      ]);
-    }
-    case "deposit_plus_scheduled_instalments": {
-      const plan = input.option.plan;
-      const deposit = clampConfiguredAmount(plan.depositAmountCents, input.totalCents);
-      const remaining = Math.max(0, input.totalCents - deposit);
-      const instalments = splitAmountWithRemainderInFirst(
-        remaining,
-        plan.instalmentCount
-      );
-      return compactSchedulePreview([
-        { dueAt: startAt, amountCents: deposit },
-        ...instalments.map((amountCents, index) => ({
-          dueAt: addIntervalPreservingMonthAnchor(
-            startAt,
-            plan.intervalCount * (index + 1),
-            plan.intervalUnit
-          ),
-          amountCents
-        }))
-      ]);
-    }
-    case "equal_scheduled_instalments": {
-      const plan = input.option.plan;
-      const instalments = splitAmountWithRemainderInFirst(
-        input.totalCents,
-        plan.instalmentCount
-      );
-      return compactSchedulePreview(instalments.map((amountCents, index) => ({
-        dueAt: index === 0 ? startAt : addIntervalPreservingMonthAnchor(
-          startAt,
-          plan.intervalCount * index,
-          plan.intervalUnit
-        ),
-        amountCents
-      })));
-    }
-    default:
-      return assertNever11(input.option.plan);
-  }
-}
-function getPaymentCadenceLabel(plan) {
-  const intervalCount = getBookingInstalmentPlanIntervalCount(plan);
-  const unitLabel = intervalCount === 1 ? plan.intervalUnit : `${plan.intervalUnit}s`;
-  return intervalCount === 1 ? unitLabel : `every ${intervalCount} ${unitLabel}`;
-}
-function compactSchedulePreview(schedule) {
-  return omitZeroAmountFutureRows(schedule);
-}
-function formatScheduleDate(isoString, locale) {
-  const date = new Date(isoString);
-  if (!Number.isFinite(date.getTime())) {
-    return isoString;
-  }
-  return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(date);
-}
-
 // ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
 var unsafeAsBookingFieldId = (id) => id;
 function createEmptyBookingValidationErrors() {
@@ -880,7 +748,7 @@ function bookingFlowReducer(state, event) {
     case "reset":
       return event.initial;
     default:
-      return assertNever11(event);
+      return assertNever(event);
   }
 }
 function clearAvailabilityFeedback(feedback) {
@@ -1009,7 +877,7 @@ function validateBookingStep(input) {
       return Object.keys(errors).length > 0 ? { ok: false, errors: createFieldBookingValidationErrors(errors) } : { ok: true };
     }
     default:
-      return assertNever11(input.stepId);
+      return assertNever(input.stepId);
   }
 }
 function validateBookingFields(input) {
@@ -1301,7 +1169,7 @@ function resolveAppointmentPackagesModel(input) {
       };
     }
     default:
-      return assertNever11(input.state);
+      return assertNever(input.state);
   }
 }
 function toHeadlessEligibleAppointmentPackage(appointmentPackage) {
@@ -1625,7 +1493,10 @@ function useHeadlessBookingFlow(options) {
     state.selectedDate,
     state.selectedSlot
   ]);
-  const appointmentDiscountContext = selectedService && (selectedService.priceAmount ?? 0) > 0 ? { type: "appointment", serviceId: selectedService.id } : null;
+  const appointmentDiscountContext = useMemo(
+    () => selectedService && (selectedService.priceAmount ?? 0) > 0 ? { type: "appointment", serviceId: selectedService.id } : null,
+    [selectedService?.id, selectedService?.priceAmount]
+  );
   const discountUi = useDiscountCodeUi({
     api,
     discountContext: appointmentDiscountContext,
@@ -2211,7 +2082,7 @@ function DefaultBookingStepContent({
     case "custom-fields":
       return /* @__PURE__ */ jsx(DefaultDynamicFields, { fields: booking.fields.items, booking });
     default:
-      return assertNever11(stepId);
+      return assertNever(stepId);
   }
 }
 function DefaultServiceSelectionStep({