@riverbankcms/sdk 0.138.0 → 0.140.0

package/dist/client/bookings.mjs

@@ -2523,6 +2523,11 @@ function assertNever$3(value, message = "Unexpected variant") {
 }
 //#endregion
 //#region ../core/src/currency-format.ts
+const CURRENCY_CODE_INPUT_PATTERN = /^[A-Za-z]{3}$/;
+/** Parse + normalize a currency code, or return null if it isn't a 3-letter code. */
+function parseCurrencyCode(value) {
+	return CURRENCY_CODE_INPUT_PATTERN.test(value) ? value.toUpperCase() : null;
+}
 const CURRENCY_LOCALE_BY_CODE = {
 	USD: "en-US",
 	GBP: "en-GB",
@@ -6873,8 +6878,14 @@ const headerInteractionPillPaletteValues = [
 	"accent"
 ];
 /**
-* "No pill": the nav link keeps whatever hover treatment its recipe compiled,
-* and the palette step writes nothing at all (#1318 Phase 4c decision 2).
+* "No pill": a colour change on hover rather than a filled background.
+*
+* The palette step writes nothing (#1318 Phase 4c decision 2), but on a
+* foreground-adaptive style that is not the end of the story: the hover colour
+* is derived from the resolved opening foreground at render time, paired with
+* the resting colour, so `quiet` resolves to a definite colour rather than to
+* whatever brand token the recipe happened to name. See
+* `applyOpeningForeground`.
 *
 * It exists because "a colour change on hover, no filled background" was not
 * expressible in the vocabulary, and it is what
@@ -7856,6 +7867,28 @@ const bookingRequirementConsentFieldSchema = z.object({
 z.union([blockBookingConsentSchema, bookingRequirementConsentFieldSchema]);
 //#endregion
 //#region ../blocks/src/system/blocks/events/shared/schemas.ts
+const publicEventLoaderQuerySchemaShape = {
+	limit: z.string().optional(),
+	from: z.string().optional(),
+	to: z.string().optional(),
+	afterStartsAt: z.string().optional(),
+	afterId: z.string().optional(),
+	categoryIds: z.string().optional(),
+	venueId: z.string().optional(),
+	staffMemberId: z.string().optional(),
+	eventSurface: z.string().optional(),
+	eventPresets: z.string().optional(),
+	scheduleScope: z.string().optional(),
+	seriesId: z.string().optional(),
+	seriesIds: z.string().optional(),
+	runSeriesId: z.string().optional(),
+	seriesSlug: z.string().optional(),
+	includeOccurrenceId: z.string().optional(),
+	readIntent: z.string().optional(),
+	detailLevel: z.string().optional(),
+	readProfile: z.string().optional()
+};
+z.object(publicEventLoaderQuerySchemaShape);
 const eventPresetSchema = z.enum([
 	"event",
 	"class",
@@ -8722,6 +8755,9 @@ function isApiSuccessResponse(json) {
 * });
 * ```
 */
+function publicEventsQuery(params) {
+	return { ...params ?? {} };
+}
 function createBlockApi(config) {
 	const { baseUrl, auth, authOverrides, siteId, isPreview } = config;
 	const dedup = createDeduplicationCache({ ttl: 100 });
@@ -8874,23 +8910,7 @@ function createBlockApi(config) {
 			const path = buildPath(EVENTS.list.path, { siteId: sid });
 			return request(EVENTS.list, {
 				path,
-				query: {
-					from: params?.from,
-					to: params?.to,
-					afterStartsAt: params?.afterStartsAt,
-					afterId: params?.afterId,
-					limit: params?.limit,
-					stage: params?.stage,
-					eventSurface: params?.eventSurface,
-					eventPresets: params?.eventPresets,
-					scheduleScope: params?.scheduleScope,
-					categoryIds: params?.categoryIds,
-					venueId: params?.venueId,
-					staffMemberId: params?.staffMemberId,
-					seriesId: params?.seriesId,
-					includeOccurrenceId: params?.includeOccurrenceId,
-					detailLevel: params?.detailLevel
-				}
+				query: publicEventsQuery(params)
 			});
 		},
 		async getEventFilters(params) {
@@ -8954,7 +8974,7 @@ function createBlockApi(config) {
 			const path = buildPath(WHOLE_SERIES.waitlistClaimResolve.path, { siteId: sid });
 			return request(WHOLE_SERIES.waitlistClaimResolve, {
 				path,
-				body: { claimToken: data.claimToken }
+				body: data
 			});
 		},
 		async getDiscountsAvailable(data) {
@@ -9043,8 +9063,9 @@ function createBlockApi(config) {
 					name: data.name,
 					company: data.company,
 					phone: data.phone,
-					target: data.target,
-					tags: data.tags,
+					sourceRef: data.sourceRef,
+					setupRevision: data.setupRevision,
+					visitorSelection: data.visitorSelection,
 					meta: data.meta
 				}
 			});
@@ -14861,61 +14882,6 @@ const BookingFormClient$1 = ({ siteId: siteIdProp, render }) => {
 	});
 };
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/registrationErrorRecovery.ts
-function resolveRegistrationRecoveryAction(step, action) {
-	if (step === "payment-failed") return "payment-options";
-	if (step === "verifying-payment" || step === "verifying-timeout" || step === "redirecting") return "payment-status";
-	return action;
-}
-function canRecoverToWaitlist(eligibility) {
-	return Boolean(eligibility?.isFull && eligibility.canJoinWaitlist);
-}
-function shouldRefreshAfterRegistrationError(step, action, enabled) {
-	return enabled || step === "error" && action === "places";
-}
-function resetRegistrationAfterExpiry(input) {
-	input.dispatchFlow({
-		type: "reset",
-		hasPreSelectedContext: input.hasPreSelectedContext
-	});
-	input.setSelectedTicketLines([]);
-	input.setSelectedSlidingAmountInput("");
-	const mode = input.preSelectedEvent?.deliveryMode;
-	input.setSelectedAttendanceMode(mode === "online" || mode === "in_person" ? mode : null);
-	input.setErrorMessage("");
-	input.setPendingRegistrationReference(null);
-}
-/** Recovery never starts another payment. Unknown payment outcomes go to the portal. */
-function recoverRegistrationError(action, handlers) {
-	switch (action) {
-		case "none": return;
-		case "portal":
-		case "payment-status":
-			window.location.assign("/portal");
-			return;
-		case "event":
-			window.location.assign(window.location.pathname);
-			return;
-		case "retry":
-			window.location.reload();
-			return;
-		case "details":
-			handlers.clearError();
-			handlers.setStep("enter-details");
-			return;
-		case "payment-options":
-		case "places":
-			handlers.refreshOptions();
-			handlers.clearError();
-			handlers.setStep(action === "places" ? handlers.canJoinWaitlist ? "enter-details" : "select-tickets" : "select-payment");
-			return;
-		case "start":
-			handlers.refreshOptions();
-			handlers.reset();
-			return;
-	}
-}
-//#endregion
 //#region ../blocks/src/system/runtime/nodes/events/domain/capacity.ts
 /**
 * Compute remaining spots for an event from `availableSpots` with a fallback
@@ -14985,6 +14951,166 @@ function resolveRuntimeEventDestination(event) {
 	};
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/checkoutRecovery.ts
+/** Recovery may select held places; checkout still owns admission and payment validation. */
+function checkoutRecoveryOptionAvailability(availability) {
+	if (availability.kind === "available" || availability.reason === "sold_out" || availability.reason === "overallCapacityUnavailable") return {
+		kind: "available",
+		remainingPlaces: null
+	};
+	return availability;
+}
+/**
+* A form-only projection for the explicit existing-checkout path. It permits
+* collecting the original selection without claiming a new place is available.
+* The public checkout service identifies the customer and remains the admission
+* authority; no reservation/customer data is exposed through this projection.
+*/
+function getCheckoutRecoveryFormEligibility(eligibility) {
+	if (!eligibility || eligibility.registration.kind !== "none" && eligibility.registration.kind !== "pending_payment" || eligibility.availability.kind === "unavailable" && eligibility.availability.reason !== "full" && eligibility.availability.reason !== "selectionRequired") return eligibility;
+	const amountCents = eligibility.price ?? 0;
+	if (amountCents <= 0 || !eligibility.currency || eligibility.availability.kind === "unavailable" && eligibility.availability.reason === "selectionRequired") return eligibility.registration.kind === "pending_payment" ? {
+		...eligibility,
+		registration: { kind: "none" },
+		ticketTypes: eligibility.ticketTypes.map((option) => ({
+			...option,
+			availability: checkoutRecoveryOptionAvailability(option.availability)
+		}))
+	} : eligibility;
+	const currency = eligibility.currency;
+	const paymentOptions = eligibility.paymentTerms.allowedOptions.map((option) => {
+		switch (option.kind) {
+			case "upfront": return {
+				kind: "payInFull",
+				amountCents,
+				currency
+			};
+			case "deferred_manual": return {
+				kind: "deferredManual",
+				amountCents,
+				currency
+			};
+			case "instalment_plan": return {
+				kind: "instalmentPlan",
+				amountCents,
+				currency
+			};
+			case "flexible_balance": return {
+				kind: "flexibleBalance",
+				amountCents,
+				currency
+			};
+		}
+	});
+	return {
+		...eligibility,
+		registration: { kind: "none" },
+		availability: {
+			kind: "available",
+			remainingPlaces: null,
+			waitlistEnabled: eligibility.waitlistEnabled
+		},
+		eligible: paymentOptions.length > 0,
+		isFull: false,
+		canJoinWaitlist: false,
+		isFree: false,
+		requiresPayment: true,
+		canPayDirectly: paymentOptions.length > 0,
+		paymentOptions,
+		eligiblePasses: [],
+		eligibleMemberships: [],
+		ticketTypes: eligibility.ticketTypes.map((option) => ({
+			...option,
+			availability: checkoutRecoveryOptionAvailability(option.availability)
+		}))
+	};
+}
+function canJoinWaitlistOutsideRecovery(event, attendanceMode, checkoutRecovery) {
+	return !checkoutRecovery && event !== null && canJoinEventWaitlist(event, { attendanceMode });
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/useCheckoutRecovery.ts
+/** Recovery belongs to the selected booking subject; changing events resets its scope. */
+function useCheckoutRecovery(event, setStep) {
+	const [recoveryEventId, setRecoveryEventId] = useState(null);
+	return {
+		checkoutRecovery: event !== null && recoveryEventId === event.selectionId,
+		startCheckoutRecovery: useCallback(() => {
+			if (!event) return;
+			setRecoveryEventId(event.selectionId);
+			setStep("select-tickets");
+		}, [event, setStep])
+	};
+}
+/** Authenticated pending bookings enter the same form-only recovery path as guests. */
+function useCheckoutRecoveryEligibility(eligibility, step, checkoutRecovery, startCheckoutRecovery) {
+	const registrationKind = eligibility?.registration.kind;
+	useEffect(() => {
+		if ((step === "select-event" || step === "select-tickets" || step === "enter-details" || step === "select-payment") && registrationKind === "pending_payment" && !checkoutRecovery) startCheckoutRecovery();
+	}, [
+		registrationKind,
+		step,
+		checkoutRecovery,
+		startCheckoutRecovery
+	]);
+	return useMemo(() => checkoutRecovery ? getCheckoutRecoveryFormEligibility(eligibility) : eligibility, [checkoutRecovery, eligibility]);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/registrationErrorRecovery.ts
+function resolveRegistrationRecoveryAction(step, action) {
+	if (step === "payment-failed") return "payment-options";
+	if (step === "verifying-payment" || step === "verifying-timeout" || step === "redirecting") return "payment-status";
+	return action;
+}
+function canRecoverToWaitlist(eligibility) {
+	return Boolean(eligibility?.isFull && eligibility.canJoinWaitlist);
+}
+function shouldRefreshAfterRegistrationError(step, action, enabled) {
+	return enabled || step === "error" && action === "places";
+}
+function resetRegistrationAfterExpiry(input) {
+	input.dispatchFlow({
+		type: "reset",
+		hasPreSelectedContext: input.hasPreSelectedContext
+	});
+	input.setSelectedTicketLines([]);
+	input.setSelectedSlidingAmountInput("");
+	const mode = input.preSelectedEvent?.deliveryMode;
+	input.setSelectedAttendanceMode(mode === "online" || mode === "in_person" ? mode : null);
+	input.setErrorMessage("");
+	input.setPendingRegistrationReference(null);
+}
+/** Recovery never starts another payment. Unknown payment outcomes go to the portal. */
+function recoverRegistrationError(action, handlers) {
+	switch (action) {
+		case "none": return;
+		case "portal":
+		case "payment-status":
+			window.location.assign("/portal");
+			return;
+		case "event":
+			window.location.assign(window.location.pathname);
+			return;
+		case "retry":
+			window.location.reload();
+			return;
+		case "details":
+			handlers.clearError();
+			handlers.setStep("enter-details");
+			return;
+		case "payment-options":
+		case "places":
+			handlers.refreshOptions();
+			handlers.clearError();
+			handlers.setStep(action === "places" ? handlers.canJoinWaitlist ? "enter-details" : "select-tickets" : "select-payment");
+			return;
+		case "start":
+			handlers.refreshOptions();
+			handlers.reset();
+			return;
+	}
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/validation.ts
 function createInitialRegistrationFormData() {
 	return {
@@ -15462,6 +15588,40 @@ const SharedDatedOfferingOrderCheckoutSessionMetadataSchema = z.object({
 	...datedOfferingSharedEngineMetadataShape
 });
 z.union([SharedDatedOfferingOrderCheckoutSessionMetadataSchema, LegacyOrderCheckoutSessionMetadataSchema]);
+//#endregion
+//#region ../commerce/src/purchase/stripeCommissionMetadata.ts
+/** Reasons are payment evidence, not an independent pricing policy. */
+const STRIPE_COMMISSION_FREE_REASONS = [
+	"managed_billing",
+	"no_commission_plan",
+	"billing_evidence_invalid",
+	"fee_rounds_to_zero",
+	"non_commissionable_scope",
+	"payment_not_stripe"
+];
+const historicalContext = {
+	currency: z.string().refine((value) => parseCurrencyCode(value) !== null).optional(),
+	sourcePlanId: z.string().trim().min(1).optional()
+};
+const percentSchema = z.number().finite().min(0).max(100);
+z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("commission_free"),
+		reason: z.enum(STRIPE_COMMISSION_FREE_REASONS),
+		...historicalContext
+	}),
+	z.object({
+		kind: z.literal("application_fee_amount"),
+		amountCents: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		percent: percentSchema,
+		...historicalContext
+	}),
+	z.object({
+		kind: z.literal("application_fee_percent"),
+		percent: percentSchema,
+		...historicalContext
+	})
+]);
 toNonNegativeCents(0);
 //#endregion
 //#region ../commerce/src/purchase/event-registration-errors.ts
@@ -15474,6 +15634,10 @@ const eventRegistrationErrors = {
 		message: "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.",
 		action: "payment-status"
 	},
+	paymentProviderUnavailable: {
+		message: "We couldn’t reach the payment provider. Please try again in a minute.",
+		action: "retry"
+	},
 	paymentPageUnavailable: {
 		message: "We couldn’t open the payment page. Please refresh this page and try again. If this keeps happening, contact the organiser for help.",
 		action: "retry"
@@ -15596,11 +15760,6 @@ function ensureWaitlistClaimLocationTracking() {
 	} catch {}
 	window.addEventListener("popstate", emitWaitlistClaimLocationChange);
 }
-function getWaitlistClaimTokenFromUrl() {
-	if (typeof window === "undefined") return null;
-	const token = new URLSearchParams(window.location.search).get("waitlist_claim")?.trim() ?? "";
-	return token.length > 0 ? token : null;
-}
 const useWaitlistClaimDeps = { useBlockApi };
 function subscribeToWaitlistClaimToken(callback) {
 	if (typeof window === "undefined") return () => {};
@@ -15610,28 +15769,42 @@ function subscribeToWaitlistClaimToken(callback) {
 		window.removeEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
 	};
 }
-function getWaitlistClaimTokenSnapshot() {
-	return getWaitlistClaimTokenFromUrl();
+function getWaitlistClaimLocationSnapshot() {
+	return typeof window === "undefined" ? "" : window.location.search;
+}
+function parseWaitlistClaimCredential(search) {
+	const params = new URLSearchParams(search);
+	const token = params.get("waitlist_claim")?.trim();
+	if (token) return {
+		kind: "emailedToken",
+		token
+	};
+	const entryId = params.get("waitlistEntry")?.trim();
+	return entryId ? {
+		kind: "portalOwnedEntry",
+		entryId
+	} : null;
 }
 function useWaitlistClaim() {
 	return useWaitlistClaimWithDeps(useWaitlistClaimDeps);
 }
 function useWaitlistClaimWithDeps(deps) {
-	return useResolvedWaitlistClaim(deps, useSyncExternalStore(subscribeToWaitlistClaimToken, getWaitlistClaimTokenSnapshot, () => null));
+	const locationSearch = useSyncExternalStore(subscribeToWaitlistClaimToken, getWaitlistClaimLocationSnapshot, () => "");
+	return useResolvedWaitlistClaim(deps, useMemo(() => parseWaitlistClaimCredential(locationSearch), [locationSearch]));
 }
-function useResolvedWaitlistClaim(deps, token) {
+function useResolvedWaitlistClaim(deps, credential) {
 	const api = deps.useBlockApi();
-	const [state, dispatch] = useReducer(waitlistClaimReducer, Boolean(token), createInitialWaitlistClaimState);
+	const [state, dispatch] = useReducer(waitlistClaimReducer, Boolean(credential), createInitialWaitlistClaimState);
 	useEffect(() => {
 		let cancelled = false;
 		async function resolveClaim() {
-			if (!token) {
+			if (!credential) {
 				dispatch({ type: "cleared" });
 				return;
 			}
 			dispatch({ type: "started" });
 			try {
-				const result = await api.resolveWaitlistClaim({ claimToken: token });
+				const result = credential.kind === "portalOwnedEntry" ? await api.resolveWaitlistClaim({ waitlistEntryId: credential.entryId }) : await api.resolveWaitlistClaim({ claimToken: credential.token });
 				if (cancelled) return;
 				dispatch({
 					type: "resolved",
@@ -15649,9 +15822,10 @@ function useResolvedWaitlistClaim(deps, token) {
 		return () => {
 			cancelled = true;
 		};
-	}, [api, token]);
+	}, [api, credential]);
 	return {
-		token,
+		token: credential?.kind === "emailedToken" ? credential.token : null,
+		entryId: credential?.kind === "portalOwnedEntry" ? credential.entryId : null,
 		claim: getWaitlistClaim(state),
 		error: getWaitlistClaimError(state),
 		loginMessage: getWaitlistClaimLoginMessage(state),
@@ -16133,15 +16307,12 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 	* landed — a success, or a hand-off to checkout — because until then nobody
 	* knows whether the first one committed.
 	*
-	* Reusing it after a failure is safe even if the customer edits their
-	* details. The server consults the command record before it re-checks
-	* anything, so a submission that already booked is answered with the booking
-	* that exists — not refused for spending a credit or a claim that this very
-	* command already spent, and not treated as a second booking because a name
-	* or a note changed in between.
+	* Identical retries retain the command after a lost response. Changed form
+	* details get a new command so the server applies the new booking intent.
 	*/
-	const commandIdRef = useRef(null);
-	return async (method, passId, membershipId, selection, submitOptions) => {
+	const commandRef = useRef(null);
+	const inFlightRef = useRef(null);
+	const submit = async (method, passId, membershipId, selection, submitOptions) => {
 		const target = options.registrationTarget;
 		if (!target) return {
 			ok: false,
@@ -16149,44 +16320,34 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 			message: "Select an event to continue."
 		};
 		options.setStep("submitting");
-		const registrationCommandId = commandIdRef.current ?? deps.createClientCommandId();
-		commandIdRef.current = registrationCommandId;
+		const registrationCommandId = commandRef.current?.id ?? deps.createClientCommandId();
 		try {
-			const prepared = prepareSubmitContext(options, registrationCommandId, target, method, passId, membershipId, selection);
+			let prepared = prepareSubmitContext(options, registrationCommandId, target, method, passId, membershipId, selection);
 			if (prepared.subject.kind === "wholeSeries" && method === "stripe") {
-				commandIdRef.current = null;
+				commandRef.current = null;
 				return await submitWholeSeriesCheckout(options, deps, {
 					...prepared,
 					subject: prepared.subject
 				}, submitOptions);
 			}
+			const request = buildOccurrenceRegistrationRequest(options, prepared, method, passId, membershipId);
+			const intentKey = registrationRequestIntentKey(request);
+			if (commandRef.current !== null && commandRef.current.intentKey !== intentKey) prepared = {
+				...prepared,
+				registrationCommandId: deps.createClientCommandId()
+			};
+			commandRef.current = {
+				id: prepared.registrationCommandId,
+				intentKey
+			};
 			const result = await options.api.registerForEvent({
-				registrationCommandId: prepared.registrationCommandId,
-				subject: prepared.subject,
-				ticketSelections: toTicketSelectionRequests(prepared.ticketSelections),
-				selectedSlidingAmount: options.selectedSlidingAmount ?? void 0,
-				email: options.formData.email.trim().toLowerCase(),
-				name: options.formData.name.trim(),
-				phone: options.formData.phone.trim() || void 0,
-				notes: options.formData.notes.trim() || void 0,
-				consentAccepted: options.formData.consentAccepted,
-				altchaSolution: options.altchaSolution,
-				paymentMethod: method,
-				customerPassId: method === "pass" ? passId : void 0,
-				customerMembershipId: method === "membership" ? membershipId : void 0,
-				bundleProductId: prepared.bundleProductId,
-				claimToken: options.claimToken ?? void 0,
-				guests: prepared.guestsPayload
+				...request,
+				registrationCommandId: prepared.registrationCommandId
 			});
-			commandIdRef.current = null;
-			if (needsOccurrenceCheckout(result, method)) return await submitOccurrenceCheckout(options, deps, prepared, result, method, submitOptions);
-			options.setRegistrationResult(toRegistrationResult(result));
-			options.setStep("success");
-			return {
-				ok: true,
-				outcome: { kind: "completed" }
-			};
+			commandRef.current = null;
+			return await completeRegistrationSubmission(options, deps, prepared, result, method, submitOptions);
 		} catch (error) {
+			if (error instanceof BlockApiError && error.tag === "registrationPreparationChanged") commandRef.current = null;
 			const { message, action } = registrationErrorPresentation(error);
 			options.setErrorAction?.(action);
 			options.setErrorMessage(message);
@@ -16198,6 +16359,24 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 			};
 		}
 	};
+	return (...args) => {
+		if (inFlightRef.current) return inFlightRef.current;
+		const pending = Promise.resolve().then(() => submit(...args));
+		inFlightRef.current = pending;
+		pending.finally(() => {
+			if (inFlightRef.current === pending) inFlightRef.current = null;
+		});
+		return pending;
+	};
+}
+async function completeRegistrationSubmission(options, deps, prepared, result, method, submitOptions) {
+	if (needsOccurrenceCheckout(result, method)) return await submitOccurrenceCheckout(options, deps, prepared, result, method, submitOptions);
+	options.setRegistrationResult(toRegistrationResult(result));
+	options.setStep("success");
+	return {
+		ok: true,
+		outcome: { kind: "completed" }
+	};
 }
 function toTicketSelectionRequests(lines) {
 	return lines.map((line) => ({
@@ -16272,6 +16451,7 @@ async function submitWholeSeriesCheckout(options, deps, prepared, submitOptions)
 		altchaSolution: options.altchaSolution,
 		guests: prepared.guestsPayload,
 		claimToken: options.claimToken ?? void 0,
+		waitlistEntryId: options.waitlistEntryId ?? void 0,
 		discountCode: options.discountCode.trim() || void 0,
 		collectionOptionKind: prepared.selectionSnapshot.collectionOptionKind,
 		checkoutAttemptId,
@@ -16293,14 +16473,14 @@ async function submitWholeSeriesCheckout(options, deps, prepared, submitOptions)
 	}
 	if (result.bypassed) return completeBypassedCheckout(options);
 	if (!result.checkoutUrl) throw new Error("Checkout URL missing");
-	savePendingCheckout(options, deps, prepared, checkoutAttemptId, {
+	savePendingCheckout(options, deps, prepared, result.checkoutAttemptId, {
 		scope: "wholeSeries",
 		registrationId: result.registrationId
 	});
 	return redirectToCheckout(result.checkoutUrl, submitOptions);
 }
 function needsOccurrenceCheckout(result, method) {
-	return result.scope === "occurrence" && !result.alreadyRegistered && result.status === "confirmed" && result.pendingPayment && [
+	return result.scope === "occurrence" && result.status === "confirmed" && result.pendingPayment && [
 		"stripe",
 		"pass_bundle",
 		"membership_bundle"
@@ -16320,6 +16500,7 @@ async function submitOccurrenceCheckout(options, deps, prepared, registration, m
 			kind: "occurrence",
 			attendeeId: registration.attendeeId
 		},
+		registrationCommandId: prepared.registrationCommandId,
 		checkoutType: method === "pass_bundle" ? "pass_bundle" : method === "membership_bundle" ? "membership_bundle" : "event",
 		productId: prepared.bundleProductId,
 		discountCode: options.discountCode.trim() || void 0,
@@ -16362,6 +16543,31 @@ function redirectToCheckout(checkoutUrl, submitOptions) {
 		}
 	};
 }
+function registrationRequestIntentKey(request) {
+	const { registrationCommandId: _command, altchaSolution: _proof, ...intent } = request;
+	return JSON.stringify(intent);
+}
+function buildOccurrenceRegistrationRequest(options, prepared, method, passId, membershipId) {
+	return {
+		registrationCommandId: prepared.registrationCommandId,
+		subject: prepared.subject,
+		ticketSelections: toTicketSelectionRequests(prepared.ticketSelections),
+		selectedSlidingAmount: options.selectedSlidingAmount ?? void 0,
+		email: options.formData.email.trim().toLowerCase(),
+		name: options.formData.name.trim(),
+		phone: options.formData.phone.trim() || void 0,
+		notes: options.formData.notes.trim() || void 0,
+		consentAccepted: options.formData.consentAccepted,
+		altchaSolution: options.altchaSolution,
+		paymentMethod: method,
+		customerPassId: method === "pass" ? passId : void 0,
+		customerMembershipId: method === "membership" ? membershipId : void 0,
+		bundleProductId: prepared.bundleProductId,
+		claimToken: options.claimToken ?? void 0,
+		waitlistEntryId: options.waitlistEntryId ?? void 0,
+		guests: prepared.guestsPayload
+	};
+}
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/eventPaymentOptions.ts
 function getApprovedDirectPaymentCollectionOptionKinds(paymentOptions) {
@@ -17384,14 +17590,28 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	}), [options.occurrenceContext, selectedEvent]);
 	const registrationOccurrenceId = getRegistrationOccurrenceId(registrationTarget);
 	const currentEvent = selectedEvent ?? preSelectedEvent;
+	const setStep = useCallback((nextStep) => {
+		dispatchFlow({
+			type: "set-step",
+			step: nextStep
+		});
+	}, []);
+	const { checkoutRecovery, startCheckoutRecovery } = useCheckoutRecovery(currentEvent, setStep);
 	const currentEventUsesTicketTypes = usesTieredPricing(currentEvent);
-	const currentCanJoinWaitlist = currentEvent ? canJoinEventWaitlist(currentEvent, { attendanceMode: selectedAttendanceMode }) : false;
+	const currentCanJoinWaitlist = canJoinWaitlistOutsideRecovery(currentEvent, selectedAttendanceMode, checkoutRecovery);
 	const usesTicketTypeSelections = currentEventUsesTicketTypes && !currentCanJoinWaitlist;
 	const eventTicketTypesForSelection = useMemo(() => getVisibleTicketTypes({
 		event: currentEvent,
 		eligibility: null,
 		selectedAttendanceMode
-	}), [currentEvent, selectedAttendanceMode]);
+	}).map((option) => checkoutRecovery ? {
+		...option,
+		availability: checkoutRecoveryOptionAvailability(option.availability)
+	} : option), [
+		currentEvent,
+		selectedAttendanceMode,
+		checkoutRecovery
+	]);
 	const normalizedSelectedTicketLines = useMemo(() => normalizeTicketSelectionLines(selectedTicketLines), [selectedTicketLines]);
 	const ticketTypeSelectionTotal = useMemo(() => getTicketSelectionTotal(normalizedSelectedTicketLines), [normalizedSelectedTicketLines]);
 	const ticketsCount = usesTicketTypeSelections ? ticketTypeSelectionTotal : flowState.ticketsCount;
@@ -17429,17 +17649,11 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		isAuthenticated: portalAuthState === "authenticated",
 		occurrenceId: registrationOccurrenceId
 	});
-	const eligibility = eligibilityResult.eligibility;
+	const eligibility = useCheckoutRecoveryEligibility(eligibilityResult.eligibility, step, checkoutRecovery, startCheckoutRecovery);
 	const eligibilityLoading = eligibilityResult.isLoading;
 	const eligibilityError = eligibilityResult.error;
 	const portalCreditState = eligibilityResult.creditState;
 	const registrationState = eligibility?.registration ?? { kind: "none" };
-	const setStep = useCallback((nextStep) => {
-		dispatchFlow({
-			type: "set-step",
-			step: nextStep
-		});
-	}, []);
 	const setTicketsCount = useCallback((nextTicketsCount) => {
 		dispatchFlow({
 			type: "set-tickets-count",
@@ -17547,10 +17761,14 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		event: currentEvent,
 		eligibility,
 		selectedAttendanceMode
-	}), [
+	}).map((option) => checkoutRecovery ? {
+		...option,
+		availability: checkoutRecoveryOptionAvailability(option.availability)
+	} : option), [
 		currentEvent,
 		selectedAttendanceMode,
-		eligibility
+		eligibility,
+		checkoutRecovery
 	]);
 	const singleSelectedPricingOptionId = getSingleSelectedPricingOptionId(normalizedSelectedTicketLines);
 	const selectedTicketType = useMemo(() => findSelectedTicketType({
@@ -17574,8 +17792,12 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		const event = currentEvent;
 		if (!usesTieredPricing(event)) return false;
 		if ((event.deliveryMode ?? "in_person") === "hybrid" && !selectedAttendanceMode) return false;
-		return !canJoinEventWaitlist(event, { attendanceMode: selectedAttendanceMode });
-	}, [currentEvent, selectedAttendanceMode]);
+		return checkoutRecovery || !canJoinEventWaitlist(event, { attendanceMode: selectedAttendanceMode });
+	}, [
+		currentEvent,
+		selectedAttendanceMode,
+		checkoutRecovery
+	]);
 	const hasValidTicketSelection = hasValidPricingOptionSelection({
 		selectionRequired: ticketTypeSelectionRequired,
 		lines: normalizedSelectedTicketLines,
@@ -17779,6 +18001,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		guests,
 		discountCode: discountUi.discountCode,
 		claimToken: waitlistClaim.token,
+		waitlistEntryId: waitlistClaim.entryId,
 		setPendingRegistrationReference,
 		setStep,
 		setRegistrationResult: (result) => setRegistrationResult(result),
@@ -17841,6 +18064,8 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		scopedEvents,
 		preSelectedEvent,
 		hasPreSelectedContext,
+		checkoutRecovery,
+		startCheckoutRecovery,
 		step,
 		setStep,
 		selectedEvent,
@@ -17893,6 +18118,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		isMembershipFastTrack,
 		waitlistClaim,
 		eligibility,
+		registrationOptionsState: eligibilityResult.state,
 		eligibilityLoading,
 		eligibilityError,
 		existingRegistration: existingRegistrationResult.registration,