@riverbankcms/sdk 0.149.0 → 0.150.0

package/dist/client/{eventRegistration-O6ZxHfOb.mjs → eventRegistration-BoXfSFgZ.mjs}

@@ -1,24 +1,23 @@
 "use client";
-import { a as buildBookingPaymentSelectionViewModel, c as eventRegistrationErrors, d as planCheckoutPaymentFlow, f as planFlexibleBalanceCreditFirst, i as usePolling, l as parseEventRegistrationErrorReason, n as BookingConsentAgreement, o as resolveBookingPaymentDueNowCents, p as useBookingNowIso, r as StepIndicator$1, s as formatPrice, t as BookingMailingListNote, u as getStripeMinimumChargeRequirement } from "./BookingMailingListNote-Cr3EeTP5.mjs";
-import { C as resolveDiscountContext, Cn as formatCurrencyAmount, D as WIZARD_STEPS, E as toRegistrationRequestSubject, M as resolveEventRegistrationScopedEvents, O as getStepNumber, Ot as getRegistrationSuccessCopy, S as findPreSelectedEvent, Sn as publicEventPricingType, T as resolveRegistrationTarget, Wt as assertNever, _ as buildEventRegistrationDisplayFromScopedEvents, b as toWholeSeriesRegistrationEvents, bn as publicEventPricingOptions, en as resolveBookingSignupOffer, fn as toBookingTimeZone, ft as groupPublicEventsByRun, in as formatBookingDateTime, k as getWizardStepsForContext, mn as toScheduledBookingDateTime, nn as formatBookingDate, on as formatBookingTime, t as defineIslandPropsDecoder, v as getRegistrationStartAt, vn as publicEventPricingCurrency, w as resolveEventRequiresPayment, x as findEventByOccurrenceId, xn as publicEventPricingStrategy, y as toRegistrationEvents } from "./propsDecoder-DZd6RJeA.mjs";
-import { a as canJoinEventWaitlistOnAnyMode, c as formatTicketTypeRemaining, f as getRemainingPlaces, h as selectMostOpenCapacitySource, i as canJoinEventWaitlist, m as selectEventCapacitySource, o as formatEventRemainingPlaces, p as isEventFull, r as formatEventPriceDisplay, s as formatRemainingPlaces, u as getEventAvailability } from "./pricing-KEAEsibq.mjs";
-import { n as useBlockApi, r as BlockApiError, t as BlockApiProvider } from "./context-DFmaZa-Q.mjs";
+import { a as buildBookingPaymentSelectionViewModel, c as useBookingNowIso, i as usePolling, n as BookingConsentAgreement, o as resolveBookingPaymentDueNowCents, r as StepIndicator$1, s as formatPrice, t as BookingMailingListNote } from "./BookingMailingListNote-CYHOufsI.mjs";
+import { $t as parseEventRegistrationErrorReason, An as publicEventPricingOptions, C as resolveDiscountContext, D as getRegistrationStepPresentation, E as toRegistrationRequestSubject, M as resolveEventRegistrationScopedEvents, Mn as publicEventPricingType, Nn as formatCurrencyAmount, O as getStepNumber, On as publicEventPricingCurrency, Ot as getRegistrationSuccessCopy, Qt as eventRegistrationErrors, S as findPreSelectedEvent, Sn as toScheduledBookingDateTime, T as resolveRegistrationTarget, Wt as assertNever, _ as buildEventRegistrationDisplayFromScopedEvents, b as toWholeSeriesRegistrationEvents, bn as toBookingTimeZone, cn as resolveBookingSignupOffer, en as getStripeMinimumChargeRequirement, fn as formatBookingDateTime, ft as groupPublicEventsByRun, jn as publicEventPricingStrategy, k as getWizardStepsForContext, mn as formatBookingTime, nn as planFlexibleBalanceCreditFirst, t as defineIslandPropsDecoder, tn as planCheckoutPaymentFlow, un as formatBookingDate, v as getRegistrationStartAt, w as resolveEventRequiresPayment, x as findEventByOccurrenceId, y as toRegistrationEvents } from "./propsDecoder-DiIeBopB.mjs";
+import { i as SpinnerNode, n as ThemedButtonLink, t as ThemedButton } from "./ThemedButton-C7WhXuRl.mjs";
+import { a as canJoinEventWaitlistOnAnyMode, c as formatTicketTypeRemaining, f as getRemainingPlaces, h as selectMostOpenCapacitySource, i as canJoinEventWaitlist, m as selectEventCapacitySource, o as formatEventRemainingPlaces, p as isEventFull, r as formatEventPriceDisplay, s as formatRemainingPlaces, u as getEventAvailability } from "./pricing-DXEh2Lhh.mjs";
+import { n as useBlockApi, r as BlockApiError, t as BlockApiProvider } from "./context-D_8s12Fp.mjs";
 import { n as isSpamProtectionEnabled, r as AltchaWidget, t as getChallengeUrl } from "./src-B833rYRr.mjs";
-import { a as requestDemoPortalMagicLink, f as storeDemoBookingPass, i as buildPortalCallbackUrl, o as DiscountCodeDisclosure, r as CUSTOMER_PORTAL_PATH, t as BookingConfirmation } from "./DemoBookingPortalAccess-BFGB1Fay.mjs";
-import { a as useDiscountCodeUi, i as CheckIcon, n as StateIcon, r as scrollToBlock, t as TerminalPanel } from "./TerminalPanel-JjmgxEsR.mjs";
-import { i as SpinnerNode, n as ThemedButtonLink, t as ThemedButton } from "./ThemedButton-CKV1Jh2m.mjs";
+import { a as requestDemoPortalMagicLink, f as storeDemoBookingPass, i as buildPortalCallbackUrl, o as DiscountCodeDisclosure, r as CUSTOMER_PORTAL_PATH, t as BookingConfirmation } from "./DemoBookingPortalAccess-Cvr9O_ca.mjs";
+import { i as useDiscountCodeUi, n as StateIcon, r as CheckIcon, t as TerminalPanel } from "./TerminalPanel-CUCNEwlH.mjs";
 import { t as FeedbackMessage } from "./FeedbackMessage-CtLvvS_d.mjs";
 import { i as getFieldValidationControlProps, r as FieldValidationMessage } from "./mailingListSignupCopy-DZSHZrm6.mjs";
-import { t as buildCheckoutReturnUrls } from "./checkoutUrls-CXhko2Rv.mjs";
-import { t as CheckboxChoice } from "./CheckboxChoice-B33MqoUo.mjs";
+import { t as CheckboxChoice } from "./CheckboxChoice-M-3HycLw.mjs";
 import { t as createBodyThemePortalRoot } from "./themePortalRoot-AGs4cE7t.mjs";
-import { n as consumeSearchParams } from "./urlParams-D71VXFGx.mjs";
 import { t as CrossIcon } from "./CrossIcon-Dn1KRKW5.mjs";
 import { t as mountReactIsland } from "./reactMount-SY8AVRof.mjs";
-import { t as buildRouteIslandApiConfig } from "./routeIslandApiConfig-E1EkhhYY.mjs";
+import { t as buildRouteIslandApiConfig } from "./routeIslandApiConfig-wzR4lKAY.mjs";
 import { t as createLucideIcon } from "./createLucideIcon-PaLVMov4.mjs";
 import { t as ModalShell } from "./ModalShell-CqkBvBIC.mjs";
-import React, { useCallback, useEffect, useId, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
+import React, { Suspense, lazy, useCallback, useEffect, useId, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
+import { z } from "zod";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { createPortal } from "react-dom";
 //#region ../core/src/uuid.ts
@@ -175,6 +174,161 @@ const Wallet = createLucideIcon("wallet", [["path", {
 	key: "xoc0q4"
 }]]);
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/registrationCompletion.ts
+/** One admission decision for navigation, labels and completion. Email recovery
+* permits navigation only; submission remains the owner of payment recovery. */
+function resolveRegistrationAdmission(input) {
+	if (input.hasWaitlistClaim) return { kind: "resume" };
+	if (input.eligibilityLoading) return { kind: "checking" };
+	if (input.eligibilityError) return {
+		kind: "closed",
+		reason: "optionsUnavailable",
+		message: input.eligibilityError
+	};
+	if (!input.eligibility) return { kind: "checking" };
+	const { registration, availability } = input.eligibility;
+	if (registration.kind === "pending_payment") return { kind: "resume" };
+	if (registration.kind === "waitlisted") return {
+		kind: "closed",
+		reason: "alreadyWaitlisted",
+		message: "You're already on the waitlist for this event."
+	};
+	return admissionFromAvailability(availability, input.isAuthenticated);
+}
+function admissionFromAvailability(availability, isAuthenticated) {
+	switch (availability.kind) {
+		case "available": return { kind: "open" };
+		case "waitlist": return {
+			kind: "waitlist",
+			recovery: isAuthenticated ? "none" : "byEmail"
+		};
+		case "unavailable": switch (availability.reason) {
+			case "full": return {
+				kind: "fullyBooked",
+				recovery: isAuthenticated ? "none" : "byEmail"
+			};
+			case "paymentUnavailable": return {
+				kind: "closed",
+				reason: "unavailable",
+				message: "Payment options are not available for this event."
+			};
+			case "selectionRequired": return { kind: "open" };
+			case "bookingClosed": return {
+				kind: "closed",
+				reason: "unavailable",
+				message: "Registration is not available for this event."
+			};
+		}
+	}
+}
+function stepAfterTickets(admission) {
+	switch (admission.kind) {
+		case "open":
+		case "resume":
+		case "waitlist": return "enter-details";
+		case "fullyBooked": return "fully-booked";
+		case "checking":
+		case "closed": return "select-tickets";
+	}
+}
+function resolveRegistrationAvailabilityBlocker(admission) {
+	switch (admission.kind) {
+		case "open":
+		case "resume":
+		case "waitlist": return null;
+		case "fullyBooked": return admission.recovery === "none" ? {
+			kind: "unavailable",
+			message: "This event is fully booked."
+		} : null;
+		case "checking": return {
+			kind: "pending",
+			message: "Checking availability..."
+		};
+		case "closed": return {
+			kind: "unavailable",
+			message: admission.message
+		};
+	}
+}
+function resolvePricingSelectionBlocker(input) {
+	if (input.selectionRequired && !input.hasValidSelection) return "Choose at least one available ticket to continue.";
+	return input.slidingScaleSelectionMessage;
+}
+/** Submit owns fresh admission. Open quotes do not depend on an email lookup. */
+function resolveGuestNextStepCheck(admission, request) {
+	switch (admission.kind) {
+		case "open":
+		case "resume": return {
+			kind: "skip",
+			outcome: { kind: "continue" }
+		};
+		case "checking": return {
+			kind: "blocked",
+			message: "Checking availability..."
+		};
+		case "closed": return {
+			kind: "blocked",
+			message: admission.message
+		};
+		case "fullyBooked":
+			if (admission.recovery === "none") return {
+				kind: "blocked",
+				message: "This event is fully booked."
+			};
+			return recoveryCheckRequest(request);
+		case "waitlist": return admission.recovery === "none" ? {
+			kind: "skip",
+			outcome: { kind: "waitlist" }
+		} : recoveryCheckRequest(request);
+	}
+}
+function recoveryCheckRequest(request) {
+	return request ? {
+		kind: "check",
+		request
+	} : {
+		kind: "blocked",
+		message: "Choose an event before checking your booking."
+	};
+}
+function resolveRegistrationTicketContinuation(input) {
+	if (input.isCheckingExistingRegistration) return {
+		kind: "blocked",
+		label: "Checking registration...",
+		pending: true,
+		message: "Your booking options are being checked."
+	};
+	if (input.ticketSelectionRequired && !input.hasValidTicketSelection) return {
+		kind: "blocked",
+		label: "Choose a ticket",
+		pending: false,
+		message: "Choose at least one available ticket to continue."
+	};
+	switch (input.admission.kind) {
+		case "checking": return {
+			kind: "blocked",
+			label: "Checking availability...",
+			pending: true,
+			message: "Your booking options are being checked."
+		};
+		case "closed": return {
+			kind: "blocked",
+			label: input.admission.reason === "alreadyWaitlisted" ? "Already on waitlist" : input.admission.reason === "optionsUnavailable" ? "Availability unavailable" : "Registration unavailable",
+			pending: false,
+			message: input.admission.message
+		};
+		case "open":
+		case "resume":
+		case "waitlist":
+		case "fullyBooked": return {
+			kind: "advance",
+			admission: input.admission,
+			label: "Continue",
+			pending: false
+		};
+	}
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/eventPaymentOptions.ts
 function getApprovedDirectPaymentCollectionOptionKinds(paymentOptions) {
 	return paymentOptions.flatMap((option) => {
@@ -274,9 +428,6 @@ function resolveEventRegistrationDirectPaymentSelection(input) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationStateMachine.ts
-function hasBlockingExistingRegistration(input) {
-	return !input.hasWaitlistClaim && input.isAuthenticated && input.registration.kind === "waitlisted";
-}
 function createInitialRegistrationFlowState(hasPreSelectedContext) {
 	return {
 		step: hasPreSelectedContext ? "select-tickets" : "select-event",
@@ -352,8 +503,7 @@ function isSelectionValid(input) {
 function normalizeRegistrationFlowState(state) {
 	const hasPass = Boolean(state.eligibility?.eligiblePasses.length);
 	const hasMembership = Boolean(state.eligibility?.eligibleMemberships.length);
-	let nextPassOptOut = state.passOptOut;
-	if (nextPassOptOut && (state.step === "select-tickets" || state.ticketsCount !== 1 || !hasPass || hasMembership)) nextPassOptOut = false;
+	const nextPassOptOut = state.passOptOut && !(state.step === "select-tickets" || state.ticketsCount !== 1 || !hasPass || hasMembership);
 	const autoSelection = computeAutoSelection({
 		isAuthenticated: state.isAuthenticated,
 		eligibility: state.eligibility,
@@ -378,8 +528,27 @@ function normalizeRegistrationFlowState(state) {
 	};
 }
 function registrationFlowReducer(state, action) {
+	if ([
+		"payment",
+		"submitting",
+		"verifying-payment",
+		"verifying-timeout",
+		"payment-status"
+	].includes(state.step) && action.type !== "set-step") return state;
 	switch (action.type) {
-		case "set-step": return normalizeRegistrationFlowState({
+		case "admission-updated":
+		case "tickets-completed":
+		case "recovery-checked": return reduceRegistrationAdmission(state, action);
+		case "set-step": return [
+			"payment",
+			"submitting",
+			"verifying-payment",
+			"verifying-timeout",
+			"payment-status"
+		].includes(action.step) ? {
+			...state,
+			step: action.step
+		} : normalizeRegistrationFlowState({
 			...state,
 			step: action.step
 		});
@@ -395,18 +564,8 @@ function registrationFlowReducer(state, action) {
 			...state,
 			eligibility: action.eligibility
 		});
-		case "set-manual-payment-selection": return normalizeRegistrationFlowState({
-			...state,
-			paymentSelection: normalizePaymentSelection(action.selection),
-			selectionSource: "manual",
-			passOptOut: action.selection.method === "stripe" ? true : state.passOptOut
-		});
-		case "use-card-instead-of-pass": return normalizeRegistrationFlowState({
-			...state,
-			passOptOut: true,
-			paymentSelection: computeDirectPaymentSelection(state.eligibility),
-			selectionSource: "manual"
-		});
+		case "set-manual-payment-selection":
+		case "use-card-instead-of-pass": return reduceRegistrationPaymentChoice(state, action);
 		case "event-changed": return normalizeRegistrationFlowState({
 			...state,
 			step: action.hasPreSelectedContext ? "select-tickets" : "select-event",
@@ -416,7 +575,6 @@ function registrationFlowReducer(state, action) {
 			eligibility: null
 		});
 		case "reset": return createInitialRegistrationFlowState(action.hasPreSelectedContext);
-		default: return state;
 	}
 }
 function isEntitlementSelection(selection) {
@@ -426,6 +584,38 @@ function requiresPaymentStep(params) {
 	if (!params.eventRequiresPayment) return false;
 	return !isEntitlementSelection(params.paymentSelection);
 }
+function reduceRegistrationPaymentChoice(state, action) {
+	switch (action.type) {
+		case "set-manual-payment-selection": return normalizeRegistrationFlowState({
+			...state,
+			paymentSelection: normalizePaymentSelection(action.selection),
+			selectionSource: "manual",
+			passOptOut: action.selection.method === "stripe" ? true : state.passOptOut
+		});
+		case "use-card-instead-of-pass": return normalizeRegistrationFlowState({
+			...state,
+			passOptOut: true,
+			paymentSelection: computeDirectPaymentSelection(state.eligibility),
+			selectionSource: "manual"
+		});
+	}
+}
+function reduceRegistrationAdmission(state, action) {
+	switch (action.type) {
+		case "admission-updated": return state.step === "fully-booked" && action.admission.kind !== "checking" ? normalizeRegistrationFlowState({
+			...state,
+			step: stepAfterTickets(action.admission)
+		}) : state;
+		case "tickets-completed": return state.step === "select-tickets" ? normalizeRegistrationFlowState({
+			...state,
+			step: stepAfterTickets(action.admission)
+		}) : state;
+		case "recovery-checked": return state.step === "fully-booked" && action.outcome.kind !== "unavailable" ? normalizeRegistrationFlowState({
+			...state,
+			step: "enter-details"
+		}) : state;
+	}
+}
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.planning.ts
 function isEventRegistrationAvailable(event) {
@@ -767,16 +957,66 @@ const EventSelectionStep = ({ events, selectedEvent, onSelect, showVenue, showCa
 	});
 };
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/useRegistrationAdmission.ts
+/** Owns admission and its navigation commands; renderers receive decisions. */
+function useRegistrationAdmission(input) {
+	const { eligibility, eligibilityError, eligibilityLoading, hasWaitlistClaim, isAuthenticated, dispatchFlow } = input;
+	const admission = useMemo(() => resolveRegistrationAdmission({
+		eligibility,
+		eligibilityError,
+		eligibilityLoading,
+		hasWaitlistClaim,
+		isAuthenticated
+	}), [
+		eligibility,
+		eligibilityError,
+		eligibilityLoading,
+		hasWaitlistClaim,
+		isAuthenticated
+	]);
+	useEffect(() => {
+		dispatchFlow({
+			type: "admission-updated",
+			admission
+		});
+	}, [admission, dispatchFlow]);
+	const ticketContinuation = resolveRegistrationTicketContinuation({
+		admission,
+		ticketSelectionRequired: input.ticketSelectionRequired,
+		hasValidTicketSelection: input.hasValidTicketSelection,
+		isCheckingExistingRegistration: isAuthenticated && input.existingRegistrationLoading
+	});
+	const handleTicketsComplete = () => {
+		if (ticketContinuation.kind === "blocked") return {
+			ok: false,
+			reason: "blocked",
+			message: ticketContinuation.message
+		};
+		dispatchFlow({
+			type: "tickets-completed",
+			admission: ticketContinuation.admission
+		});
+		return { ok: true };
+	};
+	const onRecoveryChecked = (outcome) => dispatchFlow({
+		type: "recovery-checked",
+		outcome
+	});
+	return {
+		admission,
+		ticketContinuation,
+		handleTicketsComplete,
+		onRecoveryChecked
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationErrorRecovery.ts
 function resolveRegistrationRecoveryAction(step, action) {
 	if (step === "payment-failed") return "payment-options";
 	if (step === "payment-status") return "none";
-	if (step === "verifying-payment" || step === "verifying-timeout" || step === "redirecting") return "none";
+	if (step === "verifying-payment" || step === "verifying-timeout" || step === "payment") return "none";
 	return action;
 }
-function canRecoverToWaitlist(eligibility) {
-	return eligibility?.availability.kind === "waitlist" && eligibility.registration.kind !== "pending_payment";
-}
 function shouldRefreshAfterRegistrationError(step, action, enabled) {
 	return enabled || step === "error" && action === "places";
 }
@@ -790,7 +1030,6 @@ function resetRegistrationAfterExpiry(input) {
 	const mode = input.preSelectedEvent?.deliveryMode;
 	input.setSelectedAttendanceMode(mode === "online" || mode === "in_person" ? mode : null);
 	input.setErrorMessage("");
-	input.setPendingRegistrationReference(null);
 }
 /** Retry the retained submission in place; explicit payment uncertainty stays status-only. */
 function recoverRegistrationError(action, handlers) {
@@ -1290,441 +1529,174 @@ function useResolvedWaitlistClaim(deps, credential) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/hooks/usePaymentVerification.ts
-/**
-* Hook for polling payment status after Stripe redirects.
-*
-* Built on top of the generic usePolling hook, this provides
-* a specialized interface for verifying event registration payments.
-*
-* @example
-* ```tsx
-* const verification = usePaymentVerification(
-*   step === 'verifying-payment' && attendeeId
-*     ? { transactionId: attendeeId }
-*     : null
-* );
-*
-* useEffect(() => {
-*   if (verification.status === 'completed') {
-*     setStep('success');
-*   } else if (verification.status === 'failed') {
-*     setStep('payment-failed');
-*   } else if (verification.status === 'timeout') {
-*     setStep('verifying-timeout');
-*   }
-* }, [verification.status]);
-* ```
-*/
-const paymentVerificationDeps = { useBlockApi };
-function resolvePaymentPollingTarget(config) {
-	const reference = config.reference;
-	return reference.scope === "occurrence" ? {
-		key: `occurrence:${reference.attendeeId}`,
-		reference
-	} : {
-		key: `wholeSeries:${reference.registrationId}`,
-		reference
-	};
-}
-function createPaymentPollingConfig(api, settings) {
-	if (settings === null) return null;
-	const target = resolvePaymentPollingTarget(settings);
-	return {
-		restartKey: target.key,
-		pollFn: () => api.getEventRegistrationStatus(target.reference),
-		isComplete: (result) => result.paymentStatus === "completed" || result.paymentStatus === "not_required",
-		isFailed: (result) => result.paymentStatus === "failed" || result.paymentStatus === "refunded",
-		maxAttempts: settings.maxAttempts,
-		interval: settings.pollInterval
-	};
-}
-function getPaymentVerificationError(polling, paymentStatus) {
-	if (polling.status === "timeout") return "Could not verify payment. If you were charged, please contact support.";
-	if (polling.status === "failed" && paymentStatus !== null) return paymentStatus === "refunded" ? "Payment was refunded. Please contact support." : "Payment was declined. Please try again.";
-	return polling.error?.message ?? null;
-}
-function mapPaymentVerificationResult(polling) {
-	const paymentStatus = polling.result?.paymentStatus ?? null;
-	return {
-		status: polling.status,
-		paymentStatus,
-		attendeeStatus: polling.result?.attendeeStatus ?? null,
-		waitlistPosition: polling.result?.waitlistPosition ?? null,
-		error: getPaymentVerificationError(polling, paymentStatus),
-		retry: polling.retry
-	};
-}
-/**
-* Hook for polling payment status after Stripe redirects.
-*
-* Pass config to start polling, or null to stop/idle.
-* The hook handles cleanup on unmount and starts a new cycle when the status
-* reference changes.
-*
-* @param config - Configuration for polling, or null to stop
-* @returns Verification result with status, data, and retry function
-*/
-function usePaymentVerification(config) {
-	return usePaymentVerificationWithDeps(config, paymentVerificationDeps);
-}
-function usePaymentVerificationWithDeps(config, deps) {
-	return mapPaymentVerificationResult(usePolling(createPaymentPollingConfig(deps.useBlockApi(), config)));
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/constants.ts
-const EVENT_REGISTRATION_ANCHOR_ID = "event-registration";
-const EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM = "registration_attempt";
-//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/sessionStorage.ts
 const STORAGE_PREFIX = "riverbank:event-registration:";
 const STALE_THRESHOLD_MS = 1440 * 60 * 1e3;
-/**
-* Build the sessionStorage key for a specific registration.
-*/
-function getStorageKey(siteId, checkoutAttemptId) {
-	return `${STORAGE_PREFIX}${siteId}:${checkoutAttemptId}`;
-}
-/**
-* Check if sessionStorage is available.
-* Returns false in private browsing mode or when storage is disabled.
-*/
-function isStorageAvailable() {
-	try {
-		const testKey = "__riverbank_test__";
-		sessionStorage.setItem(testKey, "test");
-		sessionStorage.removeItem(testKey);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Save pending registration data before Stripe redirect.
-*
-* @param siteId - Site ID
-* @param checkoutAttemptId - Correlation ID included in the checkout return URL
-* @param data - Registration data to save (excluding version and timestamp)
-*/
-function savePendingRegistration(siteId, checkoutAttemptId, data) {
-	if (!isStorageAvailable()) {
-		console.warn("[sessionStorage] Storage not available, skipping save");
-		return;
-	}
+const paymentSelection = z.discriminatedUnion("method", [
+	z.object({ method: z.literal("free") }),
+	z.object({
+		method: z.literal("stripe"),
+		collectionOptionKind: z.enum([
+			"upfront",
+			"deferred_manual",
+			"instalment_plan",
+			"flexible_balance"
+		])
+	}),
+	z.object({
+		method: z.literal("pass"),
+		passId: z.string(),
+		productName: z.string().optional()
+	}),
+	z.object({
+		method: z.literal("membership"),
+		membershipId: z.string(),
+		productName: z.string().optional()
+	}),
+	z.object({
+		method: z.literal("pass_bundle"),
+		bundlePassId: z.string(),
+		productName: z.string().optional(),
+		productDescription: z.string().optional(),
+		productPrice: z.number().optional(),
+		productCurrency: z.string().optional()
+	}),
+	z.object({
+		method: z.literal("membership_bundle"),
+		bundleMembershipId: z.string(),
+		productName: z.string().optional(),
+		productDescription: z.string().optional(),
+		productPrice: z.number().optional(),
+		productCurrency: z.string().optional(),
+		productInterval: z.string().optional()
+	})
+]);
+const schema = z.object({
+	version: z.literal(6),
+	reference: z.discriminatedUnion("scope", [z.object({
+		scope: z.literal("occurrence"),
+		attendeeId: z.string()
+	}), z.object({
+		scope: z.literal("wholeSeries"),
+		registrationId: z.string()
+	})]),
+	formData: z.object({
+		name: z.string(),
+		email: z.string(),
+		phone: z.string(),
+		notes: z.string(),
+		consentAccepted: z.boolean().optional(),
+		mailingListOptIn: z.boolean().optional()
+	}),
+	ticketSelections: z.array(z.object({
+		pricingOptionId: z.string().nullable(),
+		quantity: z.number().int().positive()
+	})).min(1),
+	selectedEventId: z.string().nullable(),
+	selectedAttendanceMode: z.enum(["in_person", "online"]).nullable().optional(),
+	paymentSelection,
+	guests: z.array(z.object({
+		name: z.string(),
+		email: z.string().nullable(),
+		phone: z.string().nullable()
+	})),
+	selectedSlidingAmount: z.number().nullable(),
+	discountCode: z.string(),
+	mailingListSignupNote: z.enum(["confirmation_required", "not_confirmed"]).optional(),
+	timestamp: z.number().finite()
+});
+function key(siteId, submissionId) {
+	return `${STORAGE_PREFIX}${siteId}:${submissionId}`;
+}
+function savePendingRegistration(siteId, submissionId, data) {
 	try {
-		const key = getStorageKey(siteId, checkoutAttemptId);
-		const ticketSelections = normalizeTicketSelectionLines(data.ticketSelections);
-		if (ticketSelections.length === 0) {
-			console.warn("[sessionStorage] No ticket selections to save, skipping registration state");
-			return;
-		}
-		const entry = {
+		const entry = schema.safeParse({
 			...data,
-			ticketSelections,
-			version: 5,
+			ticketSelections: normalizeTicketSelectionLines(data.ticketSelections),
+			version: 6,
 			timestamp: Date.now()
-		};
-		sessionStorage.setItem(key, JSON.stringify(entry));
-	} catch (error) {
-		console.warn("[sessionStorage] Failed to save registration:", error);
-	}
-}
-/**
-* Get pending registration data after returning from Stripe.
-*
-* Returns null if:
-* - No entry exists for this checkout attempt
-* - Entry is stale (> 24 hours old)
-* - Entry is corrupt or wrong version
-* - Storage is unavailable
-*
-* @param siteId - Site ID
-* @param checkoutAttemptId - Correlation ID returned from checkout.
-* @returns Pending registration data or null
-*/
-function getPendingRegistration(siteId, checkoutAttemptId) {
-	if (!isStorageAvailable()) return null;
-	try {
-		const key = getStorageKey(siteId, checkoutAttemptId);
-		const stored = sessionStorage.getItem(key);
-		if (stored) return parseAndValidateEntry(stored, key);
-		return null;
-	} catch (error) {
-		console.warn("[sessionStorage] Failed to read registration:", error);
-		return null;
-	}
+		});
+		if (entry.success) sessionStorage.setItem(key(siteId, submissionId), JSON.stringify(entry.data));
+	} catch {}
 }
-/**
-* Internal helper to parse and validate a storage entry.
-*/
-function parseAndValidateEntry(stored, key) {
+function getPendingRegistration(siteId, submissionId) {
 	try {
-		const raw = JSON.parse(stored);
-		if (!raw || typeof raw !== "object") {
-			sessionStorage.removeItem(key);
-			return null;
-		}
-		const version = raw.version;
-		if (version !== 4 && version !== 5) {
-			console.warn("[sessionStorage] Outdated version, ignoring entry");
-			sessionStorage.removeItem(key);
-			return null;
-		}
-		const entry = normalizeStoredRegistration(raw);
-		const timestamp = typeof entry.timestamp === "number" ? entry.timestamp : NaN;
-		if (!Number.isFinite(timestamp)) {
-			sessionStorage.removeItem(key);
-			return null;
-		}
-		if (Date.now() - timestamp > STALE_THRESHOLD_MS) {
-			console.info("[sessionStorage] Entry is stale, removing");
-			sessionStorage.removeItem(key);
-			return null;
-		}
-		const ticketSelections = normalizeTicketSelectionLines(entry.ticketSelections);
-		if (ticketSelections.length === 0 || getTicketSelectionTotal(ticketSelections) <= 0) {
-			sessionStorage.removeItem(key);
+		const stored = sessionStorage.getItem(key(siteId, submissionId));
+		const parsed = schema.safeParse(stored ? JSON.parse(stored) : null);
+		if (!parsed.success || Date.now() - parsed.data.timestamp > STALE_THRESHOLD_MS) {
+			clearPendingRegistration(siteId, submissionId);
 			return null;
 		}
-		return {
-			...entry,
-			ticketSelections
-		};
+		return parsed.data;
 	} catch {
-		console.warn("[sessionStorage] Failed to parse entry, removing");
-		sessionStorage.removeItem(key);
 		return null;
 	}
 }
-function normalizeStoredRegistration(entry) {
-	if (entry.version === 5) return entry;
-	const { attendeeId, ...stored } = entry;
-	return {
-		...stored,
-		version: 5,
-		reference: {
-			scope: "occurrence",
-			attendeeId
-		}
-	};
-}
-/**
-* Clear pending registration data after successful verification.
-*
-* @param siteId - Site ID
-* @param checkoutAttemptId - Checkout return correlation ID
-*/
-function clearPendingRegistration(siteId, checkoutAttemptId) {
-	if (!isStorageAvailable()) return;
+function clearPendingRegistration(siteId, submissionId) {
 	try {
-		const key = getStorageKey(siteId, checkoutAttemptId);
-		sessionStorage.removeItem(key);
+		sessionStorage.removeItem(key(siteId, submissionId));
 	} catch {}
 }
-/**
-* Clean up all stale registration entries from sessionStorage.
-* Should be called on component mount to prevent accumulation.
-*/
 function cleanupStaleRegistrations() {
-	if (!isStorageAvailable()) return;
 	try {
-		const keysToRemove = [];
-		for (let i = 0; i < sessionStorage.length; i++) {
-			const key = sessionStorage.key(i);
-			if (!key?.startsWith(STORAGE_PREFIX)) continue;
+		Array.from({ length: sessionStorage.length }, (_, index) => sessionStorage.key(index)).filter((item) => item !== null && item.startsWith(STORAGE_PREFIX)).forEach((item) => {
 			try {
-				const stored = sessionStorage.getItem(key);
-				if (!stored) continue;
-				const entry = JSON.parse(stored);
-				const timestamp = typeof entry.timestamp === "number" ? entry.timestamp : NaN;
-				const age = Date.now() - timestamp;
-				if (!Number.isFinite(timestamp) || age > STALE_THRESHOLD_MS) keysToRemove.push(key);
+				const parsed = schema.safeParse(JSON.parse(sessionStorage.getItem(item) ?? "null"));
+				if (!parsed.success || Date.now() - parsed.data.timestamp > STALE_THRESHOLD_MS) sessionStorage.removeItem(item);
 			} catch {
-				keysToRemove.push(key);
+				sessionStorage.removeItem(item);
 			}
-		}
-		for (const key of keysToRemove) sessionStorage.removeItem(key);
-		if (keysToRemove.length > 0) console.info(`[sessionStorage] Cleaned up ${keysToRemove.length} stale entries`);
-	} catch (error) {
-		console.warn("[sessionStorage] Cleanup failed:", error);
-	}
+		});
+	} catch {}
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/constants.ts
+const EVENT_REGISTRATION_ANCHOR_ID = "event-registration";
+const EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM = "registration_attempt";
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationStripeReturn.ts
-const eventRegistrationStripeReturnDeps = {
-	usePaymentVerification,
-	readReturnParams: () => {
-		const params = new URLSearchParams(window.location.search);
-		return {
-			registration: params.get("registration"),
-			registration_attempt: params.get(EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM),
-			session_id: params.get("session_id")
-		};
-	},
-	clearReturnParams: () => {
-		consumeSearchParams([
-			"registration",
-			EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM,
-			"session_id"
-		]);
-	},
-	scrollToBlock,
-	cleanupStaleRegistrations,
-	clearPendingRegistration,
-	getPendingRegistration
-};
-function restorePendingPresentation(options, pending) {
-	options.setFormData(pending.formData);
-	options.setTicketSelections(pending.ticketSelections);
-	options.setTicketsCount(getTicketSelectionTotal(pending.ticketSelections));
-	if (pending.selectedEventId) {
-		const event = options.events.find((item) => item.selectionId === pending.selectedEventId) ?? null;
-		if (event) options.setSelectedEvent(event);
-	}
-	options.setSelectedAttendanceMode(pending.selectedAttendanceMode ?? null);
-	options.setPaymentSelection(pending.paymentSelection);
-}
-function showReturnReconciliation(options, message) {
-	options.setErrorMessage(message);
-	options.setStep("verifying-timeout");
-}
-function checkoutReturnCommand(params) {
-	const checkoutAttemptId = params.registration_attempt;
-	if (!checkoutAttemptId) return null;
-	if (params.registration === "cancelled") return {
-		kind: "abandon",
-		checkoutAttemptId
-	};
-	if (params.registration === "success" && params.session_id) return {
-		kind: "resolveSuccess",
-		checkoutAttemptId,
-		sessionId: params.session_id
-	};
-	return null;
-}
-function handleCheckoutReturnOutcome(options, deps, context, outcome) {
-	const { pending, params } = context;
-	if (outcome.kind === "resolved") {
-		deps.clearReturnParams();
-		options.setPendingRegistrationReference(outcome.reference);
-		options.setStep("verifying-payment");
-		return "settled";
-	}
-	if (outcome.kind === "abandoned") {
-		deps.clearReturnParams();
-		options.setErrorMessage("Your payment was cancelled. You can choose a payment option and try again.");
-		options.setStep("select-payment");
-		return "settled";
-	}
-	if (outcome.kind === "notFound" && params.registration === "cancelled" && (options.registrationSubject?.kind === "occurrence" || pending?.reference.scope === "occurrence")) {
-		deps.clearReturnParams();
-		options.setErrorMessage("Your payment was cancelled. You can choose a payment option and try again.");
-		options.setStep("select-payment");
-		return "settled";
-	}
-	showReturnReconciliation(options, "We’re checking your booking and payment. Please don’t try to book again yet. If you’ve already paid, you don’t need to pay again.");
-	return outcome.kind === "notFound" ? "settled" : "retryable";
-}
-async function handleCheckoutReturn(options, deps, returnContextRef) {
-	deps.cleanupStaleRegistrations();
-	const params = deps.readReturnParams();
-	if (params.registration !== "cancelled" && params.registration !== "success") return "settled";
-	deps.scrollToBlock(EVENT_REGISTRATION_ANCHOR_ID);
-	const siteId = options.api.config.siteId;
-	const command = checkoutReturnCommand(params);
-	if (!siteId) return "settled";
-	if (!command) {
-		showReturnReconciliation(options, "We’re checking your booking and payment. Please don’t try to book again yet. If you’ve already paid, you don’t need to pay again.");
-		return "settled";
-	}
-	const { checkoutAttemptId } = command;
-	const pending = deps.getPendingRegistration(siteId, checkoutAttemptId);
-	returnContextRef.current = {
-		checkoutAttemptId,
-		mailingListSignupNote: pending?.mailingListSignupNote
-	};
-	if (pending) restorePendingPresentation(options, pending);
-	options.setStep("verifying-payment");
-	try {
-		const outcome = await options.api.resolveEventCheckoutReturn(command);
-		return handleCheckoutReturnOutcome(options, deps, {
-			pending,
-			params
-		}, outcome);
-	} catch {
-		showReturnReconciliation(options, "We couldn’t check your payment just now. Please check again in a moment. Don’t make another booking while we’re checking.");
-	}
-	return "retryable";
-}
 function useEventRegistrationStripeReturn(options) {
-	return useEventRegistrationStripeReturnWithDeps(options, eventRegistrationStripeReturnDeps);
-}
-function completeVerifiedRegistration(options, deps, returnContext) {
-	const siteId = options.api.config.siteId;
-	const checkoutAttemptId = returnContext?.checkoutAttemptId;
-	if (siteId && checkoutAttemptId) deps.clearPendingRegistration(siteId, checkoutAttemptId);
-	options.setRegistrationResult({
-		status: "confirmed",
-		mailingListSignupNote: returnContext?.mailingListSignupNote
-	});
-	options.setStep("success");
-}
-function useEventRegistrationStripeReturnWithDeps(options, deps) {
-	const { api, pendingRegistrationReference, setErrorMessage, setRegistrationResult, setStep, step } = options;
-	const returnContextRef = useRef(null);
-	const lookupInFlightRef = useRef(false);
-	const [lookupState, setLookupState] = useState("settled");
-	const resolveReturn = useCallback(async () => {
-		if (lookupInFlightRef.current) return;
-		lookupInFlightRef.current = true;
-		setLookupState("loading");
-		try {
-			setLookupState(await handleCheckoutReturn(options, deps, returnContextRef));
-		} finally {
-			lookupInFlightRef.current = false;
-		}
-	}, [options, deps]);
-	const verificationConfig = useMemo(() => step === "verifying-payment" && pendingRegistrationReference ? { reference: pendingRegistrationReference } : null, [step, pendingRegistrationReference]);
-	const verification = deps.usePaymentVerification(verificationConfig);
-	const hasVerificationTimeout = step === "verifying-timeout" && pendingRegistrationReference !== null;
-	const retry = useCallback(() => {
-		if (hasVerificationTimeout) {
-			setStep("verifying-payment");
-			return;
-		}
-		verification.retry();
-	}, [
-		hasVerificationTimeout,
-		setStep,
-		verification.retry
-	]);
-	useEffect(() => {
-		resolveReturn();
-	}, []);
+	const restored = useRef(false);
 	useEffect(() => {
-		if (verification.status === "completed") completeVerifiedRegistration(options, deps, returnContextRef.current);
-		else if (verification.status === "failed") {
-			setErrorMessage("Please try again or choose another payment option. If this keeps happening, contact the organiser for help.");
-			setStep("payment-failed");
-		} else if (verification.status === "timeout") setStep("verifying-timeout");
-	}, [
-		verification.status,
-		verification.attendeeStatus,
-		verification.waitlistPosition,
-		verification.error,
-		api.config.siteId,
-		setErrorMessage,
-		setRegistrationResult,
-		setStep
-	]);
-	return {
-		...verification,
-		status: hasVerificationTimeout ? "timeout" : verification.status,
-		retry,
-		retryReturn: lookupState === "retryable" ? () => {
-			resolveReturn();
-		} : void 0
-	};
+		if (restored.current) return;
+		restored.current = true;
+		cleanupStaleRegistrations();
+		const params = new URLSearchParams(window.location.search);
+		const checkoutAttemptId = params.get(EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM);
+		const sessionId = params.get("session_id");
+		if (params.get("registration") !== "payment" || !checkoutAttemptId || !sessionId) return;
+		const pending = options.siteId ? getPendingRegistration(options.siteId, checkoutAttemptId) : null;
+		if (pending) options.restore(pending);
+		options.verify({
+			kind: "resolveSession",
+			checkoutAttemptId,
+			sessionId
+		});
+	}, [options]);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/paymentLocation.ts
+function eventPaymentReturnUrl(submissionId) {
+	const url = new URL(window.location.href);
+	url.searchParams.set("registration", "payment");
+	url.searchParams.set(EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM, submissionId);
+	url.searchParams.delete("session_id");
+	url.hash = EVENT_REGISTRATION_ANCHOR_ID;
+	return url.toString();
+}
+function rememberEventPayment(submissionId, sessionId) {
+	const url = new URL(eventPaymentReturnUrl(submissionId));
+	url.searchParams.set("session_id", sessionId);
+	window.history.replaceState(window.history.state, "", url);
+}
+function clearEventPayment(siteId) {
+	const url = new URL(window.location.href);
+	const submissionId = url.searchParams.get(EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM);
+	if (siteId && submissionId) clearPendingRegistration(siteId, submissionId);
+	url.searchParams.delete("registration");
+	url.searchParams.delete(EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM);
+	url.searchParams.delete("session_id");
+	window.history.replaceState(window.history.state, "", url);
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationErrorPresentation.ts
@@ -1771,7 +1743,7 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 	*/
 	const { commandRef } = options;
 	const inFlightRef = useRef(null);
-	const submit = async (method, passId, membershipId, selection, submitOptions) => {
+	const submit = async (method, passId, membershipId, selection) => {
 		const target = options.registrationTarget;
 		if (!target) return {
 			ok: false,
@@ -1781,25 +1753,21 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 		options.setStep("submitting");
 		const registrationCommandId = commandRef.current?.id ?? deps.createClientCommandId();
 		try {
-			let prepared = prepareSubmitContext(options, registrationCommandId, target, method, passId, membershipId, selection);
-			let request = buildRegistrationRequest(options, prepared, method, passId, membershipId);
-			const intentKey = registrationRequestIntentKey(request);
-			if (commandRef.current !== null && commandRef.current.intentKey !== intentKey) {
-				prepared = {
-					...prepared,
-					registrationCommandId: deps.createClientCommandId()
-				};
-				request = buildRegistrationRequest(options, prepared, method, passId, membershipId);
-			}
+			const initialPrepared = prepareSubmitContext(options, registrationCommandId, target, method, passId, membershipId, selection);
+			const intentKey = registrationRequestIntentKey(buildRegistrationRequest(options, initialPrepared, method, passId, membershipId));
+			const prepared = commandRef.current !== null && commandRef.current.intentKey !== intentKey ? {
+				...initialPrepared,
+				registrationCommandId: deps.createClientCommandId()
+			} : initialPrepared;
+			const request = buildRegistrationRequest(options, prepared, method, passId, membershipId);
 			commandRef.current = {
 				id: prepared.registrationCommandId,
 				intentKey
 			};
-			const result = await options.api.registerForEvent({
+			return await completeRegistrationSubmission(options, deps, prepared, await options.api.registerForEvent({
 				...request,
 				registrationCommandId: prepared.registrationCommandId
-			});
-			return await completeRegistrationSubmission(options, deps, prepared, result, submitOptions);
+			}));
 		} catch (error) {
 			if (error instanceof BlockApiError && error.tag === "registrationPreparationChanged") commandRef.current = null;
 			const { message, action } = registrationErrorPresentation(error);
@@ -1823,7 +1791,7 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 		return pending;
 	};
 }
-async function completeRegistrationSubmission(options, deps, prepared, result, submitOptions) {
+async function completeRegistrationSubmission(options, deps, prepared, result) {
 	if (result.demoBookingPass) storeDemoBookingPass(options.formData.email, result.demoBookingPass);
 	switch (result.kind) {
 		case "paymentStatusRequired":
@@ -1838,10 +1806,24 @@ async function completeRegistrationSubmission(options, deps, prepared, result, s
 				outcome: { kind: "payment_status" }
 			};
 		case "checkoutRequired":
-			options.setPendingRegistrationReference(result.reference);
 			savePendingCheckout(options, deps, prepared, result.submissionId, result.reference, result.mailingListSignupNote);
-			options.setStep("redirecting");
-			return redirectToCheckout(result.checkoutUrl, submitOptions);
+			const subject = result.reference.scope === "occurrence" ? {
+				scope: "occurrence",
+				attendeeId: result.reference.attendeeId,
+				submissionId: result.submissionId
+			} : {
+				scope: "wholeSeries",
+				submissionId: result.submissionId
+			};
+			options.openPayment(result.checkout, subject, result.mailingListSignupNote);
+			return {
+				ok: true,
+				outcome: {
+					kind: "checkout_ready",
+					checkout: result.checkout,
+					subject
+				}
+			};
 		case "waitlisted":
 			options.setRegistrationResult({
 				status: "waitlist",
@@ -1853,7 +1835,6 @@ async function completeRegistrationSubmission(options, deps, prepared, result, s
 			break;
 		case "bookingComplete":
 		case "paymentDeferred":
-			options.setPendingRegistrationReference(result.reference);
 			options.setRegistrationResult({
 				status: "confirmed",
 				message: result.summary.paymentMethod === "pass" ? result.summary.message : void 0,
@@ -1926,19 +1907,12 @@ function savePendingCheckout(options, deps, prepared, checkoutAttemptId, referen
 		selectedEventId: options.registrationTarget?.selectedEventId ?? null,
 		selectedAttendanceMode: options.selectedAttendanceMode,
 		paymentSelection: prepared.selectionSnapshot,
+		guests: options.guests,
+		selectedSlidingAmount: options.selectedSlidingAmount,
+		discountCode: options.discountCode,
 		mailingListSignupNote
 	});
 }
-function redirectToCheckout(checkoutUrl, submitOptions) {
-	if (submitOptions?.redirect !== "manual") window.location.href = checkoutUrl;
-	return {
-		ok: true,
-		outcome: {
-			kind: "checkout_redirect",
-			checkoutUrl
-		}
-	};
-}
 function registrationRequestIntentKey(request) {
 	const { registrationCommandId: _command, altchaSolution: _proof, mailingListOptIn: _marketingConsent, checkout, ...intent } = request;
 	return JSON.stringify({
@@ -1953,7 +1927,7 @@ function buildRegistrationRequest(options, prepared, method, passId, membershipI
 	return {
 		registrationCommandId: prepared.registrationCommandId,
 		checkout: {
-			...buildCheckoutReturnUrls("registration", EVENT_REGISTRATION_ANCHOR_ID, { [EVENT_REGISTRATION_CHECKOUT_ATTEMPT_PARAM]: prepared.registrationCommandId }),
+			returnUrl: eventPaymentReturnUrl(prepared.registrationCommandId),
 			discountCode: options.discountCode.trim() || void 0,
 			collectionOptionKind: prepared.selectionSnapshot.method === "stripe" ? prepared.selectionSnapshot.collectionOptionKind : void 0
 		},
@@ -2075,7 +2049,7 @@ function getRegistrationOccurrenceId(target) {
 	return target?.subject.kind === "occurrence" ? target.subject.occurrenceId : "";
 }
 function shouldLoadRegistrationOptions(authState, step) {
-	return authState === "authenticated" || step === "select-tickets" || step === "enter-details" || step === "select-payment";
+	return authState === "authenticated" || step === "select-tickets" || step === "fully-booked" || step === "enter-details" || step === "select-payment";
 }
 function getEligibilityFlowFlags(input) {
 	const hasPass = (input.eligibility?.eligiblePasses.length ?? 0) > 0;
@@ -2174,132 +2148,544 @@ function useWaitlistClaimRestoration(input) {
 	]);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/registrationCompletion.ts
-function isSelectionSoldOut(availability) {
-	return availability?.kind === "unavailable" && availability.reason === "full";
-}
-function resolveRegistrationAvailabilityBlocker(input) {
-	if (input.hasWaitlistClaim) return null;
-	if (input.eligibilityError) return input.eligibilityError;
-	if (!input.eligibility) return "Registration is not available for this event.";
-	if (input.eligibility.registration.kind === "pending_payment") return null;
-	if (isSelectionSoldOut(input.eligibility.availability)) return null;
-	if (input.eligibility.availability.kind === "unavailable" && input.eligibility.availability.reason === "paymentUnavailable") return "Payment options are not available for this event.";
-	if (input.eligibility.availability.kind === "unavailable" || input.eligibility.registration.kind === "waitlisted") return "Registration is not available for this event.";
-	return null;
+//#region ../blocks/src/system/runtime/nodes/event-registration/useGuestRegistrationRecovery.ts
+/** Guest email is navigation permission only. Discard checks when the visitor
+* changes identity or selection before the response arrives. */
+function useGuestRegistrationRecovery(input) {
+	const [checkingNextStep, setCheckingNextStep] = useState(false);
+	const [recoveryMessage, setRecoveryMessage] = useState(null);
+	const request = guestNextStepRequest(input);
+	const requestKey = JSON.stringify([
+		request,
+		input.step,
+		input.portalAuthState,
+		input.admission
+	]);
+	const currentRequest = useRef(requestKey);
+	currentRequest.current = requestKey;
+	const checkDetailsNextStep = () => checkGuestNextStep(input, request, setCheckingNextStep);
+	const handleRecoveryEmail = () => recoverByEmail({
+		...input,
+		checkingNextStep,
+		check: checkDetailsNextStep,
+		setRecoveryMessage,
+		isCurrent: () => currentRequest.current === requestKey
+	});
+	return {
+		checkingNextStep,
+		recoveryMessage,
+		checkDetailsNextStep,
+		handleRecoveryEmail
+	};
 }
-function resolvePricingSelectionBlocker(input) {
-	if (input.selectionRequired && !input.hasValidSelection) return "Choose at least one available ticket to continue.";
-	return input.slidingScaleSelectionMessage;
+async function checkGuestNextStep(input, request, setCheckingNextStep) {
+	const plan = resolveGuestNextStepCheck(input.admission, request);
+	switch (plan.kind) {
+		case "skip": return plan.outcome;
+		case "blocked": return {
+			kind: "unavailable",
+			message: plan.message
+		};
+		case "check": break;
+	}
+	setCheckingNextStep(true);
+	try {
+		return await input.api.checkRegistrationNextStep(plan.request);
+	} catch {
+		return {
+			kind: "unavailable",
+			message: "We could not check availability. Please try again."
+		};
+	} finally {
+		setCheckingNextStep(false);
+	}
+}
+async function recoverByEmail(input) {
+	if (input.checkingNextStep) return {
+		ok: false,
+		reason: "blocked",
+		message: "Your booking is being checked."
+	};
+	const emailError = validateFormData(input.formData).email;
+	input.setErrors(emailError ? { email: emailError } : {});
+	input.setRecoveryMessage(null);
+	if (emailError) return {
+		ok: false,
+		reason: "validation-failed",
+		message: emailError
+	};
+	const next = await input.check();
+	if (!input.isCurrent()) return {
+		ok: false,
+		reason: "blocked",
+		message: "Your booking details changed. Please check again."
+	};
+	switch (next.kind) {
+		case "continue":
+		case "waitlist":
+			input.onRecoveryChecked(next);
+			return { ok: true };
+		case "unavailable":
+			input.setRecoveryMessage(next.message);
+			return {
+				ok: false,
+				reason: "blocked",
+				message: next.message
+			};
+	}
+}
+function guestNextStepRequest(input) {
+	return input.registrationTarget ? {
+		subject: toRegistrationRequestSubject(input.registrationTarget.subject, input.selectedAttendanceMode),
+		selections: input.ticketSelections,
+		selectedSlidingAmount: input.selectedSlidingAmount ?? void 0,
+		email: input.formData.email,
+		altchaSolution: input.altchaSolution
+	} : null;
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/usePaymentStatusRecovery.ts
-function isCheckableRecovery(state) {
-	return state.kind === "ready" || state.kind === "processing" || state.kind === "temporarilyUnavailable";
+//#region ../blocks/src/system/runtime/nodes/event-registration/paymentResponse.ts
+/**
+* Verified response identity owns every follow-up action, including storage-free returns.
+* `requested` is the subject the client sent, if any: a subject-bound `notFound`
+* means the server lost that booking, which no amount of re-checking will fix.
+*/
+function planPaymentResponse(response, intent, requested) {
+	switch (response.kind) {
+		case "checkout": return planCheckoutOutcome(response, intent);
+		case "notFound": return requested ? assistance(requested) : { kind: "unresolved" };
+		case "reconciliationRequired": return { kind: "unresolved" };
+		default: return assertNever(response);
+	}
 }
-function assistanceRequired(recovery) {
+function assistance(subject) {
 	return {
-		kind: "assistanceRequired",
-		subject: recovery.subject,
-		mailingListSignupNote: recovery.mailingListSignupNote
+		kind: "recovery",
+		state: {
+			kind: "assistanceRequired",
+			subject
+		}
 	};
 }
-function applyStatusOutcome(outcome, recovery, setters, setRecovery) {
-	if (outcome.kind === "resolved") {
-		setters.setPendingRegistrationReference(outcome.reference);
-		setters.setRegistrationResult({
-			status: "confirmed",
-			mailingListSignupNote: recovery.mailingListSignupNote
-		});
-		setRecovery(null);
-		setters.setStep("success");
-		return;
+function planCheckoutOutcome({ outcome, subject }, intent) {
+	switch (outcome.kind) {
+		case "resolved": return { kind: "confirmed" };
+		case "paymentAvailable": return intent === "resume" ? {
+			kind: "payment",
+			checkout: outcome.checkout,
+			subject
+		} : {
+			kind: "recovery",
+			state: {
+				kind: "paymentAvailable",
+				checkout: outcome.checkout,
+				subject
+			}
+		};
+		case "abandoned":
+		case "paymentRetryAvailable": return intent === "abandon" ? { kind: "restartBooking" } : {
+			kind: "recovery",
+			state: {
+				kind: "retryAvailable",
+				subject
+			}
+		};
+		case "paymentProcessing": return {
+			kind: "recovery",
+			state: {
+				kind: "processing",
+				subject
+			}
+		};
+		case "paymentCheckUnavailable": return {
+			kind: "recovery",
+			state: {
+				kind: "temporarilyUnavailable",
+				subject
+			}
+		};
+		case "reconciliationRequired":
+		case "paymentAssistanceRequired": return assistance(subject);
+		default: return assertNever(outcome);
+	}
+}
+function paymentCheckEvidence(result) {
+	switch (result.kind) {
+		case "unreachable": return { kind: "inconclusive" };
+		case "notFound": return { kind: "bindingLost" };
+		case "reconciliationRequired": return { kind: "paymentUnderway" };
+		case "checkout": return checkoutEvidence(result);
+		default: return assertNever(result);
 	}
+}
+function checkoutEvidence(response) {
+	const { outcome } = response;
 	switch (outcome.kind) {
+		case "paymentCheckUnavailable": return { kind: "inconclusive" };
+		case "paymentAvailable": return {
+			kind: "payable",
+			checkout: outcome.checkout,
+			response
+		};
 		case "paymentProcessing":
-			setRecovery({
-				...recovery,
-				kind: "processing"
-			});
-			return;
-		case "paymentAvailable":
-			setRecovery({
-				...recovery,
-				kind: "paymentAvailable",
-				checkoutUrl: outcome.checkoutUrl
-			});
-			return;
-		case "paymentCheckUnavailable":
-			setRecovery({
-				...recovery,
-				kind: "temporarilyUnavailable"
-			});
-			return;
+		case "reconciliationRequired": return { kind: "paymentUnderway" };
+		case "resolved":
+		case "abandoned":
 		case "paymentRetryAvailable":
-			setRecovery({
-				...recovery,
-				kind: "retryAvailable"
+		case "paymentAssistanceRequired": return {
+			kind: "terminal",
+			response
+		};
+		default: return assertNever(outcome);
+	}
+}
+function planMountedPaymentRefresh(result, mounted) {
+	const evidence = paymentCheckEvidence(result);
+	switch (evidence.kind) {
+		case "inconclusive": return { kind: "stay" };
+		case "paymentUnderway": return { kind: "poll" };
+		case "bindingLost": return {
+			kind: "leave",
+			transition: assistance(mounted.subject)
+		};
+		case "payable": return evidence.checkout.sessionId === mounted.sessionId ? { kind: "stay" } : {
+			kind: "leave",
+			transition: planCheckoutOutcome(evidence.response, "resume")
+		};
+		case "terminal": return {
+			kind: "leave",
+			transition: planCheckoutOutcome(evidence.response, "check")
+		};
+		default: return assertNever(evidence);
+	}
+}
+function paymentResponseNeedsPolling(response) {
+	if (response.kind !== "checkout") return response.kind === "reconciliationRequired";
+	return paymentOutcomeNeedsPolling(response.outcome);
+}
+function paymentOutcomeNeedsPolling(outcome) {
+	return outcome.kind === "paymentProcessing" || outcome.kind === "reconciliationRequired" || outcome.kind === "paymentCheckUnavailable";
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/usePaymentStatusRecovery.ts
+function usePaymentRuntime() {
+	const [state, setState] = useState({ kind: "idle" });
+	const note = useRef(void 0);
+	const operation = useRef(null);
+	const generation = useRef(0);
+	const appliedResult = useRef(null);
+	const current = useRef(state);
+	current.current = state;
+	useEffect(() => () => {
+		generation.current += 1;
+	}, []);
+	return {
+		state,
+		setState,
+		note,
+		operation,
+		generation,
+		appliedResult,
+		current
+	};
+}
+function usePaymentTransitions(options, runtime) {
+	const { setState, note, generation, operation } = runtime;
+	const openPayment = useCallback((checkout, subject, mailingListSignupNote) => {
+		if (mailingListSignupNote) note.current = mailingListSignupNote;
+		rememberEventPayment(subject.submissionId, checkout.sessionId);
+		setState({
+			kind: "payment",
+			checkout,
+			subject
+		});
+		options.setStep("payment");
+	}, [
+		options.setStep,
+		setState,
+		note
+	]);
+	const verify = useCallback((request, resumePayment = true) => {
+		if (operation.current) return;
+		generation.current += 1;
+		setState({
+			kind: "verifying",
+			request,
+			resumePayment
+		});
+		options.setStep("verifying-payment");
+	}, [
+		options.setStep,
+		operation,
+		generation,
+		setState
+	]);
+	const restartFrom = useCallback((step) => {
+		clearEventPayment(options.api.config.siteId);
+		options.beginNewSubmission();
+		setState({ kind: "idle" });
+		options.setOptionsRefreshKey((value) => value + 1);
+		options.setStep(step);
+	}, [options, setState]);
+	const resetBooking = useCallback(() => restartFrom("select-tickets"), [restartFrom]);
+	const returnToPaymentOptions = useCallback(() => restartFrom(options.detailsInPage() ? "select-payment" : "select-tickets"), [restartFrom, options]);
+	const applyTransition = useCallback((transition) => {
+		switch (transition.kind) {
+			case "confirmed":
+				options.setRegistrationResult({
+					status: "confirmed",
+					mailingListSignupNote: note.current
+				});
+				clearEventPayment(options.api.config.siteId);
+				setState({ kind: "idle" });
+				options.setStep("success");
+				return;
+			case "payment": return openPayment(transition.checkout, transition.subject);
+			case "restartBooking": return resetBooking();
+			case "recovery":
+				setState({
+					kind: "recovery",
+					state: {
+						...transition.state,
+						mailingListSignupNote: note.current
+					}
+				});
+				options.setStep("payment-status");
+				return;
+			case "unresolved": return options.setStep("verifying-timeout");
+			default: return assertNever(transition);
+		}
+	}, [
+		openPayment,
+		resetBooking,
+		options,
+		setState,
+		note
+	]);
+	return {
+		openPayment,
+		verify,
+		applyOutcome: useCallback((response, intent, requested) => applyTransition(planPaymentResponse(response, intent, requested)), [applyTransition]),
+		applyTransition,
+		resetBooking,
+		returnToPaymentOptions
+	};
+}
+/** A session-only return has no client subject; the server's envelope must supply one. */
+function requestedSubject(request) {
+	return request.kind === "resolveSession" ? null : request.subject;
+}
+function usePaymentChecks(options, runtime, transitions) {
+	const { state, appliedResult, current } = runtime;
+	const request = state.kind === "verifying" ? state.request : null;
+	const polling = usePolling(request ? {
+		restartKey: JSON.stringify(request),
+		pollFn: () => options.api.resolveEventCheckoutReturn(request),
+		isComplete: (result) => !paymentResponseNeedsPolling(result),
+		maxAttempts: 10,
+		interval: 1e3
+	} : null);
+	useEffect(() => {
+		if (polling.status === "completed" && polling.result && request && appliedResult.current !== polling.result) {
+			appliedResult.current = polling.result;
+			transitions.applyOutcome(polling.result, state.kind === "verifying" && state.resumePayment ? "resume" : "check", requestedSubject(request));
+		} else if (polling.status === "timeout") options.setStep("verifying-timeout");
+	}, [
+		polling.status,
+		polling.result,
+		request,
+		transitions.applyOutcome,
+		options.setStep,
+		appliedResult
+	]);
+	const check = useCallback((resumePayment = false) => {
+		appliedResult.current = null;
+		const active = current.current;
+		if (active.kind === "payment") transitions.verify({
+			kind: "checkStatus",
+			subject: active.subject
+		}, resumePayment);
+		else if (active.kind === "recovery") transitions.verify({
+			kind: "checkStatus",
+			subject: active.state.subject
+		}, resumePayment);
+		else if (active.kind === "verifying") {
+			options.setStep("verifying-payment");
+			polling.retry();
+		}
+	}, [
+		transitions.verify,
+		polling.retry,
+		options.setStep,
+		appliedResult,
+		current
+	]);
+	const checkStatus = useCallback(() => check(), [check]);
+	return {
+		check: checkStatus,
+		retryPaymentLoad: useCallback(() => check(true), [check]),
+		verification: {
+			...polling,
+			retry: checkStatus,
+			retryReturn: checkStatus
+		}
+	};
+}
+function usePaymentAbandonment(options, runtime, transitions) {
+	const { operation, generation, current, setState } = runtime;
+	return useCallback(() => {
+		if (operation.current) return operation.current;
+		const active = current.current;
+		if (active.kind !== "payment") return Promise.resolve();
+		const token = ++generation.current;
+		setState({
+			kind: "abandoning",
+			subject: active.subject
+		});
+		const pending = options.api.resolveEventCheckoutReturn({
+			kind: "abandon",
+			subject: active.subject
+		}).then((outcome) => {
+			if (token !== generation.current) return;
+			transitions.applyOutcome(outcome, "abandon", active.subject);
+		}).catch(() => {
+			if (token !== generation.current) return;
+			setState({
+				kind: "recovery",
+				state: {
+					kind: "temporarilyUnavailable",
+					subject: active.subject,
+					mailingListSignupNote: runtime.note.current
+				}
+			});
+			options.setStep("payment-status");
+		});
+		operation.current = pending;
+		pending.finally(() => {
+			if (operation.current === pending) operation.current = null;
+		});
+		return pending;
+	}, [
+		options.api,
+		transitions.applyOutcome,
+		operation,
+		generation,
+		current,
+		setState,
+		options.setStep,
+		runtime.note
+	]);
+}
+/**
+* Returning to the tab (often from a banking app mid-authentication) must not
+* unmount Stripe on inconclusive evidence; `planMountedPaymentRefresh` decides.
+*/
+function usePaymentBackgroundCheck(options, runtime, transitions) {
+	const { current, generation, operation } = runtime;
+	const inFlight = useRef(false);
+	return useCallback(() => {
+		const active = current.current;
+		if (active.kind !== "payment" || operation.current || inFlight.current) return;
+		const token = generation.current;
+		inFlight.current = true;
+		const request = {
+			kind: "checkStatus",
+			subject: active.subject
+		};
+		const unreachable = { kind: "unreachable" };
+		options.api.resolveEventCheckoutReturn(request).catch(() => unreachable).then((result) => {
+			if (token !== generation.current || current.current !== active) return;
+			const refresh = planMountedPaymentRefresh(result, {
+				sessionId: active.checkout.sessionId,
+				subject: active.subject
 			});
-			return;
-		case "abandoned":
-		case "notFound":
-		case "reconciliationRequired":
-		case "paymentAssistanceRequired":
-			setRecovery(assistanceRequired(recovery));
-			return;
-	}
+			switch (refresh.kind) {
+				case "stay": return;
+				case "poll": return transitions.verify(request, false);
+				case "leave": return transitions.applyTransition(refresh.transition);
+				default: return assertNever(refresh);
+			}
+		}).finally(() => {
+			inFlight.current = false;
+		});
+	}, [
+		options.api,
+		transitions.verify,
+		transitions.applyTransition,
+		current,
+		generation,
+		operation
+	]);
+}
+function usePaymentRefresh(state, check) {
+	useEffect(() => {
+		if (state.kind !== "payment") return;
+		const timeout = window.setTimeout(check, Math.max(0, Date.parse(state.checkout.expiresAt) - Date.now()));
+		const visible = () => {
+			if (document.visibilityState === "visible") check();
+		};
+		const restored = (event) => {
+			if (event.persisted) check();
+		};
+		document.addEventListener("visibilitychange", visible);
+		window.addEventListener("pageshow", restored);
+		return () => {
+			clearTimeout(timeout);
+			document.removeEventListener("visibilitychange", visible);
+			window.removeEventListener("pageshow", restored);
+		};
+	}, [state, check]);
 }
 function usePaymentStatusRecovery(options) {
-	const [recovery, setRecovery] = useState(null);
-	const checkRef = useRef(null);
+	const runtime = usePaymentRuntime();
+	const transitions = usePaymentTransitions(options, runtime);
+	const checks = usePaymentChecks(options, runtime, transitions);
+	const backToBooking = usePaymentAbandonment(options, runtime, transitions);
+	const backgroundCheck = usePaymentBackgroundCheck(options, runtime, transitions);
+	const { state, setState, generation, note } = runtime;
+	usePaymentRefresh(state, backgroundCheck);
+	const recovery = state.kind === "recovery" ? state.state : null;
 	return {
+		state,
 		recovery,
-		showRecovery: useCallback((next) => setRecovery(next), []),
-		check: useCallback(() => {
-			if (!recovery || !isCheckableRecovery(recovery) || checkRef.current) return;
-			const pending = (async () => {
-				setRecovery({
-					...recovery,
-					kind: "checking"
-				});
-				try {
-					applyStatusOutcome(await options.api.resolveEventCheckoutReturn({
-						kind: "checkStatus",
-						subject: recovery.subject
-					}), recovery, options, setRecovery);
-				} catch {
-					setRecovery({
-						...recovery,
-						kind: "temporarilyUnavailable"
-					});
-				}
-			})();
-			checkRef.current = pending;
-			pending.finally(() => {
-				if (checkRef.current === pending) checkRef.current = null;
-			});
-		}, [options, recovery]),
-		continuePayment: useCallback(() => {
-			if (recovery?.kind === "paymentAvailable") window.location.assign(recovery.checkoutUrl);
-		}, [recovery]),
-		returnToPayment: useCallback(() => {
-			if (recovery?.kind !== "retryAvailable") return;
-			options.beginNewSubmission();
-			setRecovery(null);
-			options.setOptionsRefreshKey((value) => value + 1);
-			options.setStep("select-payment");
-		}, [options, recovery]),
-		returnToBooking: useCallback(() => {
-			if (recovery?.kind !== "assistanceRequired") return;
-			options.beginNewSubmission();
-			setRecovery(null);
-			options.setOptionsRefreshKey((value) => value + 1);
-			options.setStep("select-tickets");
-		}, [options, recovery])
+		showRecovery: useCallback((next) => {
+			generation.current += 1;
+			note.current = next?.mailingListSignupNote;
+			setState(next ? {
+				kind: "recovery",
+				state: next
+			} : { kind: "idle" });
+		}, [
+			generation,
+			note,
+			setState
+		]),
+		restoreMailingListNote: (value) => {
+			note.current = value;
+		},
+		openPayment: transitions.openPayment,
+		verify: transitions.verify,
+		...checks,
+		backToBooking,
+		continuePayment: () => {
+			if (recovery?.kind === "paymentAvailable") transitions.openPayment(recovery.checkout, recovery.subject);
+		},
+		returnToPayment: () => {
+			if (recovery?.kind === "retryAvailable") transitions.returnToPaymentOptions();
+		},
+		returnToBooking: () => {
+			if (recovery?.kind === "retryAvailable") transitions.resetBooking();
+		}
 	};
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.ts
+function resolveAvailableAttendanceMode(event, selected) {
+	if (!event) return null;
+	const mode = event.deliveryMode ?? "in_person";
+	if (mode === "online" || mode === "in_person") return mode;
+	return selected && event.attendanceModes?.some((item) => item.mode === selected) ? selected : null;
+}
 function usesTieredPricing(event) {
 	return event !== null && event !== void 0 ? publicEventPricingStrategy(event.pricing) === "tiered" : false;
 }
@@ -2357,19 +2743,24 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	const [errorAction, setErrorAction] = useState("retry");
 	const [optionsRefreshKey, setOptionsRefreshKey] = useState(0);
 	const [altchaSolution, setAltchaSolution] = useState(null);
-	const [checkingNextStep, setCheckingNextStep] = useState(false);
 	const { authState: portalAuthState, profile: portalProfile } = deps.usePortalAuth();
 	const waitlistClaim = deps.useWaitlistClaim();
 	const [showMagicLinkModal, setShowMagicLinkModal] = useState(false);
-	const [pendingRegistrationReference, setPendingRegistrationReference] = useState(null);
 	const [paymentStepState, setPaymentStepState] = useState({
 		status: "loading",
 		canContinue: false,
 		buttonText: "Continue",
 		showLoginPrompt: false
 	});
+	const selectionLocked = [
+		"payment",
+		"submitting",
+		"verifying-payment",
+		"verifying-timeout",
+		"payment-status"
+	].includes(step);
 	useEffect(() => {
-		if (portalAuthState !== "authenticated" || !portalProfile) return;
+		if (selectionLocked || portalAuthState !== "authenticated" || !portalProfile) return;
 		setFormData((prev) => ({
 			...prev,
 			email: portalProfile.email,
@@ -2391,16 +2782,17 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			step: nextStep
 		});
 	}, []);
-	const { recovery: paymentStatusRecovery, showRecovery: setPaymentStatusRecovery, check: handleCheckPaymentStatus, continuePayment: handleContinueExistingPayment, returnToPayment: handleReturnToPayment, returnToBooking: handleReturnToBooking } = usePaymentStatusRecovery({
+	const paymentController = usePaymentStatusRecovery({
 		api,
 		beginNewSubmission: () => {
 			commandRef.current = null;
 		},
-		setPendingRegistrationReference,
 		setRegistrationResult,
 		setOptionsRefreshKey,
-		setStep
+		setStep,
+		detailsInPage: () => Object.keys(validateFormData(formData)).length === 0
 	});
+	const { recovery: paymentStatusRecovery, showRecovery: setPaymentStatusRecovery, check: handleCheckPaymentStatus, continuePayment: handleContinueExistingPayment, returnToPayment: handleReturnToPayment, returnToBooking: handleReturnToBooking } = paymentController;
 	const usesTicketTypeSelections = usesTieredPricing(currentEvent);
 	const eventTicketTypesForSelection = useMemo(() => getVisibleTicketTypes({
 		event: currentEvent,
@@ -2502,26 +2894,14 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		});
 	}, [portalAuthState]);
 	useEffect(() => {
-		const event = selectedEvent ?? preSelectedEvent;
-		if (!event) {
-			if (selectedAttendanceMode !== null) setSelectedAttendanceMode(null);
-			return;
-		}
-		const deliveryMode = event.deliveryMode ?? "in_person";
-		if (deliveryMode === "online") {
-			if (selectedAttendanceMode !== "online") setSelectedAttendanceMode("online");
-			return;
-		}
-		if (deliveryMode === "in_person") {
-			if (selectedAttendanceMode !== "in_person") setSelectedAttendanceMode("in_person");
-			return;
-		}
-		if (selectedAttendanceMode && (event.attendanceModes ?? []).some((mode) => mode.mode === selectedAttendanceMode)) return;
-		setSelectedAttendanceMode(null);
+		if (selectionLocked) return;
+		const next = resolveAvailableAttendanceMode(selectedEvent ?? preSelectedEvent, selectedAttendanceMode);
+		if (next !== selectedAttendanceMode) setSelectedAttendanceMode(next);
 	}, [
 		preSelectedEvent,
 		selectedAttendanceMode,
-		selectedEvent
+		selectedEvent,
+		selectionLocked
 	]);
 	useEffect(() => {
 		dispatchFlow({
@@ -2529,25 +2909,26 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			eligibility
 		});
 	}, [eligibility]);
-	const verification = deps.useEventRegistrationStripeReturn({
-		api,
-		events: registrationEvents,
-		registrationSubject: registrationTarget?.subject ?? null,
-		step,
-		pendingRegistrationReference,
-		setFormData,
-		setTicketsCount,
-		setSelectedEvent,
-		setSelectedAttendanceMode,
-		setTicketSelections: (lines) => setSelectedTicketLines(normalizeTicketSelectionLines(lines)),
-		setPaymentSelection: (selection) => dispatchFlow({
-			type: "set-manual-payment-selection",
-			selection
-		}),
-		setPendingRegistrationReference,
-		setStep,
-		setRegistrationResult: (result) => setRegistrationResult(result),
-		setErrorMessage
+	const verification = paymentController.verification;
+	deps.useEventRegistrationStripeReturn({
+		siteId: api.config.siteId,
+		verify: paymentController.verify,
+		restore: (pending) => {
+			paymentController.restoreMailingListNote(pending.mailingListSignupNote);
+			setFormData(pending.formData);
+			setSelectedTicketLines(pending.ticketSelections);
+			setTicketsCount(getTicketSelectionTotal(pending.ticketSelections));
+			setGuests(pending.guests);
+			discountUi.setDiscountCode(pending.discountCode);
+			setSelectedSlidingAmountInput(pending.selectedSlidingAmount === null ? "" : formatCentsAsCurrencyInput(pending.selectedSlidingAmount));
+			setSelectedAttendanceMode(pending.selectedAttendanceMode ?? null);
+			const event = registrationEvents.find((item) => item.selectionId === pending.selectedEventId);
+			if (event) setSelectedEvent(event);
+			dispatchFlow({
+				type: "set-manual-payment-selection",
+				selection: pending.paymentSelection
+			});
+		}
 	});
 	const requireGuestDetails = useMemo(() => {
 		return (selectedEvent ?? preSelectedEvent)?.requireGuestDetails === true;
@@ -2591,6 +2972,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		visibleOptions: visibleTicketTypes
 	});
 	useEffect(() => {
+		if (selectionLocked) return;
 		if (!usesTicketTypeSelections) {
 			if (selectedTicketLines.length > 0) setSelectedTicketLines([]);
 			return;
@@ -2613,6 +2995,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		usesTicketTypeSelections
 	]);
 	useEffect(() => {
+		if (selectionLocked) return;
 		if (!requireGuestDetails) {
 			if (guests.length > 0) setGuests([]);
 			return;
@@ -2622,19 +3005,16 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			if (guests.length > 0) setGuests([]);
 			return;
 		}
-		if (guests.length !== guestCount) {
-			const newGuests = [];
-			for (let i = 0; i < guestCount; i++) newGuests.push(guests[i] ?? {
-				name: "",
-				email: "",
-				phone: ""
-			});
-			setGuests(newGuests);
-		}
+		if (guests.length !== guestCount) setGuests(Array.from({ length: guestCount }, (_, index) => guests[index] ?? {
+			name: "",
+			email: "",
+			phone: ""
+		}));
 	}, [
 		ticketsCount,
 		requireGuestDetails,
-		guests
+		guests,
+		selectionLocked
 	]);
 	const validateForm = () => {
 		const newErrors = validateFormData(formData, Boolean(currentEvent?.consent));
@@ -2663,49 +3043,55 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		selectedEventSlidingScale,
 		selectedSlidingAmount
 	]);
-	const checkDetailsNextStep = async () => {
-		if (portalAuthState === "authenticated" || waitlistClaim.claim || eligibility?.availability.kind === "available" || !registrationTarget) return { kind: canRecoverToWaitlist(eligibility) ? "waitlist" : "continue" };
-		setCheckingNextStep(true);
-		try {
-			return await api.checkRegistrationNextStep({
-				subject: toRegistrationRequestSubject(registrationTarget.subject, selectedAttendanceMode),
-				selections: ticketSelections,
-				selectedSlidingAmount: selectedSlidingAmount ?? void 0,
-				email: formData.email,
-				altchaSolution
-			});
-		} catch {
-			return {
-				kind: "unavailable",
-				message: "We could not check availability. Please try again."
-			};
-		} finally {
-			setCheckingNextStep(false);
-		}
-	};
+	const { admission, ticketContinuation, handleTicketsComplete, onRecoveryChecked } = useRegistrationAdmission({
+		eligibility,
+		eligibilityError,
+		eligibilityLoading,
+		hasWaitlistClaim: waitlistClaim.claim !== null,
+		isAuthenticated: portalAuthState === "authenticated",
+		existingRegistrationLoading: existingRegistrationResult.isLoading,
+		ticketSelectionRequired: ticketTypeSelectionRequired,
+		hasValidTicketSelection,
+		dispatchFlow
+	});
+	const { checkingNextStep, recoveryMessage, checkDetailsNextStep, handleRecoveryEmail } = useGuestRegistrationRecovery({
+		api,
+		formData,
+		onRecoveryChecked,
+		setErrors,
+		admission,
+		step,
+		portalAuthState,
+		registrationTarget,
+		selectedAttendanceMode,
+		ticketSelections,
+		selectedSlidingAmount,
+		altchaSolution
+	});
 	const handleDetailsComplete = async () => {
-		const blockDetailsCompletion = (message) => {
-			setErrorAction("places");
-			setErrorMessage(message);
-			setStep("error");
+		const blockDetailsCompletion = (blocker) => {
+			if (blocker.kind === "unavailable") {
+				setErrorAction("places");
+				setErrorMessage(blocker.message);
+				setStep("error");
+			}
 			return {
 				ok: false,
 				reason: "blocked",
-				message
+				message: blocker.message
 			};
 		};
-		const availabilityBlocker = resolveRegistrationAvailabilityBlocker({
-			hasWaitlistClaim: waitlistClaim.claim !== null,
-			eligibility,
-			eligibilityError
-		});
+		const availabilityBlocker = resolveRegistrationAvailabilityBlocker(admission);
 		if (availabilityBlocker) return blockDetailsCompletion(availabilityBlocker);
 		const pricingSelectionBlocker = resolvePricingSelectionBlocker({
 			selectionRequired: ticketTypeSelectionRequired,
 			hasValidSelection: hasValidTicketSelection,
 			slidingScaleSelectionMessage
 		});
-		if (pricingSelectionBlocker) return blockDetailsCompletion(pricingSelectionBlocker);
+		if (pricingSelectionBlocker) return blockDetailsCompletion({
+			kind: "unavailable",
+			message: pricingSelectionBlocker
+		});
 		if (!validateForm()) {
 			setGuestSectionShake(true);
 			return {
@@ -2715,7 +3101,10 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			};
 		}
 		const next = await checkDetailsNextStep();
-		if (next.kind === "unavailable") return blockDetailsCompletion(next.message);
+		if (next.kind === "unavailable") return blockDetailsCompletion({
+			kind: "unavailable",
+			message: next.message
+		});
 		const canJoinWaitlist = next.kind === "waitlist";
 		if (!canJoinWaitlist && requiresPaymentStep({
 			eventRequiresPayment,
@@ -2732,7 +3121,10 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			eventRequiresPayment,
 			canJoinWaitlist
 		});
-		if (!submitPlan.ok) return blockDetailsCompletion(submitPlan.message);
+		if (!submitPlan.ok) return blockDetailsCompletion({
+			kind: "unavailable",
+			message: submitPlan.message
+		});
 		const submitResult = await handleSubmit(submitPlan.args.method, submitPlan.args.passId, submitPlan.args.membershipId, submitPlan.args.selection);
 		if (!submitResult.ok) return {
 			ok: false,
@@ -2780,6 +3172,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	const selectionMethod = paymentSelection.method;
 	const shouldShowDiscountToggle = discountContext !== null && discountUi.manualCodeEntryAllowed && (selectionMethod === "stripe" || selectionMethod === "pass_bundle" || selectionMethod === "membership_bundle");
 	const handleSubmit = deps.useEventRegistrationSubmit({
+		openPayment: paymentController.openPayment,
 		commandRef,
 		setErrorAction,
 		api,
@@ -2795,7 +3188,6 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		discountCode: discountUi.discountCode,
 		claimToken: waitlistClaim.token,
 		waitlistEntryId: waitlistClaim.entryId,
-		setPendingRegistrationReference,
 		setStep,
 		setRegistrationResult: (result) => setRegistrationResult(result),
 		setErrorMessage,
@@ -2817,7 +3209,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		});
 	};
 	const handleRetry = () => recoverRegistrationError(resolveRegistrationRecoveryAction(step, errorAction), {
-		canJoinWaitlist: canRecoverToWaitlist(eligibility),
+		canJoinWaitlist: admission.kind === "waitlist",
 		refreshOptions: () => setOptionsRefreshKey((value) => value + 1),
 		clearError: () => setErrorMessage(""),
 		setStep,
@@ -2828,8 +3220,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 			setSelectedTicketLines,
 			setSelectedSlidingAmountInput,
 			setSelectedAttendanceMode,
-			setErrorMessage,
-			setPendingRegistrationReference
+			setErrorMessage
 		})
 	});
 	const handlePaymentStepStateChange = useCallback((state) => {
@@ -2860,21 +3251,35 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		preSelectedEvent,
 		hasPreSelectedContext,
 		step,
-		setStep,
+		setStep: (next) => {
+			if (!selectionLocked) setStep(next);
+			else if (step === "payment") paymentController.backToBooking();
+		},
+		admission,
+		ticketContinuation,
+		handleTicketsComplete,
 		selectedEvent,
-		setSelectedEvent,
+		setSelectedEvent: (value) => {
+			if (!selectionLocked) setSelectedEvent(value);
+		},
 		ticketsCount,
-		setTicketsCount,
+		setTicketsCount: (value) => {
+			if (!selectionLocked) setTicketsCount(value);
+		},
 		selectedAttendanceMode,
-		setSelectedAttendanceMode,
+		setSelectedAttendanceMode: (value) => {
+			if (!selectionLocked) setSelectedAttendanceMode(value);
+		},
 		ticketSelections,
 		selectedTicketLines: normalizedSelectedTicketLines,
 		setSelectedTicketLines: (lines) => {
-			if (waitlistClaim.claim) return;
+			if (selectionLocked || waitlistClaim.claim) return;
 			setSelectedTicketLines(normalizeTicketSelectionLines(lines));
 		},
 		selectedSlidingAmountInput,
-		setSelectedSlidingAmountInput,
+		setSelectedSlidingAmountInput: (value) => {
+			if (!selectionLocked) setSelectedSlidingAmountInput(value);
+		},
 		selectedSlidingAmount,
 		selectedEventSlidingScale,
 		slidingScaleSelectionMessage,
@@ -2887,10 +3292,14 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		eventRequiresPayment,
 		formData,
 		mailingListSignup,
-		setFormData,
+		setFormData: (value) => {
+			if (!selectionLocked) setFormData(value);
+		},
 		errors,
 		guests,
-		setGuests,
+		setGuests: (value) => {
+			if (!selectionLocked) setGuests(value);
+		},
 		guestErrors,
 		guestSectionShake,
 		handleGuestShakeEnd,
@@ -2907,7 +3316,9 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		handleLogout,
 		paymentStepState,
 		handlePaymentStepStateChange,
-		handlePaymentSelectionChange,
+		handlePaymentSelectionChange: (value) => {
+			if (!selectionLocked) handlePaymentSelectionChange(value);
+		},
 		paymentSelection,
 		isMembershipFastTrack,
 		waitlistClaim,
@@ -2923,7 +3334,9 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		hasMembershipEligibility,
 		requireGuestDetails,
 		discountCode: discountUi.discountCode,
-		setDiscountCode: discountUi.setDiscountCode,
+		setDiscountCode: (value) => {
+			if (!selectionLocked) discountUi.setDiscountCode(value);
+		},
 		discountUiOpen: discountUi.discountUiOpen,
 		setDiscountUiOpen: discountUi.setDiscountUiOpen,
 		discountsAvailable: discountUi.discountsAvailable,
@@ -2933,49 +3346,31 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		discountContext,
 		shouldShowDiscountToggle,
 		verification,
+		paymentController,
 		paymentStatusRecovery,
 		handleCheckPaymentStatus,
 		handleContinueExistingPayment,
 		handleReturnToPayment,
 		handleReturnToBooking,
+		recoveryMessage,
+		checkingNextStep,
+		handleRecoveryEmail,
 		handleDetailsComplete,
 		handlePaymentSelect,
 		handleUseCardInsteadOfPass,
 		handleBookForSomeoneElse,
-		handleSubmit,
-		handleEventSelect,
+		handleSubmit: (...args) => selectionLocked ? Promise.resolve({
+			ok: false,
+			reason: "blocked",
+			message: "This registration step cannot continue."
+		}) : handleSubmit(...args),
+		handleEventSelect: (value) => {
+			if (!selectionLocked) handleEventSelect(value);
+		},
 		handleRetry
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/useEventCheckoutHandoffRestore.ts
-function eventRegistrationReloadTarget(location) {
-	return `${location.pathname}${location.search}#${EVENT_REGISTRATION_ANCHOR_ID}`;
-}
-function reloadAtEventRegistration() {
-	const target = eventRegistrationReloadTarget(window.location);
-	window.history.replaceState(window.history.state, "", target);
-	window.location.reload();
-}
-const browserCheckoutHandoffRestoreDeps = {
-	addPageShowListener: (listener) => window.addEventListener("pageshow", listener),
-	removePageShowListener: (listener) => window.removeEventListener("pageshow", listener),
-	reloadAtRegistration: reloadAtEventRegistration
-};
-function useEventCheckoutHandoffRestore(active) {
-	useEventCheckoutHandoffRestoreWithDeps(active, browserCheckoutHandoffRestoreDeps);
-}
-function useEventCheckoutHandoffRestoreWithDeps(active, deps) {
-	useEffect(() => {
-		if (!active) return;
-		const handlePageShow = (event) => {
-			if (event.persisted) deps.reloadAtRegistration();
-		};
-		deps.addPageShowListener(handlePageShow);
-		return () => deps.removePageShowListener(handlePageShow);
-	}, [active, deps]);
-}
-//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/EventRegistrationBookingLayer.tsx
 function BookingEntry(props) {
 	const base = props.variant === "teaser" ? "er-booking-teaser" : "er-booking-bar";
@@ -3577,49 +3972,23 @@ function EventRegistrationSummaryBar(props) {
 */
 function resolveDetailsButtonText(input) {
 	const { wizard } = input;
-	const availability = wizard.eligibility?.availability;
-	const full = availability?.kind === "waitlist" || isSelectionSoldOut(availability);
-	if (wizard.portalAuthState !== "authenticated" && full) return "Continue";
-	if (canRecoverToWaitlist(wizard.eligibility)) return "Join waitlist";
-	if (!input.hasWaitlistClaim && full && wizard.eligibility?.registration.kind !== "pending_payment") return "Sold out";
+	const admission = wizard.admission;
+	switch (admission.kind) {
+		case "checking": return "Checking availability...";
+		case "closed": return admission.reason === "alreadyWaitlisted" ? "Already on waitlist" : "Registration unavailable";
+		case "fullyBooked": return admission.recovery === "byEmail" ? "Continue" : "Sold out";
+		case "waitlist": return admission.recovery === "byEmail" ? "Continue" : "Join waitlist";
+		case "open":
+		case "resume": break;
+	}
 	if (wizard.paymentSelection.method === "pass") return "Book using class pass";
 	if (wizard.paymentSelection.method === "membership") return input.fallbackText;
 	return wizard.eventRequiresPayment ? "Continue to payment" : input.fallbackText;
 }
-function resolveExistingRegistrationLabel(wizard) {
-	return wizard.registrationState.kind === "waitlisted" ? "Already on waitlist" : "Already registered";
-}
-function isExistingRegistrationBlocking$1(wizard) {
-	return hasBlockingExistingRegistration({
-		isAuthenticated: wizard.portalAuthState === "authenticated",
-		registration: wizard.registrationState,
-		hasWaitlistClaim: wizard.waitlistClaim.claim !== null
-	});
-}
-function resolveTicketSelectionContinueLabel(input) {
-	if (input.isCheckingExistingRegistration) return "Checking registration...";
-	if (input.ticketTypeSelectionBlocked) return "Choose a ticket";
-	if (input.registrationOptionsPending) return "Checking availability...";
-	if (input.registrationOptionsFailed) return "Availability unavailable";
-	if (input.hasExistingRegistration) return resolveExistingRegistrationLabel(input.wizard);
-	return "Continue";
-}
 function SelectTicketsActions(props) {
 	const { wizard } = props;
-	const ticketTypeSelectionBlocked = wizard.ticketTypeSelectionRequired && !wizard.hasValidTicketSelection;
-	const registrationOptionsPending = !ticketTypeSelectionBlocked && ["idle", "loading"].includes(wizard.registrationOptionsState.tag);
-	const registrationOptionsFailed = wizard.registrationOptionsState.tag === "failed";
-	const isCheckingExistingRegistration = wizard.portalAuthState === "authenticated" && wizard.existingRegistrationLoading;
-	const hasExistingRegistration = isExistingRegistrationBlocking$1(wizard);
-	const isContinueDisabled = registrationOptionsPending || registrationOptionsFailed || isCheckingExistingRegistration || hasExistingRegistration || ticketTypeSelectionBlocked;
-	const continueLabel = resolveTicketSelectionContinueLabel({
-		wizard,
-		registrationOptionsPending,
-		registrationOptionsFailed,
-		isCheckingExistingRegistration,
-		hasExistingRegistration,
-		ticketTypeSelectionBlocked
-	});
+	const { label: continueLabel, pending: registrationOptionsPending } = wizard.ticketContinuation;
+	const isContinueDisabled = wizard.ticketContinuation.kind === "blocked";
 	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-wizard-actions er-actions",
 		children: [!wizard.hasPreSelectedContext && /* @__PURE__ */ jsx("button", {
@@ -3629,7 +3998,7 @@ function SelectTicketsActions(props) {
 			children: "← Back"
 		}), /* @__PURE__ */ jsx(ThemedButton, {
 			type: "button",
-			onClick: () => wizard.setStep("enter-details"),
+			onClick: wizard.handleTicketsComplete,
 			disabled: isContinueDisabled,
 			variant: props.buttonVariant,
 			size: "md",
@@ -3645,18 +4014,11 @@ function SelectTicketsActions(props) {
 }
 function EnterDetailsActions(props) {
 	const { wizard } = props;
-	const hasWaitlistClaim = wizard.waitlistClaim.claim !== null;
 	const isCheckingEligibility = wizard.eligibilityLoading;
-	const eligibilityUnavailable = Boolean(resolveRegistrationAvailabilityBlocker({
-		hasWaitlistClaim,
-		eligibility: wizard.eligibility,
-		eligibilityError: wizard.eligibilityError
-	}));
-	const isSoldOut = !hasWaitlistClaim && wizard.portalAuthState === "authenticated" && wizard.eligibility?.registration.kind !== "pending_payment" && isSelectionSoldOut(wizard.eligibility?.availability);
-	const isContinueDisabled = isCheckingEligibility || eligibilityUnavailable || isSoldOut;
+	const eligibilityUnavailable = Boolean(resolveRegistrationAvailabilityBlocker(wizard.admission));
+	const isContinueDisabled = isCheckingEligibility || eligibilityUnavailable;
 	const continueLabel = isCheckingEligibility ? "Checking availability..." : wizard.eligibilityError ? "Availability unavailable" : eligibilityUnavailable ? "Registration unavailable" : resolveDetailsButtonText({
 		wizard,
-		hasWaitlistClaim,
 		fallbackText: props.buttonText
 	});
 	return /* @__PURE__ */ jsxs("div", {
@@ -3699,10 +4061,11 @@ function SelectPaymentActions(props) {
 function EventRegistrationWizardActions(props) {
 	const { wizard } = props;
 	switch (wizard.step) {
+		case "fully-booked":
 		case "error":
 		case "success":
 		case "submitting":
-		case "redirecting":
+		case "payment":
 		case "verifying-payment":
 		case "verifying-timeout":
 		case "payment-status":
@@ -3715,6 +4078,118 @@ function EventRegistrationWizardActions(props) {
 	}
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/EventRegistrationPayment.tsx
+const Payment = lazy(() => import("./EventEmbeddedCheckoutStep-DL6zFAkA.mjs"));
+/** The one Stripe mount, shared by the standard wizard and headless arrangements. */
+function EventPaymentMount({ state, onComplete, onRetry, onBack }) {
+	if (state.kind === "abandoning") return /* @__PURE__ */ jsx("p", {
+		role: "status",
+		children: "Returning to booking…"
+	});
+	if (state.kind !== "payment") return null;
+	return /* @__PURE__ */ jsx(Suspense, {
+		fallback: /* @__PURE__ */ jsx("p", {
+			role: "status",
+			children: "Loading secure payment…"
+		}),
+		children: /* @__PURE__ */ jsx(Payment, {
+			checkout: state.checkout,
+			onComplete,
+			onRetry,
+			onBack: () => void onBack()
+		})
+	});
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/FullyBookedStep.tsx
+function RecoveryEmailField({ wizard }) {
+	const id = useId();
+	const errorId = `${id}-error`;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "er-field",
+		children: [
+			/* @__PURE__ */ jsx("label", {
+				className: "er-label",
+				htmlFor: id,
+				children: "Email"
+			}),
+			/* @__PURE__ */ jsx("input", {
+				id,
+				type: "email",
+				autoComplete: "email",
+				className: "er-input",
+				value: wizard.formData.email,
+				onChange: (event) => wizard.setFormData({
+					...wizard.formData,
+					email: event.target.value
+				}),
+				...getFieldValidationControlProps({
+					message: wizard.errors.email,
+					messageId: errorId
+				})
+			}),
+			wizard.errors.email && /* @__PURE__ */ jsx(FieldValidationMessage, {
+				id: errorId,
+				className: "er-error",
+				children: wizard.errors.email
+			})
+		]
+	});
+}
+function RecoveryEmail(props) {
+	const { wizard } = props;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rb-reg-stack er-stack",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "er-text",
+				children: "Already started a booking? Enter your email to finish paying."
+			}),
+			/* @__PURE__ */ jsx(RecoveryEmailField, { wizard }),
+			props.showSpamProtection && /* @__PURE__ */ jsx("div", {
+				className: "er-altcha",
+				children: /* @__PURE__ */ jsx(AltchaWidget, {
+					challengeUrl: getChallengeUrl(),
+					onSolutionChange: wizard.setAltchaSolution
+				})
+			}),
+			wizard.recoveryMessage && /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "er-error",
+				children: wizard.recoveryMessage
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "er-btn er-btn--primary",
+				disabled: wizard.checkingNextStep || props.showSpamProtection && !wizard.altchaSolution,
+				onClick: () => void wizard.handleRecoveryEmail(),
+				children: wizard.checkingNextStep ? "Checking booking..." : "Continue"
+			})
+		]
+	});
+}
+function FullyBookedStep(props) {
+	const { wizard } = props;
+	const admission = wizard.admission;
+	const byEmail = admission.kind === "fullyBooked" && admission.recovery === "byEmail";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rb-reg-stack er-stack",
+		children: [
+			/* @__PURE__ */ jsx("h3", {
+				className: "er-title",
+				children: "This event is fully booked"
+			}),
+			byEmail && /* @__PURE__ */ jsx(RecoveryEmail, { ...props }),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "er-back-btn",
+				onClick: () => wizard.setStep("select-tickets"),
+				children: "← Back"
+			})
+		]
+	});
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/siteCreditPreview.ts
 function calculateEventRegistrationPreviewTotal(input) {
 	const discountCents = input.manualDiscountCode.trim() ? 0 : input.automaticDiscount?.computedAmountCents ?? 0;
@@ -3790,7 +4265,7 @@ function buildSelectedSiteCreditPreview(input) {
 function resolvePaymentStepStatus(input) {
 	if (input.loading) return "loading";
 	if (input.error || !input.eligibility) return "error";
-	if (input.eligibility.registration.kind === "waitlisted" || input.eligibility.paymentOptions.length === 0) return "not-eligible";
+	if (resolveRegistrationAvailabilityBlocker(input.admission) !== null || input.eligibility.paymentOptions.length === 0) return "not-eligible";
 	return "ready";
 }
 function shouldPromptForLogin(status, isAuthenticated, eligibility) {
@@ -3824,8 +4299,8 @@ function UnavailableEntitlementMessage(props) {
 		})
 	] });
 }
-function IneligiblePaymentPanel(props) {
-	if (isSelectionSoldOut(props.eligibility.availability)) return /* @__PURE__ */ jsxs("div", {
+function SoldOutPaymentPanel() {
+	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-reg-stack er-stack",
 		children: [/* @__PURE__ */ jsx("h3", {
 			className: "er-title",
@@ -3838,6 +4313,8 @@ function IneligiblePaymentPanel(props) {
 			})
 		})]
 	});
+}
+function IneligiblePaymentPanel(props) {
 	const promptLogin = shouldPromptForLogin("not-eligible", props.isAuthenticated, props.eligibility);
 	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-reg-stack er-stack",
@@ -3867,6 +4344,12 @@ function IneligiblePaymentPanel(props) {
 		})]
 	});
 }
+function renderRegistrationAvailabilityBlocker(admission) {
+	const blocker = resolveRegistrationAvailabilityBlocker(admission);
+	if (blocker?.kind !== "unavailable") return null;
+	if (admission.kind === "closed" && admission.reason === "alreadyWaitlisted") return /* @__PURE__ */ jsx(AlreadyWaitlistedPaymentPanel, {});
+	return admission.kind === "fullyBooked" ? /* @__PURE__ */ jsx(SoldOutPaymentPanel, {}) : /* @__PURE__ */ jsx(ClosedPaymentPanel, { message: blocker.message });
+}
 function PaymentBlockingPanel(props) {
 	if (props.eligibilityLoading) return /* @__PURE__ */ jsx("div", {
 		className: "rb-reg-stack er-stack",
@@ -3892,7 +4375,18 @@ function PaymentBlockingPanel(props) {
 		})
 	});
 	if (!props.eligibility) return /* @__PURE__ */ jsx(MissingEligibilityPanel, {});
-	if (props.eligibility.registration.kind === "waitlisted") return /* @__PURE__ */ jsxs("div", {
+	const availabilityPanel = renderRegistrationAvailabilityBlocker(props.admission);
+	if (availabilityPanel) return availabilityPanel;
+	if (props.eligibility.isFree) return /* @__PURE__ */ jsx(FreePaymentSummary, { ticketsCount: props.ticketsCount });
+	return props.eligibility.paymentOptions.length > 0 ? null : /* @__PURE__ */ jsx(IneligiblePaymentPanel, {
+		eligibility: props.eligibility,
+		email: props.email,
+		isAuthenticated: props.isAuthenticated,
+		onRequestLogin: props.onRequestLogin
+	});
+}
+function AlreadyWaitlistedPaymentPanel() {
+	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-reg-stack er-stack",
 		children: [/* @__PURE__ */ jsx("h3", {
 			className: "er-title",
@@ -3909,7 +4403,9 @@ function PaymentBlockingPanel(props) {
 			})]
 		})]
 	});
-	if (props.eligibility.isFree) return /* @__PURE__ */ jsxs("div", {
+}
+function FreePaymentSummary({ ticketsCount }) {
+	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-reg-stack er-stack",
 		children: [/* @__PURE__ */ jsx("h3", {
 			className: "er-title",
@@ -3922,18 +4418,24 @@ function PaymentBlockingPanel(props) {
 			}), /* @__PURE__ */ jsxs("p", {
 				className: "er-text er-text--muted",
 				children: [
-					props.ticketsCount,
+					ticketsCount,
 					" ticket",
-					props.ticketsCount > 1 ? "s" : ""
+					ticketsCount > 1 ? "s" : ""
 				]
 			})]
 		})]
 	});
-	return props.eligibility.paymentOptions.length > 0 ? null : /* @__PURE__ */ jsx(IneligiblePaymentPanel, {
-		eligibility: props.eligibility,
-		email: props.email,
-		isAuthenticated: props.isAuthenticated,
-		onRequestLogin: props.onRequestLogin
+}
+function ClosedPaymentPanel({ message }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "rb-reg-stack er-stack",
+		children: /* @__PURE__ */ jsx("div", {
+			className: "er-center",
+			children: /* @__PURE__ */ jsx("p", {
+				className: "er-text er-text--error",
+				children: message
+			})
+		})
 	});
 }
 //#endregion
@@ -4919,8 +5421,9 @@ function canContinueWithPaymentSelection(selection, directPaymentSelection) {
 		case null: return false;
 	}
 }
-function buildEventDirectPaymentOptions(input) {
-	return buildEventRegistrationPaymentOptionsViewModel({
+function buildEventPaymentSelectionView(input) {
+	const canShowDirectPaymentOptions = Boolean(input.eligibility?.requiresPayment && input.eligibility.price);
+	const directPaymentOptions = input.eligibility && canShowDirectPaymentOptions ? buildEventRegistrationPaymentOptionsViewModel({
 		eventTitle: input.event?.title ?? "Event",
 		approvedPaymentOptions: input.eligibility.paymentOptions,
 		paymentTerms: input.eligibility.paymentTerms,
@@ -4928,7 +5431,18 @@ function buildEventDirectPaymentOptions(input) {
 		currency: input.eligibility.currency,
 		startsAt: getRegistrationStartAt(input.event, input.occurrenceContext),
 		nowIso: input.nowIso
-	}).options;
+	}).options : [];
+	const directPaymentSelectionState = resolveEventRegistrationDirectPaymentSelection({
+		options: directPaymentOptions,
+		selection: input.selection
+	});
+	return {
+		canShowDirectPaymentOptions,
+		directPaymentOptions,
+		directPaymentSelectionState,
+		directPaymentFallbackKind: directPaymentSelectionState.kind === "invalid" ? directPaymentSelectionState.fallbackSelection.collectionOptionKind : void 0,
+		selectedDirectOption: directPaymentSelectionState.kind === "valid" ? directPaymentOptions.find((option) => option.kind === directPaymentSelectionState.selection.collectionOptionKind) ?? null : null
+	};
 }
 /**
 * Payment Selection Step
@@ -4937,24 +5451,17 @@ function buildEventDirectPaymentOptions(input) {
 * Fetches eligible passes/memberships using the user's email.
 * Also shows available passes/memberships for purchase (upsell).
 */
-const PaymentSelectionStep = ({ event, occurrenceContext, ticketsCount, email, isAuthenticated = false, creditState = { kind: "not_authenticated" }, directPaymentTotalCents, manualDiscountPending = false, selectedSelection, onSelectionChange, eligibility, eligibilityLoading, eligibilityError = null, onRequestLogin, onStateChange, nowIso }) => {
+const PaymentSelectionStep = ({ event, occurrenceContext, ticketsCount, email, isAuthenticated = false, creditState = { kind: "not_authenticated" }, directPaymentTotalCents, manualDiscountPending = false, selectedSelection, onSelectionChange, eligibility, admission, eligibilityLoading, eligibilityError = null, onRequestLogin, onStateChange, nowIso }) => {
 	const occurrenceId = occurrenceContext?.id ?? (event?.registrationSubject.kind === "occurrence" ? event.registrationSubject.occurrenceId : "");
 	const selectedMethod = selectedSelection.method;
-	const totalPrice = directPaymentTotalCents;
-	const canShowDirectPaymentOptions = Boolean(eligibility?.requiresPayment && eligibility.price);
-	const directPaymentOptions = eligibility && canShowDirectPaymentOptions ? buildEventDirectPaymentOptions({
+	const { canShowDirectPaymentOptions, directPaymentOptions, directPaymentSelectionState, directPaymentFallbackKind, selectedDirectOption } = buildEventPaymentSelectionView({
 		event,
 		occurrenceContext,
 		eligibility,
-		totalPriceCents: totalPrice,
-		nowIso
-	}) : [];
-	const directPaymentSelectionState = resolveEventRegistrationDirectPaymentSelection({
-		options: directPaymentOptions,
+		totalPriceCents: directPaymentTotalCents,
+		nowIso,
 		selection: selectedSelection
 	});
-	const directPaymentFallbackKind = (directPaymentSelectionState.kind === "invalid" ? directPaymentSelectionState.fallbackSelection : null)?.collectionOptionKind;
-	const selectedDirectOption = directPaymentSelectionState.kind === "valid" ? directPaymentOptions.find((option) => option.kind === directPaymentSelectionState.selection.collectionOptionKind) ?? null : null;
 	const siteCreditPreview = buildSelectedSiteCreditPreview({
 		options: directPaymentOptions,
 		selectionState: directPaymentSelectionState,
@@ -4973,7 +5480,8 @@ const PaymentSelectionStep = ({ event, occurrenceContext, ticketsCount, email, i
 	const paymentStepStatus = resolvePaymentStepStatus({
 		loading: eligibilityLoading,
 		error: eligibilityError,
-		eligibility
+		eligibility,
+		admission
 	});
 	const paymentButtonText = resolvePaymentButtonText(selectedMethod, siteCreditPreview, eligibility, selectedDirectOption);
 	const showLoginPrompt = shouldPromptForLogin(paymentStepStatus, isAuthenticated, eligibility);
@@ -4994,6 +5502,7 @@ const PaymentSelectionStep = ({ event, occurrenceContext, ticketsCount, email, i
 	]);
 	const blockingPanel = /* @__PURE__ */ jsx(PaymentBlockingPanel, {
 		eligibility,
+		admission,
 		eligibilityLoading,
 		eligibilityError,
 		occurrenceId,
@@ -5141,16 +5650,6 @@ function ExistingRegistrationNotice(props) {
 		})
 	});
 }
-function resolveExistingRegistrationKind(wizard) {
-	return wizard.registrationState.kind === "waitlisted" ? "waitlisted" : "booked";
-}
-function isExistingRegistrationBlocking(wizard) {
-	return hasBlockingExistingRegistration({
-		isAuthenticated: wizard.portalAuthState === "authenticated",
-		registration: wizard.registrationState,
-		hasWaitlistClaim: wizard.waitlistClaim.claim !== null
-	});
-}
 function AttendeeDetailsContent(props) {
 	const { wizard } = props;
 	const membership = wizard.portalAuthState === "authenticated" && wizard.ticketsCount === 1 ? wizard.eligibility?.eligibleMemberships[0] : void 0;
@@ -5203,6 +5702,7 @@ function PaymentSelectionContent(props) {
 	if (!wizard.api.config.siteId) return null;
 	if (subtotalCents === null) return /* @__PURE__ */ jsx(PaymentBlockingPanel, {
 		eligibility: wizard.eligibility,
+		admission: wizard.admission,
 		eligibilityLoading: wizard.eligibilityLoading,
 		eligibilityError: wizard.eligibilityError,
 		occurrenceId: wizard.occurrenceContext?.id ?? "",
@@ -5227,6 +5727,7 @@ function PaymentSelectionContent(props) {
 		selectedSelection: wizard.paymentSelection,
 		onSelectionChange: wizard.handlePaymentSelectionChange,
 		eligibility: wizard.eligibility,
+		admission: wizard.admission,
 		eligibilityLoading: wizard.eligibilityLoading,
 		eligibilityError: wizard.eligibilityError,
 		onRequestLogin: () => wizard.setShowMagicLinkModal(true),
@@ -5234,14 +5735,54 @@ function PaymentSelectionContent(props) {
 		nowIso: wizard.nowIso
 	}), /* @__PURE__ */ jsx(EventDiscountCodeDisclosure, { wizard })] });
 }
+function ClosedAdmissionNotice({ wizard }) {
+	const admission = wizard.admission;
+	return admission.kind === "closed" && admission.reason !== "alreadyWaitlisted" && !wizard.eligibilityLoading ? /* @__PURE__ */ jsx("p", {
+		role: "alert",
+		className: "er-error",
+		children: admission.message
+	}) : null;
+}
+function TicketSelectionContent({ wizard }) {
+	if (!wizard.selectedEvent && !wizard.occurrenceContext) return null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		wizard.admission.kind === "closed" && wizard.admission.reason === "alreadyWaitlisted" && /* @__PURE__ */ jsx(ExistingRegistrationNotice, {
+			kind: "waitlisted",
+			onBookForSomeoneElse: wizard.handleBookForSomeoneElse
+		}),
+		/* @__PURE__ */ jsx(ClosedAdmissionNotice, { wizard }),
+		/* @__PURE__ */ jsx(TicketSelectionStep, {
+			event: wizard.selectedEvent,
+			occurrenceContext: wizard.occurrenceContext,
+			selectedAttendanceMode: wizard.selectedAttendanceMode,
+			onAttendanceModeChange: wizard.setSelectedAttendanceMode,
+			ticketsCount: wizard.ticketsCount,
+			maxTickets: wizard.maxTicketsNum,
+			visibleTicketTypes: wizard.visibleTicketTypes,
+			ticketSelections: wizard.selectedTicketLines,
+			onTicketSelectionsChange: wizard.setSelectedTicketLines,
+			slidingScale: wizard.selectedEventSlidingScale,
+			selectedSlidingAmountInput: wizard.selectedSlidingAmountInput,
+			slidingScaleSelectionMessage: wizard.slidingScaleSelectionMessage,
+			onSlidingAmountChange: wizard.setSelectedSlidingAmountInput,
+			onTicketsChange: wizard.setTicketsCount,
+			bookingUnit: resolveBookingUnit(wizard.selectedEvent)
+		})
+	] });
+}
 function EventRegistrationWizardContent(props) {
 	const { wizard } = props;
 	const showSpamProtection = props.showSpamProtection ?? isSpamProtectionEnabled();
 	switch (wizard.step) {
+		case "payment": return /* @__PURE__ */ jsx(EventPaymentMount, {
+			state: wizard.paymentController.state,
+			onComplete: wizard.paymentController.check,
+			onRetry: wizard.paymentController.retryPaymentLoad,
+			onBack: wizard.paymentController.backToBooking
+		});
 		case "error":
 		case "success":
 		case "submitting":
-		case "redirecting":
 		case "verifying-payment":
 		case "verifying-timeout":
 		case "payment-status":
@@ -5253,28 +5794,11 @@ function EventRegistrationWizardContent(props) {
 			showVenue: props.showVenue,
 			showCapacity: props.showCapacity
 		});
-		case "select-tickets":
-			if (!wizard.selectedEvent && !wizard.occurrenceContext) return null;
-			return /* @__PURE__ */ jsxs(Fragment, { children: [isExistingRegistrationBlocking(wizard) && /* @__PURE__ */ jsx(ExistingRegistrationNotice, {
-				kind: resolveExistingRegistrationKind(wizard),
-				onBookForSomeoneElse: wizard.handleBookForSomeoneElse
-			}), /* @__PURE__ */ jsx(TicketSelectionStep, {
-				event: wizard.selectedEvent,
-				occurrenceContext: wizard.occurrenceContext,
-				selectedAttendanceMode: wizard.selectedAttendanceMode,
-				onAttendanceModeChange: wizard.setSelectedAttendanceMode,
-				ticketsCount: wizard.ticketsCount,
-				maxTickets: wizard.maxTicketsNum,
-				visibleTicketTypes: wizard.visibleTicketTypes,
-				ticketSelections: wizard.selectedTicketLines,
-				onTicketSelectionsChange: wizard.setSelectedTicketLines,
-				slidingScale: wizard.selectedEventSlidingScale,
-				selectedSlidingAmountInput: wizard.selectedSlidingAmountInput,
-				slidingScaleSelectionMessage: wizard.slidingScaleSelectionMessage,
-				onSlidingAmountChange: wizard.setSelectedSlidingAmountInput,
-				onTicketsChange: wizard.setTicketsCount,
-				bookingUnit: resolveBookingUnit(wizard.selectedEvent)
-			})] });
+		case "select-tickets": return /* @__PURE__ */ jsx(TicketSelectionContent, { wizard });
+		case "fully-booked": return /* @__PURE__ */ jsx(FullyBookedStep, {
+			wizard,
+			showSpamProtection
+		});
 		case "enter-details": return /* @__PURE__ */ jsx(AttendeeDetailsContent, {
 			wizard,
 			showSpamProtection
@@ -5353,7 +5877,10 @@ function presentation(state) {
 		case "assistanceRequired": return {
 			title: "We still can’t confirm your payment",
 			message: "Please don’t make another payment. Contact the organiser so they can check your booking.",
-			action: { label: "Return to booking" }
+			action: {
+				label: "Return to booking",
+				disabled: true
+			}
 		};
 	}
 }
@@ -5604,51 +6131,27 @@ function EventRegistrationMagicLinkModal(props) {
 function EventRegistrationTerminalState(props) {
 	const { wizard } = props;
 	switch (wizard.step) {
-		case "submitting":
-		case "redirecting": {
-			const label = wizard.step === "redirecting" ? "Redirecting to payment" : "Processing your registration";
-			return /* @__PURE__ */ jsxs("div", {
-				className: "er-center",
-				children: [/* @__PURE__ */ jsx(SpinnerNode, {
-					size: "lg",
-					srLabel: label
-				}), /* @__PURE__ */ jsxs("p", {
-					className: "er-text--muted",
-					children: [label, "..."]
-				})]
-			});
-		}
+		case "submitting": return /* @__PURE__ */ jsx(RegistrationProcessing, {});
+		case "payment": return null;
 		case "verifying-payment": return /* @__PURE__ */ jsx(VerifyingPaymentStep, {});
 		case "payment-failed": return /* @__PURE__ */ jsx(PaymentFailedStep, {
 			message: wizard.errorMessage,
 			onRetry: () => wizard.setStep("select-payment")
 		});
-		case "verifying-timeout": return /* @__PURE__ */ jsx(VerifyingTimeoutStep, {
-			onCheckAgain: wizard.verification.status === "timeout" ? wizard.verification.retry : wizard.verification.retryReturn,
-			title: wizard.verification.status === "timeout" ? void 0 : "We’re checking your payment",
-			message: wizard.verification.status === "timeout" ? void 0 : wizard.errorMessage,
+		case "verifying-timeout": return /* @__PURE__ */ jsx(RegistrationVerificationTimeout, {
+			wizard,
 			supportEmail: props.supportEmail
 		});
-		case "payment-status": return wizard.paymentStatusRecovery ? /* @__PURE__ */ jsx(PaymentStatusStep, {
-			state: wizard.paymentStatusRecovery,
-			onCheck: wizard.handleCheckPaymentStatus,
-			onContinuePayment: wizard.handleContinueExistingPayment,
-			onReturnToPayment: wizard.handleReturnToPayment,
-			onReturnToBooking: wizard.handleReturnToBooking
-		}) : null;
+		case "payment-status": return /* @__PURE__ */ jsx(RegistrationPaymentStatus, { wizard });
 		case "success": return /* @__PURE__ */ jsx(EventRegistrationSuccess, {
 			wizard,
 			fallbackMessage: props.successMessage,
 			demoEmailSuppressed: props.demoEmailSuppressed
 		});
-		case "error": return /* @__PURE__ */ jsx(ErrorStep, {
-			message: wizard.errorMessage,
-			action: wizard.errorAction,
-			canJoinWaitlist: wizard.eligibility?.availability.kind === "waitlist" && wizard.eligibility.registration.kind !== "pending_payment",
-			onRetry: wizard.handleRetry
-		});
+		case "error": return /* @__PURE__ */ jsx(RegistrationError, { wizard });
 		case "select-event":
 		case "select-tickets":
+		case "fully-booked":
 		case "enter-details":
 		case "select-payment": return null;
 	}
@@ -5717,6 +6220,46 @@ function EventRegistrationSurface(props) {
 		})]
 	});
 }
+function RegistrationProcessing() {
+	const label = "Processing your registration";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "er-center",
+		children: [/* @__PURE__ */ jsx(SpinnerNode, {
+			size: "lg",
+			srLabel: label
+		}), /* @__PURE__ */ jsxs("p", {
+			className: "er-text--muted",
+			children: [label, "..."]
+		})]
+	});
+}
+function RegistrationVerificationTimeout({ wizard, supportEmail }) {
+	const timedOut = wizard.verification.status === "timeout";
+	return /* @__PURE__ */ jsx(VerifyingTimeoutStep, {
+		onCheckAgain: timedOut ? wizard.verification.retry : wizard.verification.retryReturn,
+		title: timedOut ? void 0 : "We’re checking your payment",
+		message: timedOut ? void 0 : wizard.errorMessage,
+		supportEmail
+	});
+}
+function RegistrationPaymentStatus({ wizard }) {
+	return wizard.paymentStatusRecovery ? /* @__PURE__ */ jsx(PaymentStatusStep, {
+		state: wizard.paymentStatusRecovery,
+		onCheck: wizard.handleCheckPaymentStatus,
+		onContinuePayment: wizard.handleContinueExistingPayment,
+		onReturnToPayment: wizard.handleReturnToPayment,
+		onReturnToBooking: wizard.handleReturnToBooking
+	}) : null;
+}
+function RegistrationError({ wizard }) {
+	const admission = wizard.admission;
+	return /* @__PURE__ */ jsx(ErrorStep, {
+		message: wizard.errorMessage,
+		action: wizard.errorAction,
+		canJoinWaitlist: admission.kind === "waitlist",
+		onRetry: wizard.handleRetry
+	});
+}
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/EventRegistrationWizard.tsx
 const EVENT_PORTAL_AUTH_COPY = {
@@ -5764,11 +6307,12 @@ function getWizardStepLabel(input) {
 		case "select-event": return input.eventSelectionLabel;
 		case "select-tickets": return input.selectedEvent?.registrationSubject.kind === "wholeSeries" ? "Places" : "Tickets";
 		case "enter-details": return "Details";
-		case "select-payment": return "Payment";
+		case "select-payment": return "Payment options";
+		case "payment": return "Payment";
+		case "fully-booked":
 		case "error":
 		case "success":
 		case "submitting":
-		case "redirecting":
 		case "verifying-payment":
 		case "verifying-timeout":
 		case "payment-status":
@@ -5799,7 +6343,6 @@ function EventRegistrationWizardView(viewProps) {
 	const showSpamProtection = spamProtectionEnabled ?? isSpamProtectionEnabled();
 	const registrationRootClassName = `event-registration ${className || ""}`;
 	const registrationRootRef = React.useRef(null);
-	useEventCheckoutHandoffRestore(wizard.step === "redirecting");
 	const [bookingOverlayOpen, setBookingOverlayOpen] = useState(false);
 	const [floatingPortalRoot, setFloatingPortalRoot] = useState(null);
 	useEffect(() => {
@@ -5839,19 +6382,19 @@ function EventRegistrationWizardView(viewProps) {
 			})
 		})
 	});
-	const isWizardStep = WIZARD_STEPS.includes(wizard.step);
 	const activeWizardSteps = useMemo(() => {
 		const needsPaymentStep = requiresPaymentStep({
 			eventRequiresPayment: wizard.eventRequiresPayment,
 			paymentSelection: wizard.paymentSelection
 		});
-		return getWizardStepsForContext(wizard.hasPreSelectedContext, needsPaymentStep);
+		return getWizardStepsForContext(wizard.hasPreSelectedContext, needsPaymentStep, wizard.step === "payment");
 	}, [
+		wizard.step,
 		wizard.hasPreSelectedContext,
 		wizard.eventRequiresPayment,
 		wizard.paymentSelection
 	]);
-	const totalSteps = activeWizardSteps.length;
+	const { isWizardStep, totalSteps } = getRegistrationStepPresentation(wizard.step, activeWizardSteps);
 	const summaryEvent = wizard.selectedEvent ?? wizard.preSelectedEvent;
 	const eventSelectionStepLabel = getEventSelectionMode(wizard.scopedEvents) === "date" ? "Date" : "Event";
 	const stepLabels = activeWizardSteps.map((step) => getWizardStepLabel({
@@ -5911,7 +6454,10 @@ function EventRegistrationWizardView(viewProps) {
 			ticketCurrency: bookingCurrency,
 			buttonVariant,
 			formatTicketPrice: (ticketType) => formatTicketPriceIfKnown(ticketType, bookingCurrency),
-			onOpen: () => setBookingOverlayOpen(true),
+			onOpen: () => {
+				if (wizard.paymentController.state.kind === "payment") wizard.paymentController.retryPaymentLoad();
+				setBookingOverlayOpen(true);
+			},
 			onClose: () => setBookingOverlayOpen(false),
 			overlaySurface: renderRegistrationSurface("overlay")
 		})]