@riverbankcms/sdk 0.89.1 → 0.90.1

package/dist/client/{carousel-3TKQSNJC.mjs → carousel-BEJKNGQ7.mjs}

@@ -1,8 +1,8 @@
-import { normalizeCarouselProps, CarouselNodeClient } from './chunk-7DH35FGA.mjs';
+import { normalizeCarouselProps, CarouselNodeClient } from './chunk-EJBHK74Y.mjs';
 import './chunk-6N7YRNYU.mjs';
 import { mountReactIsland } from './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-UQFY4AHX.mjs';
-import './chunk-25W2EQUN.mjs';
+import { defineIslandPropsDecoder } from './chunk-B4H6QMPY.mjs';
+import './chunk-3H5CLFKT.mjs';
 import { jsx } from 'react/jsx-runtime';
 
 var decode = defineIslandPropsDecoder("carousel");

package/dist/client/{cart-6XHSZK23.mjs → cart-44BBM6XG.mjs}

@@ -1,16 +1,15 @@
-import { mountShopBlockIsland, CartClient } from './chunk-ZJZZA5EP.mjs';
-import './chunk-VGLXACVK.mjs';
-import './chunk-7DH35FGA.mjs';
+import { mountShopBlockIsland, CartClient } from './chunk-4COPESPO.mjs';
+import './chunk-DQIRKNZE.mjs';
+import './chunk-EJBHK74Y.mjs';
 import './chunk-6N7YRNYU.mjs';
-import './chunk-ZFHRN6W2.mjs';
 import './chunk-L4J5Y62O.mjs';
-import './chunk-EY42X22F.mjs';
+import './chunk-SLY6UDAS.mjs';
 import './chunk-3DCJ45Z2.mjs';
 import './chunk-WBQG7VJA.mjs';
-import './chunk-STJ2NCQM.mjs';
+import './chunk-WHZQDPBZ.mjs';
 import './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-UQFY4AHX.mjs';
-import './chunk-25W2EQUN.mjs';
+import { defineIslandPropsDecoder } from './chunk-B4H6QMPY.mjs';
+import './chunk-3H5CLFKT.mjs';
 
 // src/rendering/islands/enhancers/cart.tsx
 var decode = defineIslandPropsDecoder("cart");

package/dist/client/{checkout-FVSPM6FI.mjs → checkout-THMHEYKF.mjs}

@@ -1,16 +1,15 @@
-import { mountShopBlockIsland, CheckoutClient } from './chunk-ZJZZA5EP.mjs';
-import './chunk-VGLXACVK.mjs';
-import './chunk-7DH35FGA.mjs';
+import { mountShopBlockIsland, CheckoutClient } from './chunk-4COPESPO.mjs';
+import './chunk-DQIRKNZE.mjs';
+import './chunk-EJBHK74Y.mjs';
 import './chunk-6N7YRNYU.mjs';
-import './chunk-ZFHRN6W2.mjs';
 import './chunk-L4J5Y62O.mjs';
-import './chunk-EY42X22F.mjs';
+import './chunk-SLY6UDAS.mjs';
 import './chunk-3DCJ45Z2.mjs';
 import './chunk-WBQG7VJA.mjs';
-import './chunk-STJ2NCQM.mjs';
+import './chunk-WHZQDPBZ.mjs';
 import './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-UQFY4AHX.mjs';
-import './chunk-25W2EQUN.mjs';
+import { defineIslandPropsDecoder } from './chunk-B4H6QMPY.mjs';
+import './chunk-3H5CLFKT.mjs';
 
 // src/rendering/islands/enhancers/checkout.tsx
 var decode = defineIslandPropsDecoder("checkout");

package/dist/client/{chunk-25W2EQUN.mjs → chunk-3H5CLFKT.mjs}

@@ -88,6 +88,8 @@ function publicEventPricingType(pricing) {
     case "ticket_types":
     case "course":
       return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+    case "external":
+      return "external";
   }
 }
 function publicEventPricingCurrency(pricing) {
@@ -99,6 +101,8 @@ function publicEventPricingCurrency(pricing) {
       return pricing.currency;
     case "course":
       return pricing.display.display.currency;
+    case "external":
+      return null;
   }
 }
 function publicEventScalarPrice(pricing) {
@@ -113,6 +117,7 @@ function publicEventPricingMode(pricing) {
       return "ticket_types";
     case "drop_in":
     case "course":
+    case "external":
       return void 0;
   }
 }
@@ -130,6 +135,7 @@ function isFreePublicEventPriceDisplay(display) {
     case "range":
     case "mixed":
     case "unavailable":
+    case "external":
       return false;
   }
 }
@@ -160,6 +166,8 @@ function formatBookingPriceDisplay(display, options = {}) {
       return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
     case "unavailable":
       return "Pricing unavailable";
+    case "external":
+      return display.label;
     case "course":
       return formatCoursePriceDisplayLabel(display.display, options);
     default:

package/dist/client/{chunk-ZJZZA5EP.mjs → chunk-4COPESPO.mjs}

@@ -1,14 +1,13 @@
 "use client";
-import { addPassToCommerceCart, useCommerceCart } from './chunk-VGLXACVK.mjs';
-import { CarouselNodeClient } from './chunk-7DH35FGA.mjs';
-import { useDiscountCodeUi } from './chunk-ZFHRN6W2.mjs';
+import { addPassToCommerceCart, useCommerceCart } from './chunk-DQIRKNZE.mjs';
+import { CarouselNodeClient } from './chunk-EJBHK74Y.mjs';
 import { buildRouteIslandApiConfig } from './chunk-L4J5Y62O.mjs';
-import { createBodyThemePortalRoot, consumeSearchParams, scrollToBlock, TerminalPanel, StateIcon, CheckIcon, CrossIcon, ActionRow, DiscountCodeDisclosure, consumeSearchParam, buildCheckoutReturnUrls } from './chunk-EY42X22F.mjs';
+import { useDiscountCodeUi, createBodyThemePortalRoot, consumeSearchParams, scrollToBlock, TerminalPanel, StateIcon, CheckIcon, CrossIcon, ActionRow, DiscountCodeDisclosure, consumeSearchParam, buildCheckoutReturnUrls } from './chunk-SLY6UDAS.mjs';
 import { ModalShell, resolveDedicatedCheckoutPath } from './chunk-WBQG7VJA.mjs';
-import { useBlockApi, FeedbackMessage, BlockApiProvider } from './chunk-STJ2NCQM.mjs';
+import { useBlockApi, FeedbackMessage, BlockApiProvider, discountAvailabilityHasDiscounts, discountAvailabilityAllowsManualEntry, getAutoAppliedDiscountPreview } from './chunk-WHZQDPBZ.mjs';
 import { mountReactIsland } from './chunk-N7PBWBWQ.mjs';
-import { themeButtonClassName, formatCommercePrice, formatInterval, getShopDisplayForItems, deriveCommerceCheckoutState, buildProductDetailDisplay, productItemKey, buildProductCartItem, buildProductCardDisplay, assertNever11, reportWorkflowError, clearWorkflowFeedback, unwrapRichTextRoot, createRichTextDocFromMarkdown, isRecord } from './chunk-UQFY4AHX.mjs';
-import { assertNever, ok, err, getCurrentResolveImageUrlContext, resolveImageUrlWithContext, ImagePresets } from './chunk-25W2EQUN.mjs';
+import { themeButtonClassName, formatCommercePrice, formatInterval, getShopDisplayForItems, deriveCommerceCheckoutState, buildProductDetailDisplay, productItemKey, buildProductCartItem, buildProductCardDisplay, assertNever as assertNever$1, reportWorkflowError, clearWorkflowFeedback, unwrapRichTextRoot, createRichTextDocFromMarkdown, isRecord } from './chunk-B4H6QMPY.mjs';
+import { assertNever, ok, err, getCurrentResolveImageUrlContext, resolveImageUrlWithContext, ImagePresets } from './chunk-3H5CLFKT.mjs';
 import * as React3 from 'react';
 import React3__default, { useState, useRef, useCallback, useEffect } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
@@ -443,7 +442,7 @@ function shopCheckoutReducer(state, action) {
         notice: action.notice
       };
     default:
-      return assertNever11(action);
+      return assertNever$1(action);
   }
 }
 
@@ -574,15 +573,13 @@ function planCartDiscountAvailabilityRequests(checkout) {
   }));
 }
 function aggregateCartDiscountUiState(availability) {
-  if (!availability.some((item) => item.hasDiscounts)) {
+  if (!availability.some(discountAvailabilityHasDiscounts)) {
     return { type: "unavailable" };
   }
-  if (availability.some((item) => item.manualCodeEntryAllowed)) {
+  if (availability.some(discountAvailabilityAllowsManualEntry)) {
     return { type: "manual-allowed" };
   }
-  const autoAppliedDiscount = availability.find(
-    (item) => item.autoAppliedDiscount
-  )?.autoAppliedDiscount ?? null;
+  const autoAppliedDiscount = availability.map(getAutoAppliedDiscountPreview).find((discount) => discount !== null) ?? null;
   return {
     type: "auto-only",
     autoAppliedDiscount
@@ -681,7 +678,7 @@ function discountApplyReducer(state, action) {
         status: { type: "idle" }
       };
     default:
-      return assertNever11(action);
+      return assertNever$1(action);
   }
 }
 function getAppliedDiscountCode(state) {
@@ -712,7 +709,7 @@ function getDiscountApplyFeedback(status, formatPrice) {
         message: status.message
       };
     default:
-      return assertNever11(status);
+      return assertNever$1(status);
   }
 }
 var DISCOUNT_APPLY_MESSAGES = {
@@ -1283,7 +1280,7 @@ function shopPassesMembershipsReducer(state, action) {
         returnNotice: null
       };
     default:
-      return assertNever11(action);
+      return assertNever$1(action);
   }
 }
 function getOpenCheckout(state) {

package/dist/client/chunk-5AJIMWKS.mjs

@@ -0,0 +1,436 @@
+"use client";
+import { formatPrice } from './chunk-SLY6UDAS.mjs';
+import { assertNever } from './chunk-B4H6QMPY.mjs';
+import { resolveFlexibleBalanceInitialPaymentCents, resolveFlexibleBalanceDueAt, getBookingInstalmentDepositRefundability, splitAmountWithRemainderInFirst, addIntervalPreservingMonthAnchor, clampConfiguredAmount, getBookingInstalmentPlanIntervalCount, omitZeroAmountFutureRows } from './chunk-3H5CLFKT.mjs';
+import { useReducer, useRef, useCallback, useEffect } from 'react';
+
+// ../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 remainingBalance = Math.max(0, input.totalCents - dueToday);
+      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
+      const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
+      const formattedRemainingBalance = formatPrice(remainingBalance, 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: "Remaining balance", value: formattedRemainingBalance },
+          { 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 assertNever(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 assertNever(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/hooks/usePolling.state.ts
+function createInitialPollingState() {
+  return {
+    tag: "idle",
+    result: null,
+    error: null
+  };
+}
+function pollingReducer(state, action) {
+  switch (action.type) {
+    case "polling-went-idle":
+      return createInitialPollingState();
+    case "polling-reset":
+      return {
+        tag: "polling",
+        result: null,
+        error: null
+      };
+    case "polling-progressed":
+      return {
+        tag: "polling",
+        result: action.result,
+        error: null
+      };
+    case "polling-completed":
+      return {
+        tag: "completed",
+        result: action.result,
+        error: null
+      };
+    case "polling-failed":
+      return {
+        tag: "failed",
+        result: action.result,
+        error: null
+      };
+    case "polling-request-failed":
+      switch (state.tag) {
+        case "idle":
+          return {
+            tag: "polling",
+            result: null,
+            error: action.error
+          };
+        case "polling":
+          return {
+            tag: "polling",
+            result: state.result,
+            error: action.error
+          };
+        case "completed":
+        case "failed":
+        case "timeout":
+          return state;
+        default:
+          return assertNever(state);
+      }
+    case "polling-timed-out":
+      return {
+        tag: "timeout",
+        result: state.result,
+        error: new Error("Polling timed out")
+      };
+    default:
+      return assertNever(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/usePolling.ts
+var DEFAULT_MAX_ATTEMPTS = 10;
+var DEFAULT_POLL_INTERVAL = 1e3;
+function usePolling(config) {
+  const [state, dispatch] = useReducer(
+    pollingReducer,
+    void 0,
+    createInitialPollingState
+  );
+  const attemptsRef = useRef(0);
+  const timeoutRef = useRef(null);
+  const isPollingRef = useRef(false);
+  const isActiveRef = useRef(false);
+  const generationRef = useRef(0);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const cleanup = useCallback(() => {
+    isActiveRef.current = false;
+    generationRef.current += 1;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    isPollingRef.current = false;
+  }, []);
+  const resetState = useCallback(() => {
+    dispatch({ type: "polling-reset" });
+    attemptsRef.current = 0;
+  }, []);
+  const poll = useCallback(async () => {
+    const cfg = configRef.current;
+    if (!cfg) return true;
+    if (isPollingRef.current) return false;
+    const maxAttempts = cfg.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    if (attemptsRef.current >= maxAttempts) {
+      dispatch({ type: "polling-timed-out" });
+      cleanup();
+      return true;
+    }
+    isPollingRef.current = true;
+    attemptsRef.current += 1;
+    const generation = generationRef.current;
+    try {
+      const data = await cfg.pollFn();
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (cfg.isFailed?.(data)) {
+        dispatch({ type: "polling-failed", result: data });
+        cleanup();
+        return true;
+      }
+      if (cfg.isComplete(data)) {
+        dispatch({ type: "polling-completed", result: data });
+        cleanup();
+        return true;
+      }
+      dispatch({ type: "polling-progressed", result: data });
+      isPollingRef.current = false;
+      return false;
+    } catch (err) {
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (err instanceof Error) {
+        dispatch({ type: "polling-request-failed", error: err });
+      }
+      isPollingRef.current = false;
+      return false;
+    }
+  }, [cleanup]);
+  const schedulePoll = useCallback(() => {
+    if (!isActiveRef.current) return;
+    const cfg = configRef.current;
+    const pollInterval = cfg?.interval ?? DEFAULT_POLL_INTERVAL;
+    const doPoll = async () => {
+      const shouldStop = await poll();
+      if (!shouldStop && isActiveRef.current) {
+        timeoutRef.current = setTimeout(doPoll, pollInterval);
+      }
+    };
+    void doPoll();
+  }, [poll]);
+  useEffect(() => {
+    if (!config) {
+      cleanup();
+      dispatch({ type: "polling-went-idle" });
+      return;
+    }
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+    return cleanup;
+  }, [config, cleanup, resetState, schedulePoll]);
+  const retry = useCallback(() => {
+    if (!configRef.current) return;
+    cleanup();
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+  }, [cleanup, resetState, schedulePoll]);
+  return {
+    status: config ? state.tag : "idle",
+    result: config ? state.result : null,
+    error: config ? state.error : null,
+    retry
+  };
+}
+
+export { buildBookingPaymentSelectionViewModel, usePolling };