@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/client/{BookingMailingListNote-1n4Ch_u_.mjs → BookingMailingListNote-Cr3EeTP5.mjs}

@@ -1,9 +1,10 @@
 "use client";
-import { Vt as assertNever$2, bn as formatCurrencyAmount } from "./propsDecoder-CwvvNOHx.mjs";
-import { i as CheckIcon } from "./TerminalPanel-B5ZUsYhe.mjs";
+import { Cn as formatCurrencyAmount, Wt as assertNever$3, wn as parseCurrencyCode } from "./propsDecoder-DZd6RJeA.mjs";
+import { i as CheckIcon } from "./TerminalPanel-JjmgxEsR.mjs";
 import { n as getBookingMailingListNoteCopy } from "./mailingListSignupCopy-DZSHZrm6.mjs";
-import { n as RichText } from "./checkoutUrls-BEfR7kVu.mjs";
-import { useCallback, useEffect, useReducer, useRef } from "react";
+import { n as RichText } from "./checkoutUrls-CXhko2Rv.mjs";
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+import { z } from "zod";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region ../core/src/date-math.ts
 function addDaysToDate(date, dayCount) {
@@ -20,6 +21,18 @@ function subtractDaysFromIso(isoString, dayCount) {
 	return addDaysToIso(isoString, -dayCount);
 }
 //#endregion
+//#region ../core/src/money-input.ts
+function unsafeAsNonNegativeCents(value) {
+	return value;
+}
+/**
+* Normalizes a derived amount to non-negative whole cents. This intentionally
+* clamps negatives to zero; use parseNonNegativeCents for validation.
+*/
+function toNonNegativeCents(value) {
+	return unsafeAsNonNegativeCents(Math.max(0, Math.trunc(value)));
+}
+//#endregion
 //#region ../core/src/booking-flexible-balance.ts
 function clampFlexibleBalanceConfiguredAmount(amountCents, totalAmountCents) {
 	return Math.max(0, Math.min(amountCents, totalAmountCents));
@@ -31,10 +44,10 @@ function resolveFlexibleBalanceDueAt(input) {
 	switch (input.dueDateRule.kind) {
 		case "relative_to_start_date": return subtractDaysFromIso(input.bookingStartAt, input.dueDateRule.daysBeforeStart);
 		case "fixed_calendar_date": return input.dueDateRule.dueAt;
-		default: return assertNever$1(input.dueDateRule);
+		default: return assertNever$2(input.dueDateRule);
 	}
 }
-function assertNever$1(value) {
+function assertNever$2(value) {
 	throw new Error(`Unexpected value: ${String(value)}`);
 }
 //#endregion
@@ -44,7 +57,7 @@ function isDepositBearingBookingInstalmentPlan(plan) {
 		case "deposit_plus_one_remainder":
 		case "deposit_plus_scheduled_instalments": return true;
 		case "equal_scheduled_instalments": return false;
-		default: return assertNever(plan);
+		default: return assertNever$1(plan);
 	}
 }
 function getBookingInstalmentDepositRefundability(plan) {
@@ -70,7 +83,7 @@ function addIntervalPreservingMonthAnchor(isoString, intervalCount, intervalUnit
 			date.setUTCDate(date.getUTCDate() + intervalCount * 7);
 			return date.toISOString();
 		case "month": return addMonthsPreservingAnchorDay(date, intervalCount).toISOString();
-		default: return assertNever(intervalUnit);
+		default: return assertNever$1(intervalUnit);
 	}
 }
 function getBookingInstalmentPlanIntervalCount(plan) {
@@ -78,7 +91,7 @@ function getBookingInstalmentPlanIntervalCount(plan) {
 		case "deposit_plus_one_remainder": return plan.remainderDueCount;
 		case "deposit_plus_scheduled_instalments":
 		case "equal_scheduled_instalments": return plan.intervalCount;
-		default: return assertNever(plan);
+		default: return assertNever$1(plan);
 	}
 }
 function omitZeroAmountFutureRows(rows) {
@@ -94,10 +107,380 @@ function addMonthsPreservingAnchorDay(date, intervalCount) {
 	nextMonth.setUTCDate(Math.min(anchorDay, lastDayOfTargetMonth));
 	return nextMonth;
 }
-function assertNever(value) {
+function assertNever$1(value) {
+	throw new Error(`Unexpected value: ${String(value)}`);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/hooks/useBookingNowIso.ts
+/**
+* The moment a booking or registration flow opened, as an ISO timestamp.
+*
+* Payment previews take this as their "now" so the pure view-model builders
+* never read the clock themselves. It's captured once per mount, which keeps
+* memoised previews stable across renders.
+*/
+function useBookingNowIso() {
+	const [nowIso] = useState(() => (/* @__PURE__ */ new Date()).toISOString());
+	return nowIso;
+}
+//#endregion
+//#region ../commerce/src/utils/assertNever.ts
+function assertNever(value, message) {
+	if (message) throw new Error(message);
 	throw new Error(`Unexpected value: ${String(value)}`);
 }
 //#endregion
+//#region ../commerce/src/purchase/bookingInstalmentSchedule.ts
+function resolveBookingInitialInstalmentAmountCents(input) {
+	const totalAmountCents = Math.max(0, input.totalAmountCents);
+	switch (input.plan.kind) {
+		case "deposit_plus_one_remainder":
+		case "deposit_plus_scheduled_instalments": return clampConfiguredAmount(input.plan.depositAmountCents, totalAmountCents);
+		case "equal_scheduled_instalments": return splitAmountWithRemainderInFirst(totalAmountCents, input.plan.instalmentCount)[0] ?? 0;
+		default: return assertNever(input.plan);
+	}
+}
+function buildBookingInstalmentSchedule(input) {
+	const totalAmountCents = Math.max(0, input.totalAmountCents);
+	switch (input.plan.kind) {
+		case "deposit_plus_one_remainder": {
+			const depositAmountCents = resolveBookingInitialInstalmentAmountCents(input);
+			const remainderAmountCents = Math.max(0, totalAmountCents - depositAmountCents);
+			return omitZeroAmountFutureRows([createScheduleRow({
+				sequence: 1,
+				stateAtBooking: "paid_today",
+				dueAt: input.anchorAt,
+				amountCents: depositAmountCents
+			}), createScheduleRow({
+				sequence: 2,
+				stateAtBooking: "scheduled",
+				dueAt: addIntervalPreservingMonthAnchor(input.anchorAt, input.plan.remainderDueCount, input.plan.intervalUnit),
+				amountCents: remainderAmountCents
+			})]);
+		}
+		case "deposit_plus_scheduled_instalments": {
+			const plan = input.plan;
+			const depositAmountCents = resolveBookingInitialInstalmentAmountCents(input);
+			const instalmentAmounts = splitAmountWithRemainderInFirst(Math.max(0, totalAmountCents - depositAmountCents), plan.instalmentCount);
+			return omitZeroAmountFutureRows([createScheduleRow({
+				sequence: 1,
+				stateAtBooking: "paid_today",
+				dueAt: input.anchorAt,
+				amountCents: depositAmountCents
+			}), ...instalmentAmounts.map((amountCents, index) => createScheduleRow({
+				sequence: index + 2,
+				stateAtBooking: "scheduled",
+				dueAt: addIntervalPreservingMonthAnchor(input.anchorAt, plan.intervalCount * (index + 1), plan.intervalUnit),
+				amountCents
+			}))]);
+		}
+		case "equal_scheduled_instalments": {
+			const plan = input.plan;
+			return omitZeroAmountFutureRows(splitAmountWithRemainderInFirst(totalAmountCents, plan.instalmentCount).map((amountCents, index) => createScheduleRow({
+				sequence: index + 1,
+				stateAtBooking: index === 0 ? "paid_today" : "scheduled",
+				dueAt: index === 0 ? input.anchorAt : addIntervalPreservingMonthAnchor(input.anchorAt, plan.intervalCount * index, plan.intervalUnit),
+				amountCents
+			})));
+		}
+		default: return assertNever(input.plan);
+	}
+}
+function createScheduleRow(input) {
+	return {
+		id: `payment-${input.sequence}`,
+		sequence: input.sequence,
+		stateAtBooking: input.stateAtBooking,
+		dueAt: input.dueAt,
+		amountCents: input.amountCents
+	};
+}
+//#endregion
+//#region ../commerce/src/purchase/checkoutPaymentFlow.ts
+function planCheckoutPaymentFlow(options) {
+	const amountDueCents = toNonNegativeCents(options.amountDueCents);
+	const discountCents = toNonNegativeCents(options.discountCents);
+	const availableCreditCents = toNonNegativeCents(options.availableCreditCents);
+	const minimumStripeChargeCents = toNonNegativeCents(options.minimumStripeChargeCents ?? 0);
+	if (amountDueCents <= 0) return {
+		kind: "bypass",
+		bypassReason: discountCents > 0 ? "discount_free" : "free",
+		reserveCreditCents: 0
+	};
+	if (!options.creditCurrencyMatches || availableCreditCents <= 0) return {
+		kind: "stripe",
+		reserveCreditCents: toNonNegativeCents(0)
+	};
+	if (availableCreditCents >= amountDueCents) return {
+		kind: "store_credit_only",
+		reserveCreditCents: amountDueCents
+	};
+	return {
+		kind: "stripe",
+		reserveCreditCents: planMixedPaymentCreditReservation({
+			amountDueCents,
+			availableCreditCents,
+			minimumStripeChargeCents
+		})
+	};
+}
+function planMixedPaymentCreditReservation(input) {
+	const chargeAfterFullCredit = input.amountDueCents - input.availableCreditCents;
+	if (input.minimumStripeChargeCents <= 0 || chargeAfterFullCredit <= 0 || chargeAfterFullCredit >= input.minimumStripeChargeCents) return input.availableCreditCents;
+	if (input.amountDueCents < input.minimumStripeChargeCents) return toNonNegativeCents(0);
+	return toNonNegativeCents(input.amountDueCents - input.minimumStripeChargeCents);
+}
+/**
+* Apply site credit to a flexible-balance booking before card payment.
+*
+* Credit first reduces the configured payment due now. Once that payment is
+* covered, any remaining credit reduces the later balance. If a partial credit
+* application would leave a positive card charge below Stripe's minimum, less
+* credit is used so the configured payment can still be collected.
+*/
+function planFlexibleBalanceCreditFirst(input) {
+	const totalCents = toNonNegativeCents(input.totalAfterDiscountCents);
+	const configuredDueNowCents = toNonNegativeCents(Math.min(input.configuredPaymentDueNowCents, totalCents));
+	const availableCreditCents = toNonNegativeCents(input.creditCurrencyMatches ? input.availableCreditCents : 0);
+	const minimumStripeChargeCents = toNonNegativeCents(input.minimumStripeChargeCents ?? 0);
+	if (availableCreditCents >= totalCents && totalCents > 0) return {
+		kind: "credit_only",
+		reserveCreditCents: totalCents,
+		cardDueNowCents: toNonNegativeCents(0),
+		laterBalanceCents: toNonNegativeCents(0)
+	};
+	let reserveCreditCents = toNonNegativeCents(Math.min(availableCreditCents, totalCents));
+	if (reserveCreditCents >= configuredDueNowCents) return {
+		kind: "flexible_balance",
+		reserveCreditCents,
+		cardDueNowCents: toNonNegativeCents(0),
+		laterBalanceCents: toNonNegativeCents(totalCents - reserveCreditCents)
+	};
+	const plannedCardDueNowCents = toNonNegativeCents(configuredDueNowCents - reserveCreditCents);
+	if (plannedCardDueNowCents > 0 && plannedCardDueNowCents < minimumStripeChargeCents) {
+		if (configuredDueNowCents < minimumStripeChargeCents) return {
+			kind: "card_below_minimum",
+			reserveCreditCents: toNonNegativeCents(0),
+			cardDueNowCents: configuredDueNowCents,
+			laterBalanceCents: toNonNegativeCents(totalCents - configuredDueNowCents)
+		};
+		reserveCreditCents = toNonNegativeCents(configuredDueNowCents - minimumStripeChargeCents);
+	}
+	const cardDueNowCents = toNonNegativeCents(configuredDueNowCents - reserveCreditCents);
+	return {
+		kind: "flexible_balance",
+		reserveCreditCents,
+		cardDueNowCents,
+		laterBalanceCents: toNonNegativeCents(totalCents - reserveCreditCents - cardDueNowCents)
+	};
+}
+//#endregion
+//#region ../commerce/src/purchase/settlement.ts
+function normalizeCurrencyCode(raw) {
+	const normalized = raw.trim().toUpperCase();
+	if (!/^[A-Z]{3}$/.test(normalized)) throw new Error(`Invalid currency code: ${raw}`);
+	return normalized;
+}
+//#endregion
+//#region ../commerce/src/purchase/checkoutSessionMetadata.ts
+const datedOfferingSharedEngineMetadataShape = {
+	datedOfferingEngineContractVersion: z.literal("shared_v1"),
+	datedOfferingEngineRouteKind: z.literal("shared_whole_series_registration"),
+	datedOfferingCapacityHoldId: z.string().uuid(),
+	datedOfferingCapacityHoldAuditRef: z.string().uuid(),
+	customerId: z.string().uuid(),
+	eventSeriesId: z.string().uuid()
+};
+z.object(datedOfferingSharedEngineMetadataShape);
+const orderCheckoutSessionMetadataBaseShape = {
+	type: z.literal("order"),
+	site_id: z.string().uuid(),
+	order_id: z.string().uuid().optional(),
+	customer_email: z.string().email().optional(),
+	customer_name: z.string().optional(),
+	product_id: z.string().uuid().optional(),
+	attendee_id: z.string().uuid().optional(),
+	occurrence_id: z.string().uuid().optional(),
+	tickets_count: z.string().optional(),
+	notes: z.string().optional(),
+	discount_redemption_id: z.string().uuid().optional(),
+	discount_code_id: z.string().uuid().optional(),
+	discount_code: z.string().optional(),
+	discount_public_label: z.string().optional(),
+	credit_reservation_id: z.string().uuid().optional(),
+	credit_reserved_cents: z.string().optional(),
+	discount_code_amount_cents: z.string().optional(),
+	order_payment_reason: z.enum([
+		"instalment_payoff",
+		"flexible_balance_initial",
+		"flexible_balance_paydown"
+	]).optional(),
+	order_payment_plan_id: z.string().uuid().optional(),
+	order_flexible_balance_contract_id: z.string().uuid().optional()
+};
+const absentDatedOfferingSharedEngineMetadataShape = {
+	datedOfferingEngineContractVersion: z.never().optional(),
+	datedOfferingEngineRouteKind: z.never().optional(),
+	datedOfferingCapacityHoldId: z.never().optional(),
+	datedOfferingCapacityHoldAuditRef: z.never().optional(),
+	customerId: z.never().optional(),
+	eventSeriesId: z.never().optional()
+};
+const LegacyOrderCheckoutSessionMetadataSchema = z.object({
+	...orderCheckoutSessionMetadataBaseShape,
+	...absentDatedOfferingSharedEngineMetadataShape
+});
+const SharedDatedOfferingOrderCheckoutSessionMetadataSchema = z.object({
+	...orderCheckoutSessionMetadataBaseShape,
+	...datedOfferingSharedEngineMetadataShape
+});
+z.union([SharedDatedOfferingOrderCheckoutSessionMetadataSchema, LegacyOrderCheckoutSessionMetadataSchema]);
+//#endregion
+//#region ../commerce/src/purchase/stripeCommissionMetadata.ts
+/** Reasons are payment evidence, not an independent pricing policy. */
+const STRIPE_COMMISSION_FREE_REASONS = [
+	"managed_billing",
+	"no_commission_plan",
+	"billing_evidence_invalid",
+	"fee_rounds_to_zero",
+	"payment_not_stripe"
+];
+const historicalContext = {
+	currency: z.string().refine((value) => parseCurrencyCode(value) !== null).optional(),
+	sourcePlanId: z.string().trim().min(1).optional()
+};
+const percentSchema = z.number().finite().min(0).max(100);
+z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("commission_free"),
+		reason: z.enum(STRIPE_COMMISSION_FREE_REASONS),
+		...historicalContext
+	}),
+	z.object({
+		kind: z.literal("application_fee_amount"),
+		amountCents: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		percent: percentSchema,
+		...historicalContext
+	}),
+	z.object({
+		kind: z.literal("application_fee_percent"),
+		percent: percentSchema,
+		...historicalContext
+	})
+]);
+toNonNegativeCents(0);
+//#endregion
+//#region ../commerce/src/purchase/stripeMinimumCharge.ts
+const STRIPE_MINIMUM_CHARGE_CENTS_BY_CURRENCY = {
+	GBP: 30,
+	USD: 50,
+	EUR: 50,
+	AED: 200,
+	AUD: 50,
+	BGN: 100,
+	BRL: 50,
+	CAD: 50,
+	CHF: 50,
+	CZK: 1500,
+	DKK: 250,
+	HKD: 400,
+	HUF: 17500,
+	JPY: 50,
+	MXN: 1e3,
+	MYR: 200,
+	NOK: 300,
+	NZD: 50,
+	PLN: 200,
+	RON: 200,
+	SEK: 300,
+	SGD: 50,
+	THB: 1e3
+};
+function isStripeMinimumChargeCurrency(currency) {
+	return currency in STRIPE_MINIMUM_CHARGE_CENTS_BY_CURRENCY;
+}
+function getStripeMinimumChargeRequirement(rawCurrency) {
+	let currency;
+	try {
+		currency = normalizeCurrencyCode(rawCurrency);
+	} catch {
+		return null;
+	}
+	const currencyKey = currency;
+	if (!isStripeMinimumChargeCurrency(currencyKey)) return null;
+	return {
+		currency,
+		minimumAmountCents: STRIPE_MINIMUM_CHARGE_CENTS_BY_CURRENCY[currencyKey]
+	};
+}
+//#endregion
+//#region ../commerce/src/purchase/event-registration-errors.ts
+const eventRegistrationErrors = {
+	registrationClosed: {
+		message: "Booking is currently closed for this event. Please contact the organiser if you’d like to find out more.",
+		action: "none"
+	},
+	paymentInvestigationRequired: {
+		message: "We still can’t confirm your payment. Please don’t make another payment. Contact the organiser so they can check your booking.",
+		action: "none"
+	},
+	paymentProviderUnavailable: {
+		message: "We couldn’t reach the payment provider. Please try again in a minute.",
+		action: "retry"
+	},
+	paymentPageUnavailable: {
+		message: "We couldn’t open the payment page. Please refresh this page and try again. If this keeps happening, contact the organiser for help.",
+		action: "retry"
+	},
+	paymentUnavailable: {
+		message: "Online payment is not available for this event right now. Please contact the organiser for help with booking.",
+		action: "none"
+	},
+	capacityChanged: {
+		message: "Sorry, there aren’t enough places left for your selection. Please check the available places and choose again.",
+		action: "places"
+	},
+	selectionChanged: {
+		message: "The booking options for this event have changed. Please check the latest options and choose your places again.",
+		action: "places"
+	},
+	registrationPreparationChanged: {
+		message: "The booking options for this event have changed. Please check the latest options and choose your places again.",
+		action: "places"
+	},
+	registrationAlreadyExists: {
+		message: "You already have a booking for this event. Please check your bookings to see its status. If you need help, contact the organiser.",
+		action: "portal"
+	},
+	holdExpired: {
+		message: "Your reservation has timed out. Please check availability and choose your places again.",
+		action: "start"
+	},
+	waitlistUnavailable: {
+		message: "Sorry, the waiting list place offered in this invitation is no longer available. Please check the event for available places or contact the organiser for help.",
+		action: "event"
+	},
+	paymentContextMismatch: {
+		message: "The payment options for this event have changed. Please check the latest options before continuing.",
+		action: "payment-options"
+	},
+	verificationFailed: {
+		message: "We couldn’t confirm this request came from a person. Please refresh the page and try again.",
+		action: "none"
+	},
+	idempotencyConflict: {
+		message: "You’ve already started booking this event. Please finish in the other tab if it’s still open, or check your booking status before starting again.",
+		action: "portal"
+	},
+	invalidCommitInput: {
+		message: "We couldn’t accept your booking details. Please check the information you entered and try again. If this keeps happening, contact the organiser for help.",
+		action: "details"
+	}
+};
+function parseEventRegistrationErrorReason(value) {
+	return typeof value === "string" && Object.prototype.hasOwnProperty.call(eventRegistrationErrors, value) ? value : null;
+}
+//#endregion
 //#region ../blocks/src/system/runtime/shared/bookingPaymentOptionCopy.ts
 function buildUpfrontBookingPaymentOptionCopy(formattedTotal) {
 	return {
@@ -164,16 +547,15 @@ function resolveBookingPaymentDueNowCents(input) {
 	switch (input.option.kind) {
 		case "upfront": return input.totalCents;
 		case "deferred_manual": return 0;
-		case "instalment_plan": return buildInstalmentSchedulePreview({
-			totalCents: input.totalCents,
-			option: input.option,
-			bookingStartAt: input.bookingStartAt
-		})[0]?.amountCents ?? input.totalCents;
+		case "instalment_plan": return resolveBookingInitialInstalmentAmountCents({
+			totalAmountCents: input.totalCents,
+			plan: input.option.plan
+		});
 		case "flexible_balance": return resolveFlexibleBalanceInitialPaymentCents({
 			totalAmountCents: input.totalCents,
 			config: input.option.config
 		});
-		default: return assertNever$2(input.option);
+		default: return assertNever$3(input.option);
 	}
 }
 function buildBookingPaymentSelectionViewModel(input) {
@@ -190,6 +572,7 @@ function buildBookingPaymentSelectionViewModel(input) {
 			totalCents,
 			currency,
 			bookingStartAt: input.bookingStartAt,
+			nowIso: input.nowIso,
 			locale: input.locale
 		}))
 	};
@@ -232,17 +615,12 @@ function buildBookingPaymentOptionViewModel(input) {
 			};
 		}
 		case "instalment_plan": {
-			const schedulePreview = buildInstalmentSchedulePreview({
-				totalCents: input.totalCents,
-				option: input.option,
-				bookingStartAt: input.bookingStartAt
-			});
-			const dueToday = resolveBookingPaymentDueNowCents({
-				option: input.option,
-				totalCents: input.totalCents,
-				bookingStartAt: input.bookingStartAt
+			const [firstRow, ...futureRows] = buildBookingInstalmentSchedule({
+				anchorAt: input.nowIso,
+				totalAmountCents: input.totalCents,
+				plan: input.option.plan
 			});
-			const futureRows = schedulePreview.slice(1);
+			const dueToday = firstRow?.amountCents ?? 0;
 			const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
 			const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
 			const depositRefundability = getBookingInstalmentDepositRefundability(input.option.plan);
@@ -289,7 +667,7 @@ function buildBookingPaymentOptionViewModel(input) {
 			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(),
+				bookingStartAt: input.bookingStartAt ?? input.nowIso,
 				dueDateRule: input.option.config.dueDateRule
 			});
 			const copy = buildFlexibleBalanceBookingPaymentOptionCopy({
@@ -327,43 +705,7 @@ function buildBookingPaymentOptionViewModel(input) {
 				ctaLabel: copy.ctaLabel
 			};
 		}
-		default: return assertNever$2(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 instalments = splitAmountWithRemainderInFirst(Math.max(0, input.totalCents - deposit), 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;
-			return compactSchedulePreview(splitAmountWithRemainderInFirst(input.totalCents, plan.instalmentCount).map((amountCents, index) => ({
-				dueAt: index === 0 ? startAt : addIntervalPreservingMonthAnchor(startAt, plan.intervalCount * index, plan.intervalUnit),
-				amountCents
-			})));
-		}
-		default: return assertNever$2(input.option.plan);
+		default: return assertNever$3(input.option);
 	}
 }
 function getPaymentCadenceLabel(plan) {
@@ -371,9 +713,6 @@ function getPaymentCadenceLabel(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;
@@ -425,14 +764,14 @@ function pollingReducer(state, action) {
 			case "completed":
 			case "failed":
 			case "timeout": return state;
-			default: return assertNever$2(state);
+			default: return assertNever$3(state);
 		}
 		case "polling-timed-out": return {
 			tag: "timeout",
 			result: state.result,
 			error: /* @__PURE__ */ new Error("Polling timed out")
 		};
-		default: return assertNever$2(action);
+		default: return assertNever$3(action);
 	}
 }
 //#endregion
@@ -443,67 +782,24 @@ function pollingReducer(state, action) {
 * Provides a reusable polling mechanism with configurable intervals,
 * max attempts, and completion detection. Used by usePaymentVerification
 * and other hooks that need to poll for status changes.
-*
-* @example
-* ```tsx
-* const polling = usePolling(shouldPoll ? {
-*   pollFn: () => api.getStatus(id),
-*   isComplete: (result) => result.status === 'done',
-* } : null);
-*
-* useEffect(() => {
-*   if (polling.status === 'completed') {
-*     handleSuccess(polling.result);
-*   }
-* }, [polling.status]);
-* ```
 */
 const DEFAULT_MAX_ATTEMPTS = 10;
 const DEFAULT_POLL_INTERVAL = 1e3;
-/**
-* Generic hook for polling an async operation until completion.
-*
-* Pass config to start polling, or null to stop/idle.
-* The hook handles cleanup on unmount and config changes.
-*
-* **IMPORTANT: Config identity stability**
-*
-* The config object is used as an effect dependency. If config identity
-* changes on every render (e.g., inline objects), polling will restart
-* continuously, causing infinite request loops.
-*
-* Always memoize the config object:
-*
-* @example
-* ```tsx
-* // BAD - inline object creates new identity every render
-* usePolling({
-*   pollFn: () => api.getStatus(id),
-*   isComplete: (result) => result.status === 'done',
-* });
-*
-* // GOOD - memoized config, stable identity
-* const pollConfig = useMemo(() => shouldPoll ? {
-*   pollFn: () => api.getStatus(id),
-*   isComplete: (result) => result.status === 'done',
-* } : null, [shouldPoll, api, id]);
-*
-* usePolling(pollConfig);
-* ```
-*
-* @param config - Configuration for polling, or null to stop
-* @returns Polling result with status, data, and retry function
-*/
-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(() => {
+function usePollingRuntime(config) {
+	const runtime = {
+		configRef: useRef(config),
+		attemptsRef: useRef(0),
+		timeoutRef: useRef(null),
+		isPollingRef: useRef(false),
+		isActiveRef: useRef(false),
+		generationRef: useRef(0)
+	};
+	runtime.configRef.current = config;
+	return runtime;
+}
+function usePollingCleanup(runtime) {
+	const { isActiveRef, generationRef, timeoutRef, isPollingRef } = runtime;
+	return useCallback(() => {
 		isActiveRef.current = false;
 		generationRef.current += 1;
 		if (timeoutRef.current) {
@@ -511,16 +807,27 @@ function usePolling(config) {
 			timeoutRef.current = null;
 		}
 		isPollingRef.current = false;
-	}, []);
-	const resetState = useCallback(() => {
+	}, [
+		generationRef,
+		isActiveRef,
+		isPollingRef,
+		timeoutRef
+	]);
+}
+function usePollingReset(runtime, dispatch) {
+	const { attemptsRef } = runtime;
+	return useCallback(() => {
 		dispatch({ type: "polling-reset" });
 		attemptsRef.current = 0;
-	}, []);
-	const poll = useCallback(async () => {
-		const cfg = configRef.current;
-		if (!cfg) return true;
+	}, [attemptsRef, dispatch]);
+}
+function usePollingRequest(runtime, dispatch, cleanup) {
+	const { configRef, attemptsRef, isPollingRef, isActiveRef, generationRef } = runtime;
+	return useCallback(async () => {
+		const config = configRef.current;
+		if (!config) return true;
 		if (isPollingRef.current) return false;
-		const maxAttempts = cfg.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+		const maxAttempts = config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
 		if (attemptsRef.current >= maxAttempts) {
 			dispatch({ type: "polling-timed-out" });
 			cleanup();
@@ -530,81 +837,115 @@ function usePolling(config) {
 		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)) {
+			const result = await config.pollFn();
+			if (generation !== generationRef.current || !isActiveRef.current) return true;
+			if (config.isFailed?.(result)) {
 				dispatch({
 					type: "polling-failed",
-					result: data
+					result
 				});
 				cleanup();
 				return true;
 			}
-			if (cfg.isComplete(data)) {
+			if (config.isComplete(result)) {
 				dispatch({
 					type: "polling-completed",
-					result: data
+					result
 				});
 				cleanup();
 				return true;
 			}
 			dispatch({
 				type: "polling-progressed",
-				result: data
+				result
 			});
 			isPollingRef.current = false;
 			return false;
-		} catch (err) {
-			if (generation !== generationRef.current || !isActiveRef.current) {
-				isPollingRef.current = false;
-				return true;
-			}
-			if (err instanceof Error) dispatch({
+		} catch (error) {
+			if (generation !== generationRef.current || !isActiveRef.current) return true;
+			if (error instanceof Error) dispatch({
 				type: "polling-request-failed",
-				error: err
+				error
 			});
 			isPollingRef.current = false;
 			return false;
 		}
-	}, [cleanup]);
-	const schedulePoll = useCallback(() => {
+	}, [
+		attemptsRef,
+		cleanup,
+		configRef,
+		dispatch,
+		generationRef,
+		isActiveRef,
+		isPollingRef
+	]);
+}
+function usePollingScheduler(runtime, poll) {
+	const { attemptsRef, configRef, isActiveRef, timeoutRef } = runtime;
+	return useCallback(() => {
 		if (!isActiveRef.current) return;
-		const pollInterval = configRef.current?.interval ?? DEFAULT_POLL_INTERVAL;
 		const doPoll = async () => {
-			if (!await poll() && isActiveRef.current) timeoutRef.current = setTimeout(doPoll, pollInterval);
+			if (!await poll() && isActiveRef.current) {
+				const configuredInterval = configRef.current?.interval;
+				const interval = typeof configuredInterval === "function" ? configuredInterval(attemptsRef.current) : configuredInterval ?? DEFAULT_POLL_INTERVAL;
+				timeoutRef.current = setTimeout(doPoll, interval);
+			}
 		};
 		doPoll();
-	}, [poll]);
+	}, [
+		attemptsRef,
+		configRef,
+		isActiveRef,
+		poll,
+		timeoutRef
+	]);
+}
+function usePollingCycle(config, runtime, dispatch) {
+	const cleanup = usePollingCleanup(runtime);
+	const resetState = usePollingReset(runtime, dispatch);
+	const schedulePoll = usePollingScheduler(runtime, usePollingRequest(runtime, dispatch, cleanup));
+	const pollingEnabled = config !== null;
 	useEffect(() => {
-		if (!config) {
+		if (!pollingEnabled) {
 			cleanup();
 			dispatch({ type: "polling-went-idle" });
 			return;
 		}
 		resetState();
-		isActiveRef.current = true;
+		runtime.isActiveRef.current = true;
 		schedulePoll();
 		return cleanup;
 	}, [
-		config,
 		cleanup,
+		dispatch,
+		pollingEnabled,
 		resetState,
+		config?.restartKey ?? null,
+		runtime.isActiveRef,
 		schedulePoll
 	]);
-	const retry = useCallback(() => {
-		if (!configRef.current) return;
+	return useCallback(() => {
+		if (!runtime.configRef.current) return;
 		cleanup();
 		resetState();
-		isActiveRef.current = true;
+		runtime.isActiveRef.current = true;
 		schedulePoll();
 	}, [
 		cleanup,
 		resetState,
+		runtime.configRef,
+		runtime.isActiveRef,
 		schedulePoll
 	]);
+}
+/**
+* Polls until the operation completes, fails, times out, or becomes disabled.
+* Config objects may be rebuilt across renders; change restartKey to begin a
+* new operation and reset its attempt budget.
+*/
+function usePolling(config) {
+	const [state, dispatch] = useReducer(pollingReducer, void 0, createInitialPollingState);
+	const retry = usePollingCycle(config, usePollingRuntime(config), dispatch);
 	return {
 		status: config ? state.tag : "idle",
 		result: config ? state.result : null,
@@ -708,4 +1049,4 @@ function BookingMailingListNote(props) {
 	});
 }
 //#endregion
-export { buildBookingPaymentSelectionViewModel as a, usePolling as i, BookingConsentAgreement as n, resolveBookingPaymentDueNowCents as o, StepIndicator as r, formatPrice as s, BookingMailingListNote as t };
+export { buildBookingPaymentSelectionViewModel as a, eventRegistrationErrors as c, planCheckoutPaymentFlow as d, planFlexibleBalanceCreditFirst as f, usePolling as i, parseEventRegistrationErrorReason as l, BookingConsentAgreement as n, resolveBookingPaymentDueNowCents as o, useBookingNowIso as p, StepIndicator as r, formatPrice as s, BookingMailingListNote as t, getStripeMinimumChargeRequirement as u };