@riverbankcms/sdk 0.121.0 → 0.124.0

package/dist/client/{courseRegistration-CxCBybB4.mjs → courseRegistration-Cf11pNDs.mjs}

@@ -1,21 +1,21 @@
 "use client";
-import { It as toBookingTimeZone, Kt as assertNever, Lt as toScheduledBookingDateTime, Ot as formatBookingDate, Rt as parseEventPageSurfaceSubject, Z as themeButtonClassName, jt as formatBookingTime, t as defineIslandPropsDecoder } from "./propsDecoder-DreFXjNP.mjs";
-import { n as formatCoursePriceDisplay, r as resolveCoursePricingState, t as formatCoursePriceAmount } from "./pricing-DE8fjJiT.mjs";
-import { n as useBlockApi, t as BlockApiProvider } from "./context-BGZNlGXB.mjs";
+import { At as formatBookingTime, Dt as formatBookingDate, Ft as toBookingTimeZone, Gt as assertNever, It as toScheduledBookingDateTime, Lt as parseEventPageSurfaceSubject, X as themeButtonClassName, t as defineIslandPropsDecoder } from "./propsDecoder-DeunRj6m.mjs";
+import { n as formatCoursePriceDisplay, r as resolveCoursePricingState, t as formatCoursePriceAmount } from "./pricing-BYWN_ATa.mjs";
+import { n as useBlockApi, t as BlockApiProvider } from "./context-CJz1Vlsz.mjs";
 import { n as isSpamProtectionEnabled, r as AltchaWidget, t as getChallengeUrl } from "./src-B833rYRr.mjs";
-import { i as CheckIcon, n as TerminalPanel, r as StateIcon, t as useDiscountCodeUi } from "./useDiscountCodeUi-DCccGCxV.mjs";
-import { t as DiscountCodeDisclosure } from "./DiscountCodeDisclosure-DIWj-P9v.mjs";
-import { n as SpinnerNode, r as formatPrice, t as StepIndicator$1 } from "./StepIndicator-CiZ8kdPk.mjs";
+import { i as CheckIcon, n as TerminalPanel, r as StateIcon, t as useDiscountCodeUi } from "./useDiscountCodeUi-I-92-x2V.mjs";
+import { t as DiscountCodeDisclosure } from "./DiscountCodeDisclosure-DxvjKvck.mjs";
+import { n as SpinnerNode, r as formatPrice, t as StepIndicator$1 } from "./StepIndicator-CTcGf8Be.mjs";
 import { t as FeedbackMessage } from "./FeedbackMessage-ByMrs3cr.mjs";
 import { n as getFieldValidationControlProps, t as FieldValidationMessage } from "./FieldValidationMessage-AYanWFb-.mjs";
 import { t as buildCheckoutReturnUrls } from "./checkoutUrls-Ct8Mxna3.mjs";
 import { t as scrollToBlock } from "./scrollToBlock-C86BYkyV.mjs";
-import { a as ClockIcon, i as LoggedInAsUser, n as logoutPortal, r as useWaitlistClaim, t as MagicLinkForm } from "./MagicLinkForm-OoJAIUIj.mjs";
+import { a as ClockIcon, i as LoggedInAsUser, n as logoutPortal, r as useWaitlistClaim, t as MagicLinkForm } from "./MagicLinkForm-BzyRJ8VF.mjs";
 import { t as CrossIcon } from "./CrossIcon-Dn1KRKW5.mjs";
 import { t as mountReactIsland } from "./reactMount-SY8AVRof.mjs";
 import { t as buildRouteIslandApiConfig } from "./routeIslandApiConfig-UNsfPcYq.mjs";
 import { t as ModalShell } from "./ModalShell-CqkBvBIC.mjs";
-import React, { Component, useEffect, useMemo, useState } from "react";
+import React, { Component, useCallback, useEffect, useMemo, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/shared/utils/validation.ts
 const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -491,6 +491,37 @@ function EnrollmentForm({ formData, errors, onChange, isEmailLocked, isLoading,
 	] });
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/pricing.ts
+function parseCurrencyInputToCents(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	const amount = Number(trimmed);
+	if (!Number.isFinite(amount) || amount < 0) return null;
+	return Math.round(amount * 100);
+}
+function formatCentsAsCurrencyInput(amount) {
+	const major = amount / 100;
+	return Number.isInteger(major) ? String(major) : major.toFixed(2);
+}
+function getMissingCoursePricingSelectionMessage(pricing) {
+	if (pricing?.requiresSelection && !pricing.selectedOption) return pricing.slidingScale ? "Choose an amount to continue." : "Choose a pricing option to continue.";
+	const selectedAmount = pricing?.selectedSlidingAmount;
+	const scale = pricing?.slidingScale;
+	if (scale && selectedAmount !== null && selectedAmount !== void 0 && (selectedAmount < scale.minAmount || selectedAmount > scale.maxAmount)) return "Choose an amount within the sliding scale.";
+	return null;
+}
+function buildCoursePricingOptionPayload(pricing) {
+	if (pricing?.selectedOption) return { pricingOptionId: pricing.selectedOption.id };
+	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null) return { selectedSlidingAmount: pricing.selectedSlidingAmount };
+	return {};
+}
+function defaultCoursePricingSelection(pricing, previousOptionId) {
+	return {
+		pricingOptionId: previousOptionId && pricing.selectableOptions.some((option) => option.id === previousOptionId) ? previousOptionId : pricing.selectedOption?.id ?? null,
+		slidingAmountInput: pricing.slidingScale?.suggestedAmount !== null && pricing.slidingScale?.suggestedAmount !== void 0 ? formatCentsAsCurrencyInput(pricing.slidingScale.suggestedAmount) : ""
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/course-registration/wizardSteps.ts
 /**
 * Steps that are part of the main wizard and should show the step indicator.
@@ -563,6 +594,110 @@ function getStepLabels(steps) {
 	return steps.map((step) => STEP_LABELS[step] ?? step);
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/courseRegistrationViewState.ts
+function deriveCourseRegistrationViewState(input) {
+	const hasCoursePayment = resolveCoursePaymentRequirement(input.pricing);
+	const canUseMembership = hasCoursePayment && input.selectedCourse?.acceptsMemberships === true && input.portalAuthState === "authenticated" && input.eligibleMembershipCount > 0;
+	const hasPreSelectedCourse = input.scopedCourses.length === 1;
+	const fastTrack = canUseMembership && input.eligibleMembershipCount === 1 && input.bookingMode === "membership";
+	const wizardSteps = getWizardStepsForContext(hasPreSelectedCourse, hasCoursePayment, canUseMembership, input.bookingMode, fastTrack);
+	const showPortalAuthSidebar = shouldShowPortalAuthSidebar({
+		...input,
+		hasCoursePayment
+	});
+	return {
+		hasCoursePayment,
+		canUseMembership,
+		hasPreSelectedCourse,
+		wizardSteps,
+		currentStepNumber: getStepNumber(input.step, wizardSteps),
+		totalSteps: wizardSteps.length,
+		stepLabels: getStepLabels(wizardSteps),
+		showPortalAuthSidebar
+	};
+}
+function resolveCoursePaymentRequirement(pricing) {
+	if (!pricing) return false;
+	return pricing.selectedOption ? pricing.selectedRequiresPayment : pricing.hasPaidSelection;
+}
+function shouldShowPortalAuthSidebar(input) {
+	if (input.portalAuthState !== "unauthenticated") return false;
+	if (input.step === "success" || input.step === "waitlist" || input.step === "error") return false;
+	return input.waitlistRequiresPortalLogin || input.hasCoursePayment && input.selectedCourse?.acceptsMemberships === true && input.step !== "select-course";
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseEligibility.ts
+function shouldFetchEligibility(input) {
+	if (!input.course || input.portalAuthState === "checking" || input.hasWaitlistClaimToken) return false;
+	const membershipCheck = input.portalAuthState === "authenticated" && input.hasPaidSelection && input.course.acceptsMemberships;
+	const capacityCheck = input.course.availableSpots !== null && input.course.availableSpots <= 0;
+	return membershipCheck || capacityCheck;
+}
+function useCourseEligibility(input) {
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const [eligibility, setEligibility] = useState(null);
+	const [memberships, setMemberships] = useState([]);
+	const [paymentChoice, setPaymentChoice] = useState("checkout");
+	const [selectedMembershipId, setSelectedMembershipId] = useState(null);
+	const choosePaymentChoice = useCallback((choice) => {
+		setPaymentChoice(choice);
+	}, []);
+	const chooseMembership = useCallback((membershipId) => {
+		setSelectedMembershipId(membershipId);
+	}, []);
+	useEffect(() => {
+		let cancelled = false;
+		setEligibility(null);
+		setMemberships([]);
+		setSelectedMembershipId(null);
+		setError(null);
+		setPaymentChoice("checkout");
+		const eligibilityInput = {
+			course: input.selectedCourse,
+			hasPaidSelection: input.hasPaidSelection,
+			portalAuthState: input.portalAuthState,
+			hasWaitlistClaimToken: input.waitlistClaimToken !== null
+		};
+		if (!shouldFetchEligibility(eligibilityInput)) return;
+		const course = eligibilityInput.course;
+		setLoading(true);
+		input.api.checkWholeSeriesEligibility({ eventSeriesId: course.eventSeriesId }).then((result) => {
+			if (cancelled) return;
+			const eligibleMemberships = result.eligibleMemberships ?? [];
+			setEligibility(result);
+			setMemberships(eligibleMemberships);
+			if (input.portalAuthState === "authenticated" && eligibleMemberships.length > 0) {
+				setPaymentChoice("membership");
+				if (eligibleMemberships.length === 1) setSelectedMembershipId(eligibleMemberships[0]?.customerMembershipId ?? null);
+			}
+		}).catch((cause) => {
+			if (!cancelled) setError(cause instanceof Error ? cause.message : "Failed to check membership eligibility");
+		}).finally(() => {
+			if (!cancelled) setLoading(false);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		input.api,
+		input.hasPaidSelection,
+		input.portalAuthState,
+		input.selectedCourse,
+		input.waitlistClaimToken
+	]);
+	return {
+		eligibilityLoading: loading,
+		eligibilityError: error,
+		courseEligibility: eligibility,
+		eligibleMemberships: memberships,
+		paymentChoice,
+		choosePaymentChoice,
+		selectedMembershipId,
+		chooseMembership
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/course-page-surface-scope.ts
 /**
 * Resolves native course-page ownership without falling back to entry or slug
@@ -580,7 +715,7 @@ function resolveCoursePageSurfaceScope(courses, subjectValue) {
 	return {
 		kind: "scoped",
 		subject: parsed.value,
-		courses: courses.filter((course) => allowedSeriesIds.has(course.seriesId))
+		courses: courses.filter((course) => allowedSeriesIds.has(course.eventSeriesId))
 	};
 }
 function eventSeriesIdsForSubject(subject) {
@@ -591,654 +726,504 @@ function eventSeriesIdsForSubject(subject) {
 	}
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.ts
-function parseCurrencyInputToCents(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const amount = Number(trimmed);
-	if (!Number.isFinite(amount) || amount < 0) return null;
-	return Math.round(amount * 100);
-}
-function formatCentsAsCurrencyInput(amount) {
-	const major = amount / 100;
-	return Number.isInteger(major) ? String(major) : major.toFixed(2);
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationSelection.ts
+function selectScopedCourses(props) {
+	const surfaceScope = resolveCoursePageSurfaceScope(props.courses ?? [], props.subject);
+	if (surfaceScope.kind === "unsupported") return [];
+	if (surfaceScope.kind === "scoped") return surfaceScope.courses;
+	return [];
 }
-function shouldFetchCourseEligibility(course, hasPaidSelection, portalAuthState, hasWaitlistClaimToken) {
-	if (!course || portalAuthState === "checking") return false;
-	if (hasWaitlistClaimToken) return false;
-	const needsMembershipEligibility = portalAuthState === "authenticated" && hasPaidSelection && course.acceptsMemberships;
-	const needsWaitlistAvailabilityCheck = course.availableSpots !== null && course.availableSpots <= 0;
-	return needsMembershipEligibility || needsWaitlistAvailabilityCheck;
-}
-/**
-* Extracts session_id from URL, checking both query params and hash fragment.
-*
-* Stripe appends session_id to the success URL, but if our URL contains a hash
-* (e.g., #course-registration), Stripe ends up appending session_id after the hash:
-* Expected: ?enrollment=success&session_id=cs_test_...#course-registration
-* Actual:   ?enrollment=success#course-registration&session_id=cs_test_...
-*
-* This helper checks both locations to handle this edge case.
-*/
-function getSessionIdFromUrl() {
+function getCourseCheckoutSessionId() {
 	const fromSearch = new URLSearchParams(window.location.search).get("session_id");
 	if (fromSearch) return fromSearch;
 	return window.location.hash.match(/[?&]session_id=([^&]+)/)?.[1] ?? null;
 }
-function getMissingCoursePricingSelectionMessage(pricing) {
-	if (pricing?.requiresSelection && !pricing.selectedOption) {
-		if (pricing.slidingScale) return "Choose an amount to continue.";
-		return "Choose a pricing option to continue.";
-	}
-	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null && pricing.selectedSlidingAmount < pricing.slidingScale.minAmount) return "Choose an amount within the sliding scale.";
-	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null && pricing.selectedSlidingAmount > pricing.slidingScale.maxAmount) return "Choose an amount within the sliding scale.";
-	return null;
+function initialStep(courses) {
+	if (new URLSearchParams(window.location.search).get("enrollment") === "success" && getCourseCheckoutSessionId()) return "verifying-payment";
+	return courses.length === 1 ? "enter-details" : "select-course";
 }
-function buildCoursePricingOptionPayload(pricing) {
-	if (pricing?.selectedOption) return { pricingOptionId: pricing.selectedOption.id };
-	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null) return { selectedSlidingAmount: pricing.selectedSlidingAmount };
-	return {};
-}
-function resolveHasCoursePayment(pricing) {
-	if (!pricing) return false;
-	if (pricing.selectedOption) return pricing.selectedRequiresPayment;
-	return pricing.hasPaidSelection;
-}
-function useCourseRegistrationWizard(props, options = {}) {
-	const api = useBlockApi();
-	const { contentEntry, courses, entrySubrouteContext, subject } = props;
-	const scopedCourses = useMemo(() => {
-		const allCourses = courses ?? [];
-		if (entrySubrouteContext?.kind === "course-run") {
-			const matched = allCourses.find((c) => c.id === entrySubrouteContext.run.courseId) ?? null;
-			if (matched) return [matched];
-		}
-		const pageSurfaceScope = resolveCoursePageSurfaceScope(allCourses, subject);
-		if (pageSurfaceScope.kind === "unsupported") return [];
-		if (pageSurfaceScope.kind === "scoped") return [...pageSurfaceScope.courses];
-		if (contentEntry?.id) {
-			const matchedCourses = allCourses.filter((c) => c.contentEntryId === contentEntry.id);
-			if (matchedCourses.length > 0) return matchedCourses;
-		}
-		if (contentEntry?.slug) {
-			const matchedCourse = allCourses.find((c) => c.slug === contentEntry.slug);
-			if (matchedCourse) return [matchedCourse];
-		}
-		return allCourses;
-	}, [
-		courses,
-		contentEntry?.id,
-		contentEntry?.slug,
-		entrySubrouteContext,
-		subject
-	]);
-	const [step, setStep] = useState(() => {
-		const enrollment = new URLSearchParams(window.location.search).get("enrollment");
-		const sessionId = getSessionIdFromUrl();
-		if (enrollment === "success" && sessionId) return "verifying-payment";
-		return scopedCourses.length === 1 ? "enter-details" : "select-course";
-	});
+function useCourseRegistrationSelection(props) {
+	const scopedCourses = useMemo(() => selectScopedCourses(props), [props.courses, props.subject]);
+	const [step, setStep] = useState(() => initialStep(scopedCourses));
 	const [selectedCourse, setSelectedCourse] = useState(scopedCourses.length === 1 ? scopedCourses[0] ?? null : null);
 	const [selectedPricingOptionId, setSelectedPricingOptionId] = useState(null);
 	const [selectedSlidingAmountInput, setSelectedSlidingAmountInput] = useState("");
-	const [formData, setFormData] = useState({
-		name: "",
-		email: "",
-		phone: "",
-		notes: ""
-	});
-	const [errors, setErrors] = useState({});
-	const [enrollmentResult, setEnrollmentResult] = useState(null);
-	const [errorMessage, setErrorMessage] = useState("");
-	const [portalAuthState, setPortalAuthState] = useState("checking");
-	const [altchaSolution, setAltchaSolution] = useState(null);
-	const showSpamProtection = isSpamProtectionEnabled();
-	const [eligibilityLoading, setEligibilityLoading] = useState(false);
-	const [eligibilityError, setEligibilityError] = useState(null);
-	const [courseEligibility, setCourseEligibility] = useState(null);
-	const [eligibleMemberships, setEligibleMemberships] = useState([]);
-	const [paymentChoice, setPaymentChoice] = useState("checkout");
-	const [selectedMembershipId, setSelectedMembershipId] = useState(null);
-	const [bookingMode, setBookingMode] = useState(null);
-	const waitlistClaim = useWaitlistClaim();
+	const goToStep = useCallback((nextStep) => {
+		setStep(nextStep);
+	}, []);
+	const chooseCourse = useCallback((course) => {
+		setSelectedCourse(course);
+	}, []);
+	const choosePricingOption = useCallback((pricingOptionId) => {
+		setSelectedPricingOptionId(pricingOptionId);
+	}, []);
+	const changeSlidingAmount = useCallback((amount) => {
+		setSelectedSlidingAmountInput(amount);
+	}, []);
 	const selectedCoursePricing = useMemo(() => selectedCourse ? resolveCoursePricingState(selectedCourse, selectedPricingOptionId, parseCurrencyInputToCents(selectedSlidingAmountInput)) : null, [
 		selectedCourse,
 		selectedPricingOptionId,
 		selectedSlidingAmountInput
 	]);
-	const missingPricingSelectionMessage = getMissingCoursePricingSelectionMessage(selectedCoursePricing);
-	const selectedCoursePricingPayload = buildCoursePricingOptionPayload(selectedCoursePricing);
-	const showSoldOutCourseError = () => {
-		setErrorMessage(courseEligibility?.reason ?? "This course is fully booked.");
-		setStep("error");
-		return true;
-	};
-	useEffect(() => {
-		let cancelled = false;
-		async function checkPortalAuth() {
-			if (!(api.config.auth.type === "bearer" || api.config.authOverrides?.portal?.type === "bearer")) {
-				setPortalAuthState("unauthenticated");
-				return;
-			}
-			setPortalAuthState("checking");
-			try {
-				const me = await api.getPortalProfile();
-				if (cancelled) return;
-				setPortalAuthState("authenticated");
-				setFormData((prev) => ({
-					...prev,
-					email: me.profile.email,
-					name: prev.name || me.profile.name,
-					phone: prev.phone || me.profile.phone || ""
-				}));
-			} catch {
-				if (cancelled) return;
-				setPortalAuthState("unauthenticated");
-			}
-		}
-		checkPortalAuth();
-		return () => {
-			cancelled = true;
-		};
-	}, [api]);
-	useEffect(() => {
-		const claim = waitlistClaim.claim;
-		if (!claim || claim.subject.kind !== "course") return;
-		const courseId = claim.subject.courseId;
-		const matchedCourse = scopedCourses.find((course) => course.id === courseId) ?? null;
-		if (!matchedCourse) {
-			setErrorMessage("This waitlist claim is for a different course.");
-			setStep("error");
-			return;
-		}
-		setSelectedCourse(matchedCourse);
-		setFormData((prev) => ({
-			...prev,
-			email: claim.prefill.email,
-			name: claim.prefill.name,
-			phone: claim.prefill.phone ?? "",
-			notes: claim.prefill.notes ?? ""
-		}));
-		if (step === "select-course") setStep("enter-details");
-	}, [
-		waitlistClaim.claim,
-		scopedCourses,
-		step
-	]);
-	useEffect(() => {
-		if (waitlistClaim.requiresPortalLogin) return;
-		if (!waitlistClaim.error) return;
-		setErrorMessage(waitlistClaim.error);
-		setStep("error");
-	}, [waitlistClaim.error, waitlistClaim.requiresPortalLogin]);
 	useEffect(() => {
 		if (!selectedCourse) {
 			setSelectedPricingOptionId(null);
 			setSelectedSlidingAmountInput("");
 			return;
 		}
-		const defaultPricing = resolveCoursePricingState(selectedCourse, null);
-		setSelectedSlidingAmountInput(defaultPricing.slidingScale?.suggestedAmount !== null && defaultPricing.slidingScale?.suggestedAmount !== void 0 ? formatCentsAsCurrencyInput(defaultPricing.slidingScale.suggestedAmount) : "");
-		setSelectedPricingOptionId((previous) => {
-			if (previous && defaultPricing.selectableOptions.some((option) => option.id === previous)) return previous;
-			return defaultPricing.selectedOption?.id ?? null;
-		});
+		const selection = defaultCoursePricingSelection(resolveCoursePricingState(selectedCourse, null), selectedPricingOptionId);
+		setSelectedPricingOptionId(selection.pricingOptionId);
+		setSelectedSlidingAmountInput(selection.slidingAmountInput);
 	}, [selectedCourse]);
-	useEffect(() => {
-		let cancelled = false;
-		async function fetchEligibility() {
-			setCourseEligibility(null);
-			setEligibleMemberships([]);
-			setSelectedMembershipId(null);
-			setEligibilityError(null);
-			setPaymentChoice("checkout");
-			const course = selectedCourse;
-			if (!shouldFetchCourseEligibility(course, selectedCoursePricing?.hasPaidSelection ?? false, portalAuthState, waitlistClaim.token !== null)) return;
-			if (!course) return;
-			setEligibilityLoading(true);
-			try {
-				const res = await api.checkCourseEligibility({ courseId: course.id });
-				if (cancelled) return;
-				setCourseEligibility(res);
-				const memberships = res.eligibleMemberships ?? [];
-				setEligibleMemberships(memberships);
-				if (portalAuthState === "authenticated" && memberships.length > 0) {
-					setPaymentChoice("membership");
-					if (memberships.length === 1) setSelectedMembershipId(memberships[0]?.customerMembershipId ?? null);
-				}
-			} catch (error) {
-				if (cancelled) return;
-				setEligibilityError(error instanceof Error ? error.message : "Failed to check membership eligibility");
-			} finally {
-				if (!cancelled) setEligibilityLoading(false);
+	return {
+		scopedCourses,
+		step,
+		goToStep,
+		selectedCourse,
+		chooseCourse,
+		selectedPricingOptionId,
+		choosePricingOption,
+		selectedSlidingAmountInput,
+		changeSlidingAmount,
+		selectedCoursePricing
+	};
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCoursePaymentVerification.ts
+function applyTerminalStatus(status, setters) {
+	if (status === "enrolled" || status === "completed") {
+		setters.setEnrollmentResult({
+			status: "enrolled",
+			usedMembership: false
+		});
+		setters.setStep("success");
+		return true;
+	}
+	if (status === "waitlist") {
+		setters.setEnrollmentResult({
+			status: "waitlist",
+			usedMembership: false
+		});
+		setters.setStep("waitlist");
+		return true;
+	}
+	setters.setErrorMessage("Payment did not complete. Please try again.");
+	setters.setStep("error");
+	return true;
+}
+async function pollCourseRegistrationStatus(api, sessionId, setters, isCancelled) {
+	const startedAt = Date.now();
+	while (!isCancelled()) {
+		try {
+			const result = await api.getWholeSeriesRegistrationStatus({ sessionId });
+			if (isCancelled()) return;
+			if (result.status !== "pending_payment") {
+				applyTerminalStatus(result.status, setters);
+				return;
 			}
+		} catch (cause) {
+			setters.setErrorMessage(cause instanceof Error ? cause.message : "Failed to verify payment");
 		}
-		fetchEligibility();
-		return () => {
-			cancelled = true;
-		};
-	}, [
-		api,
-		selectedCourse,
-		selectedCoursePricing?.hasPaidSelection,
-		portalAuthState,
-		waitlistClaim.token
-	]);
+		if (Date.now() - startedAt > 3e4) {
+			setters.setErrorMessage("Payment is still processing. Please check your email for confirmation.");
+			setters.setStep("error");
+			return;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 1500));
+	}
+}
+function useCoursePaymentVerification(api, setters) {
 	useEffect(() => {
 		let cancelled = false;
-		async function verifyAfterCheckout() {
-			const enrollment = new URLSearchParams(window.location.search).get("enrollment");
-			const sessionId = getSessionIdFromUrl();
-			if (enrollment === "cancelled") {
-				scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
-				setErrorMessage("Payment was cancelled. You can try again.");
-				setStep("error");
-				return;
-			}
-			if (enrollment !== "success" || !sessionId) return;
+		const enrollment = new URLSearchParams(window.location.search).get("enrollment");
+		const sessionId = getCourseCheckoutSessionId();
+		if (enrollment === "cancelled") {
 			scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
-			setStep("verifying-payment");
-			const startedAt = Date.now();
-			const timeoutMs = 3e4;
-			while (!cancelled) {
-				try {
-					const status = await api.getCourseRegistrationStatus({ sessionId });
-					if (cancelled) return;
-					if (status.status === "enrolled" || status.status === "completed") {
-						setEnrollmentResult({
-							status: "enrolled",
-							usedMembership: false
-						});
-						setStep("success");
-						return;
-					}
-					if (status.status === "waitlist") {
-						setEnrollmentResult({
-							status: "waitlist",
-							usedMembership: false
-						});
-						setStep("waitlist");
-						return;
-					}
-					if (status.status === "cancelled") {
-						setErrorMessage("Payment did not complete. Please try again.");
-						setStep("error");
-						return;
-					}
-				} catch (error) {
-					setErrorMessage(error instanceof Error ? error.message : "Failed to verify payment");
-				}
-				if (Date.now() - startedAt > timeoutMs) {
-					setErrorMessage("Payment is still processing. Please check your email for confirmation.");
-					setStep("error");
-					return;
-				}
-				await new Promise((r) => setTimeout(r, 1500));
-			}
+			setters.setErrorMessage("Payment was cancelled. You can try again.");
+			setters.setStep("error");
+			return;
 		}
-		verifyAfterCheckout();
+		if (enrollment !== "success" || !sessionId) return;
+		scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
+		setters.setStep("verifying-payment");
+		pollCourseRegistrationStatus(api, sessionId, setters, () => cancelled);
 		return () => {
 			cancelled = true;
 		};
-	}, [api]);
-	const handleValidateForm = () => {
-		const newErrors = validateFormData(formData);
-		setErrors(newErrors);
-		return Object.keys(newErrors).length === 0;
+	}, [
+		api,
+		setters.setEnrollmentResult,
+		setters.setErrorMessage,
+		setters.setStep
+	]);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationActions.ts
+function blocked(message, setters) {
+	setters.setErrorMessage(message);
+	setters.setStep("error");
+	return {
+		kind: "blocked",
+		message
 	};
-	const handleCourseSelect = (course) => {
-		setSelectedCourse(course);
-		setStep("enter-details");
+}
+function validateSubmission(state, setters) {
+	if (!state.selectedCourse) return {
+		kind: "blocked",
+		message: "Choose an available set of dates to continue."
 	};
-	const handleSubmit = async () => {
-		if (!selectedCourse) return {
-			kind: "blocked",
-			message: "Choose an available set of dates to continue."
-		};
-		if (!handleValidateForm()) return { kind: "validation-failed" };
-		if (missingPricingSelectionMessage) {
-			setErrorMessage(missingPricingSelectionMessage);
-			setStep("error");
-			return {
-				kind: "blocked",
-				message: missingPricingSelectionMessage
-			};
-		}
-		const requiresPayment = selectedCoursePricing?.selectedRequiresPayment ?? false;
-		const canUseMembership = requiresPayment && selectedCourse.acceptsMemberships && portalAuthState === "authenticated" && eligibleMemberships.length > 0;
-		if (showSpamProtection && !altchaSolution) {
-			const message = "Please complete the verification check.";
-			setErrorMessage(message);
-			setStep("error");
-			return {
-				kind: "blocked",
-				message
-			};
-		}
-		if (!waitlistClaim.claim && courseEligibility?.isFull && !courseEligibility.canJoinWaitlist && showSoldOutCourseError()) return {
-			kind: "blocked",
-			message: courseEligibility.reason ?? "This course is fully booked."
+	const errors = validateFormData(state.formData);
+	setters.setErrors(errors);
+	if (Object.keys(errors).length > 0) return { kind: "validation-failed" };
+	const pricingMessage = getMissingCoursePricingSelectionMessage(state.pricing);
+	if (pricingMessage) return blocked(pricingMessage, setters);
+	if (!state.hasClaim && state.eligibility?.isFull && !state.eligibility.canJoinWaitlist) return blocked(state.eligibility.reason ?? "This course is fully booked.", setters);
+	if (isSpamProtectionEnabled() && !state.altchaSolution) return blocked("Please complete the verification check.", setters);
+	return null;
+}
+function enrollmentPayload(state, payment) {
+	return {
+		...registrantPayload(state),
+		paymentMethod: payment.method,
+		...payment.method === "membership" ? { customerMembershipId: payment.membershipId } : {}
+	};
+}
+function registrantPayload(state) {
+	return {
+		eventSeriesId: state.selectedCourse.eventSeriesId,
+		...buildCoursePricingOptionPayload(state.pricing),
+		email: state.formData.email.trim().toLowerCase(),
+		name: state.formData.name.trim(),
+		phone: state.formData.phone.trim() || void 0,
+		formData: { notes: state.formData.notes.trim() || void 0 },
+		altchaSolution: state.altchaSolution,
+		claimToken: state.claimToken ?? void 0
+	};
+}
+async function enroll(state, setters, payment) {
+	setters.setStep("submitting");
+	try {
+		const result = await state.api.registerForWholeSeries(enrollmentPayload(state, payment));
+		setters.setEnrollmentResult({
+			status: result.status,
+			waitlistPosition: result.waitlistPosition ?? void 0,
+			usedMembership: payment.method === "membership"
+		});
+		setters.setStep(result.status === "waitlist" ? "waitlist" : "success");
+		return { kind: "state-updated" };
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : "Booking failed";
+		setters.setErrorMessage(message);
+		setters.setStep("error");
+		return {
+			kind: "failed",
+			message
 		};
-		if (courseEligibility?.canJoinWaitlist) {
-			setStep("submitting");
-			try {
-				const result = await api.enrollInCourse({
-					courseId: selectedCourse.id,
-					...selectedCoursePricingPayload,
-					email: formData.email.trim().toLowerCase(),
-					name: formData.name.trim(),
-					phone: formData.phone.trim() || void 0,
-					formData: { notes: formData.notes.trim() || void 0 },
-					altchaSolution,
-					paymentMethod: "free",
-					claimToken: waitlistClaim.token ?? void 0
-				});
-				setEnrollmentResult({
-					status: result.status,
-					waitlistPosition: result.waitlistPosition ?? void 0,
-					usedMembership: false
-				});
-				setStep(result.status === "waitlist" ? "waitlist" : "success");
-				return { kind: "state-updated" };
-			} catch (error) {
-				const message = error instanceof Error ? error.message : "Booking failed";
-				setErrorMessage(message);
-				setStep("error");
-				return {
-					kind: "failed",
-					message
-				};
-			}
-		}
-		if (requiresPayment && canUseMembership) {
-			setStep("select-payment");
-			return { kind: "state-updated" };
-		}
-		if (requiresPayment) {
-			setStep("submitting");
-			try {
-				const { successUrl, cancelUrl } = buildCheckoutReturnUrls("enrollment", COURSE_REGISTRATION_ANCHOR_ID);
-				const checkoutResult = await api.createCourseCheckout({
-					courseId: selectedCourse.id,
-					...selectedCoursePricingPayload,
-					email: formData.email.trim().toLowerCase(),
-					name: formData.name.trim(),
-					phone: formData.phone.trim() || void 0,
-					formData: { notes: formData.notes.trim() || void 0 },
-					altchaSolution,
-					discountCode: discountCode.trim() ? discountCode.trim() : void 0,
-					successUrl,
-					cancelUrl,
-					claimToken: waitlistClaim.token ?? void 0
-				});
-				if (checkoutResult.bypassed) {
-					setEnrollmentResult({
-						status: "enrolled",
-						waitlistPosition: void 0,
-						usedMembership: false
-					});
-					setStep("success");
-					return { kind: "state-updated" };
-				}
-				if (!checkoutResult.checkoutUrl) throw new Error("Checkout URL missing");
-				setStep("redirecting");
-				if (options.onCheckoutRedirect) options.onCheckoutRedirect(checkoutResult.checkoutUrl);
-				else window.location.href = checkoutResult.checkoutUrl;
-				return {
-					kind: "checkout-redirect",
-					checkoutUrl: checkoutResult.checkoutUrl
-				};
-			} catch (error) {
-				const message = error instanceof Error ? error.message : "Checkout failed";
-				setErrorMessage(message);
-				setStep("error");
-				return {
-					kind: "failed",
-					message
-				};
-			}
-		}
-		setStep("submitting");
-		try {
-			const result = await api.enrollInCourse({
-				courseId: selectedCourse.id,
-				...selectedCoursePricingPayload,
-				email: formData.email.trim().toLowerCase(),
-				name: formData.name.trim(),
-				phone: formData.phone.trim() || void 0,
-				formData: { notes: formData.notes.trim() || void 0 },
-				altchaSolution,
-				paymentMethod: "free",
-				claimToken: waitlistClaim.token ?? void 0
-			});
-			setEnrollmentResult({
-				status: result.status,
-				waitlistPosition: result.waitlistPosition ?? void 0,
-				usedMembership: result.paymentMethod === "membership"
+	}
+}
+async function checkout(state, setters) {
+	setters.setStep("submitting");
+	try {
+		const urls = buildCheckoutReturnUrls("enrollment", COURSE_REGISTRATION_ANCHOR_ID);
+		const result = await state.api.createWholeSeriesCheckout({
+			...registrantPayload(state),
+			discountCode: state.discountCode.trim() || void 0,
+			successUrl: urls.successUrl,
+			cancelUrl: urls.cancelUrl
+		});
+		if (result.bypassed) {
+			setters.setEnrollmentResult({
+				status: "enrolled",
+				usedMembership: false
 			});
-			setStep(result.status === "waitlist" ? "waitlist" : "success");
+			setters.setStep("success");
 			return { kind: "state-updated" };
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "Booking failed";
-			setErrorMessage(message);
-			setStep("error");
-			return {
-				kind: "failed",
-				message
-			};
 		}
-	};
-	const handlePaymentContinue = async () => {
-		if (!selectedCourse) return {
-			kind: "blocked",
-			message: "Choose an available set of dates to continue."
+		if (!result.checkoutUrl) throw new Error("Checkout URL missing");
+		setters.setStep("redirecting");
+		if (state.options.onCheckoutRedirect) state.options.onCheckoutRedirect(result.checkoutUrl);
+		else window.location.href = result.checkoutUrl;
+		return {
+			kind: "checkout-redirect",
+			checkoutUrl: result.checkoutUrl
 		};
-		if (!handleValidateForm()) return { kind: "validation-failed" };
-		if (missingPricingSelectionMessage) {
-			setErrorMessage(missingPricingSelectionMessage);
-			setStep("error");
-			return {
-				kind: "blocked",
-				message: missingPricingSelectionMessage
-			};
-		}
-		const requiresPayment = selectedCoursePricing?.selectedRequiresPayment ?? false;
-		if (!waitlistClaim.claim && courseEligibility?.isFull && !courseEligibility.canJoinWaitlist && showSoldOutCourseError()) return {
-			kind: "blocked",
-			message: courseEligibility.reason ?? "This course is fully booked."
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : "Checkout failed";
+		setters.setErrorMessage(message);
+		setters.setStep("error");
+		return {
+			kind: "failed",
+			message
 		};
-		if (!requiresPayment) {
-			setStep("enter-details");
-			return { kind: "state-updated" };
-		}
-		if (showSpamProtection && !altchaSolution) {
-			const message = "Please complete the verification check.";
-			setErrorMessage(message);
-			setStep("error");
-			return {
-				kind: "blocked",
-				message
-			};
-		}
-		if (paymentChoice === "membership") {
-			if (!selectedMembershipId) {
-				const message = "Select a membership to sign up.";
-				setErrorMessage(message);
-				setStep("error");
-				return {
-					kind: "blocked",
-					message
-				};
-			}
-			setStep("submitting");
-			try {
-				const result = await api.enrollInCourse({
-					courseId: selectedCourse.id,
-					...selectedCoursePricingPayload,
-					email: formData.email.trim().toLowerCase(),
-					name: formData.name.trim(),
-					phone: formData.phone.trim() || void 0,
-					formData: { notes: formData.notes.trim() || void 0 },
-					altchaSolution,
-					paymentMethod: "membership",
-					customerMembershipId: selectedMembershipId,
-					claimToken: waitlistClaim.token ?? void 0
-				});
-				setEnrollmentResult({
-					status: result.status,
-					waitlistPosition: result.waitlistPosition ?? void 0,
-					usedMembership: true
-				});
-				setStep(result.status === "waitlist" ? "waitlist" : "success");
-				return { kind: "state-updated" };
-			} catch (error) {
-				const message = error instanceof Error ? error.message : "Booking failed";
-				setErrorMessage(message);
-				setStep("error");
-				return {
-					kind: "failed",
-					message
-				};
-			}
-		}
-		setStep("submitting");
-		try {
-			const { successUrl, cancelUrl } = buildCheckoutReturnUrls("enrollment", COURSE_REGISTRATION_ANCHOR_ID);
-			const checkoutResult = await api.createCourseCheckout({
-				courseId: selectedCourse.id,
-				...selectedCoursePricingPayload,
-				email: formData.email.trim().toLowerCase(),
-				name: formData.name.trim(),
-				phone: formData.phone.trim() || void 0,
-				formData: { notes: formData.notes.trim() || void 0 },
-				altchaSolution,
-				discountCode: discountCode.trim() ? discountCode.trim() : void 0,
-				successUrl,
-				cancelUrl,
-				claimToken: waitlistClaim.token ?? void 0
-			});
-			if (checkoutResult.bypassed) {
-				setEnrollmentResult({
-					status: "enrolled",
-					waitlistPosition: void 0,
-					usedMembership: false
-				});
-				setStep("success");
-				return { kind: "state-updated" };
-			}
-			if (!checkoutResult.checkoutUrl) throw new Error("Checkout URL missing");
-			setStep("redirecting");
-			if (options.onCheckoutRedirect) options.onCheckoutRedirect(checkoutResult.checkoutUrl);
-			else window.location.href = checkoutResult.checkoutUrl;
-			return {
-				kind: "checkout-redirect",
-				checkoutUrl: checkoutResult.checkoutUrl
-			};
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "Checkout failed";
-			setErrorMessage(message);
-			setStep("error");
-			return {
-				kind: "failed",
-				message
-			};
-		}
+	}
+}
+async function submitDetails(state, setters) {
+	const invalid = validateSubmission(state, setters);
+	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (state.eligibility?.canJoinWaitlist) return enroll(state, setters, { method: "free" });
+	const requiresPayment = state.pricing?.selectedRequiresPayment ?? false;
+	const canUseMembership = requiresPayment && state.selectedCourse.acceptsMemberships && state.portalAuthState === "authenticated" && state.eligibleMemberships.length > 0;
+	if (requiresPayment && canUseMembership) {
+		setters.setStep("select-payment");
+		return { kind: "state-updated" };
+	}
+	if (requiresPayment) return checkout(state, setters);
+	return enroll(state, setters, { method: "free" });
+}
+async function continuePayment(state, setters) {
+	const invalid = validateSubmission(state, setters);
+	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (!state.pricing?.selectedRequiresPayment) {
+		setters.setStep("enter-details");
+		return { kind: "state-updated" };
+	}
+	const selectedState = state;
+	if (state.paymentChoice === "membership") {
+		if (!state.selectedMembershipId) return blocked("Select a membership to sign up.", setters);
+		return enroll(selectedState, setters, {
+			method: "membership",
+			membershipId: state.selectedMembershipId
+		});
+	}
+	return checkout(selectedState, setters);
+}
+function useCourseRegistrationActions(state, setStep) {
+	const [errors, setErrors] = useState({});
+	const [enrollmentResult, setEnrollmentResult] = useState(null);
+	const [errorMessage, setErrorMessage] = useState("");
+	const reportError = useCallback((message) => {
+		setErrorMessage(message);
+	}, []);
+	const recordEnrollmentResult = useCallback((result) => {
+		setEnrollmentResult(result);
+	}, []);
+	const setters = {
+		setStep,
+		setErrors,
+		setEnrollmentResult,
+		setErrorMessage
 	};
-	const handleRetry = () => {
-		setStep(scopedCourses.length === 1 ? "enter-details" : "select-course");
-		setErrorMessage("");
+	return {
+		errors,
+		enrollmentResult,
+		errorMessage,
+		reportError,
+		recordEnrollmentResult,
+		handleSubmit: () => submitDetails(state, setters),
+		handlePaymentContinue: () => continuePayment(state, setters)
 	};
-	const handleBookingModeChange = (mode) => {
-		setBookingMode(mode);
-		if (mode === "membership") setPaymentChoice("membership");
-		else setPaymentChoice("checkout");
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationPortal.ts
+const EMPTY_FORM = {
+	name: "",
+	email: "",
+	phone: "",
+	notes: ""
+};
+function useCourseRegistrationPortal(api) {
+	const [formData, setFormData] = useState(EMPTY_FORM);
+	const [portalAuthState, setPortalAuthState] = useState("checking");
+	const updateFormData = useCallback((updater) => {
+		setFormData(updater);
+	}, []);
+	useEffect(() => {
+		let cancelled = false;
+		if (!(api.config.auth.type === "bearer" || api.config.authOverrides?.portal?.type === "bearer")) {
+			setPortalAuthState("unauthenticated");
+			return;
+		}
+		setPortalAuthState("checking");
+		api.getPortalProfile().then((result) => {
+			if (cancelled) return;
+			setPortalAuthState("authenticated");
+			setFormData((current) => ({
+				...current,
+				email: result.profile.email,
+				name: current.name || result.profile.name,
+				phone: current.phone || result.profile.phone || ""
+			}));
+		}).catch(() => {
+			if (!cancelled) setPortalAuthState("unauthenticated");
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [api]);
+	return {
+		formData,
+		updateFormData,
+		portalAuthState
 	};
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseWaitlistSelection.ts
+function useCourseWaitlistSelection(input) {
+	useEffect(() => {
+		const claim = input.waitlistClaim.claim;
+		if (!claim || claim.subject.kind !== "whole_series") return;
+		const eventSeriesId = claim.subject.eventSeriesId;
+		const course = input.scopedCourses.find((candidate) => candidate.eventSeriesId === eventSeriesId);
+		if (!course) {
+			input.reportError("This waitlist claim is for a different course.");
+			input.goToStep("error");
+			return;
+		}
+		input.chooseCourse(course);
+		input.updateFormData((current) => ({
+			...current,
+			email: claim.prefill.email,
+			name: claim.prefill.name,
+			phone: claim.prefill.phone ?? "",
+			notes: claim.prefill.notes ?? ""
+		}));
+		if (input.step === "select-course") input.goToStep("enter-details");
+	}, [
+		input.chooseCourse,
+		input.goToStep,
+		input.reportError,
+		input.scopedCourses,
+		input.step,
+		input.updateFormData,
+		input.waitlistClaim.claim
+	]);
+	useEffect(() => {
+		if (input.waitlistClaim.requiresPortalLogin || !input.waitlistClaim.error) return;
+		input.reportError(input.waitlistClaim.error);
+		input.goToStep("error");
+	}, [
+		input.goToStep,
+		input.reportError,
+		input.waitlistClaim.error,
+		input.waitlistClaim.requiresPortalLogin
+	]);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.ts
+function useCourseRegistrationWizard(props, options = {}) {
+	const api = useBlockApi();
+	const selection = useCourseRegistrationSelection(props);
+	const portal = useCourseRegistrationPortal(api);
+	const waitlistClaim = useWaitlistClaim();
+	const [bookingMode, setBookingMode] = useState(null);
+	const [altchaSolution, setAltchaSolution] = useState(null);
+	const eligibility = useCourseEligibility({
+		api,
+		selectedCourse: selection.selectedCourse,
+		hasPaidSelection: selection.selectedCoursePricing?.hasPaidSelection ?? false,
+		portalAuthState: portal.portalAuthState,
+		waitlistClaimToken: waitlistClaim.token
+	});
 	const discountUi = useDiscountCodeUi({
 		api,
-		discountContext: useMemo(() => {
-			if (!selectedCourse) return null;
-			if (!selectedCoursePricing?.selectedRequiresPayment) return null;
-			if (paymentChoice !== "checkout") return null;
-			return {
-				type: "course",
-				courseId: selectedCourse.id
-			};
-		}, [
-			selectedCourse,
-			selectedCoursePricing?.selectedRequiresPayment,
-			paymentChoice
+		discountContext: useMemo(() => selection.selectedCourse && selection.selectedCoursePricing?.selectedRequiresPayment && eligibility.paymentChoice === "checkout" ? {
+			type: "whole_series",
+			eventSeriesId: selection.selectedCourse.eventSeriesId
+		} : null, [
+			eligibility.paymentChoice,
+			selection.selectedCourse,
+			selection.selectedCoursePricing?.selectedRequiresPayment
 		]),
-		subtotalCents: selectedCoursePricing?.selectedPriceAmount ?? void 0
+		subtotalCents: selection.selectedCoursePricing?.selectedPriceAmount ?? void 0
 	});
-	const discountCode = discountUi.discountCode;
-	const hasCoursePayment = resolveHasCoursePayment(selectedCoursePricing);
-	const canUseMembership = hasCoursePayment && selectedCourse?.acceptsMemberships === true && portalAuthState === "authenticated" && eligibleMemberships.length > 0;
-	const hasPreSelectedCourse = scopedCourses.length === 1;
-	const isMembershipFastTrack = canUseMembership && eligibleMemberships.length === 1 && bookingMode === "membership";
-	const wizardSteps = useMemo(() => getWizardStepsForContext(hasPreSelectedCourse, hasCoursePayment, canUseMembership, bookingMode, isMembershipFastTrack), [
-		hasPreSelectedCourse,
-		hasCoursePayment,
-		canUseMembership,
-		bookingMode,
-		isMembershipFastTrack
-	]);
-	const currentStepNumber = getStepNumber(step, wizardSteps);
-	const totalSteps = wizardSteps.length;
-	const stepLabels = getStepLabels(wizardSteps);
-	const canShowPortalAuthSidebarOnCurrentStep = step !== "success" && step !== "waitlist" && step !== "error";
-	const showPortalAuthSidebar = portalAuthState === "unauthenticated" && waitlistClaim.requiresPortalLogin && canShowPortalAuthSidebarOnCurrentStep || portalAuthState === "unauthenticated" && hasCoursePayment && selectedCourse?.acceptsMemberships === true && step !== "select-course" && canShowPortalAuthSidebarOnCurrentStep;
-	return {
+	const actions = useCourseRegistrationActions({
 		api,
-		scopedCourses,
-		step,
-		setStep,
-		selectedCourse,
-		selectedPricingOptionId,
-		setSelectedPricingOptionId,
-		selectedSlidingAmountInput,
-		setSelectedSlidingAmountInput,
-		selectedCoursePricing,
-		setSelectedCourse,
-		formData,
-		setFormData,
-		errors,
-		enrollmentResult,
-		errorMessage,
-		portalAuthState,
-		handleLogout: portalAuthState === "authenticated" ? () => logoutPortal(COURSE_REGISTRATION_ANCHOR_ID) : void 0,
+		selectedCourse: selection.selectedCourse,
+		pricing: selection.selectedCoursePricing,
+		formData: portal.formData,
+		portalAuthState: portal.portalAuthState,
+		eligibility: eligibility.courseEligibility,
+		eligibleMemberships: eligibility.eligibleMemberships,
+		paymentChoice: eligibility.paymentChoice,
+		selectedMembershipId: eligibility.selectedMembershipId,
+		claimToken: waitlistClaim.token,
+		hasClaim: waitlistClaim.claim !== null,
 		altchaSolution,
-		setAltchaSolution,
-		showSpamProtection,
-		eligibilityLoading,
-		eligibilityError,
-		courseEligibility,
-		eligibleMemberships,
-		paymentChoice,
-		setPaymentChoice,
-		selectedMembershipId,
-		setSelectedMembershipId,
-		discountUiOpen: discountUi.discountUiOpen,
-		setDiscountUiOpen: discountUi.setDiscountUiOpen,
 		discountCode: discountUi.discountCode,
-		setDiscountCode: discountUi.setDiscountCode,
-		discountsAvailable: discountUi.discountsAvailable,
-		manualCodeEntryAllowed: discountUi.manualCodeEntryAllowed,
-		discountsAvailableLoading: discountUi.discountsAvailableLoading,
-		canUseMembership,
+		options
+	}, selection.goToStep);
+	useCourseRegistrationEffects({
+		api,
+		actions,
+		portal,
+		selection,
+		waitlistClaim
+	});
+	return buildCourseRegistrationWizardResult({
+		api,
+		selection,
+		portal,
+		eligibility,
+		actions,
+		discountUi,
 		waitlistClaim,
+		view: deriveCourseRegistrationViewState({
+			scopedCourses: selection.scopedCourses,
+			selectedCourse: selection.selectedCourse,
+			pricing: selection.selectedCoursePricing,
+			portalAuthState: portal.portalAuthState,
+			eligibleMembershipCount: eligibility.eligibleMemberships.length,
+			bookingMode,
+			step: selection.step,
+			waitlistRequiresPortalLogin: waitlistClaim.requiresPortalLogin
+		}),
 		bookingMode,
-		wizardSteps,
-		currentStepNumber,
-		totalSteps,
-		stepLabels,
-		showPortalAuthSidebar,
-		hasPreSelectedCourse,
-		hasCoursePayment,
-		handleCourseSelect,
-		handleSubmit,
-		handlePaymentContinue,
-		handleRetry,
-		handleBookingModeChange
+		setBookingMode,
+		altchaSolution,
+		setAltchaSolution
+	});
+}
+function useCourseRegistrationEffects(input) {
+	useCoursePaymentVerification(input.api, {
+		setStep: input.selection.goToStep,
+		setErrorMessage: input.actions.reportError,
+		setEnrollmentResult: input.actions.recordEnrollmentResult
+	});
+	useCourseWaitlistSelection({
+		waitlistClaim: input.waitlistClaim,
+		scopedCourses: input.selection.scopedCourses,
+		step: input.selection.step,
+		goToStep: input.selection.goToStep,
+		chooseCourse: input.selection.chooseCourse,
+		updateFormData: input.portal.updateFormData,
+		reportError: input.actions.reportError
+	});
+}
+function buildCourseRegistrationWizardResult(parts) {
+	const handleBookingModeChange = (mode) => {
+		parts.setBookingMode(mode);
+		parts.eligibility.choosePaymentChoice(mode === "membership" ? "membership" : "checkout");
+	};
+	return {
+		api: parts.api,
+		...parts.selection,
+		...parts.portal,
+		...parts.eligibility,
+		...parts.actions,
+		waitlistClaim: parts.waitlistClaim,
+		bookingMode: parts.bookingMode,
+		altchaSolution: parts.altchaSolution,
+		setAltchaSolution: parts.setAltchaSolution,
+		showSpamProtection: isSpamProtectionEnabled(),
+		discountUiOpen: parts.discountUi.discountUiOpen,
+		setDiscountUiOpen: parts.discountUi.setDiscountUiOpen,
+		discountCode: parts.discountUi.discountCode,
+		setDiscountCode: parts.discountUi.setDiscountCode,
+		discountsAvailable: parts.discountUi.discountsAvailable,
+		manualCodeEntryAllowed: parts.discountUi.manualCodeEntryAllowed,
+		discountsAvailableLoading: parts.discountUi.discountsAvailableLoading,
+		...parts.view,
+		handleCourseSelect: (course) => {
+			parts.selection.chooseCourse(course);
+			parts.selection.goToStep("enter-details");
+		},
+		handleRetry: () => {
+			parts.selection.goToStep(parts.selection.scopedCourses.length === 1 ? "enter-details" : "select-course");
+			parts.actions.reportError("");
+		},
+		handleBookingModeChange,
+		handleLogout: parts.portal.portalAuthState === "authenticated" ? () => logoutPortal(COURSE_REGISTRATION_ANCHOR_ID) : void 0,
+		selectedCoursePricingPayload: buildCoursePricingOptionPayload(parts.selection.selectedCoursePricing)
 	};
 }
 //#endregion
@@ -1654,7 +1639,7 @@ function getCourseSlidingScaleMessage(pricing) {
 }
 function CourseRegistrationWizard(props) {
 	const { showSessions = true, showPrice = true, showCapacity = true, showVenue = true, successMessage = "You're booked in! Check your email for confirmation and session details.", waitlistMessage = "You've been added to the waitlist. We'll email you a claim link if a spot opens up.", membershipMessage = "Booked using your membership! Check your email for session details.", buttonText = "Sign up", buttonVariant = "primary", className } = props;
-	const { api, scopedCourses, step, setStep, selectedCourse, selectedPricingOptionId, setSelectedPricingOptionId, selectedSlidingAmountInput, setSelectedSlidingAmountInput, selectedCoursePricing, formData, setFormData, errors, enrollmentResult, errorMessage, portalAuthState, handleLogout, altchaSolution: _altchaSolution, setAltchaSolution, showSpamProtection, eligibilityLoading, eligibilityError, courseEligibility, eligibleMemberships, paymentChoice, setPaymentChoice, selectedMembershipId, setSelectedMembershipId, discountUiOpen, setDiscountUiOpen, discountCode, setDiscountCode, discountsAvailable, manualCodeEntryAllowed, discountsAvailableLoading, waitlistClaim, canUseMembership: _canUseMembership, bookingMode, currentStepNumber, totalSteps, stepLabels, showPortalAuthSidebar, hasPreSelectedCourse: _hasPreSelectedCourse, hasCoursePayment: _hasCoursePayment, handleCourseSelect, handleSubmit, handlePaymentContinue, handleRetry, handleBookingModeChange } = useCourseRegistrationWizard(props);
+	const { api, scopedCourses, step, goToStep, selectedCourse, selectedPricingOptionId, choosePricingOption, selectedSlidingAmountInput, changeSlidingAmount, selectedCoursePricing, formData, updateFormData, errors, enrollmentResult, errorMessage, portalAuthState, handleLogout, altchaSolution: _altchaSolution, setAltchaSolution, showSpamProtection, eligibilityLoading, eligibilityError, courseEligibility, eligibleMemberships, paymentChoice, choosePaymentChoice, selectedMembershipId, chooseMembership, discountUiOpen, setDiscountUiOpen, discountCode, setDiscountCode, discountsAvailable, manualCodeEntryAllowed, discountsAvailableLoading, waitlistClaim, canUseMembership: _canUseMembership, bookingMode, currentStepNumber, totalSteps, stepLabels, showPortalAuthSidebar, hasPreSelectedCourse: _hasPreSelectedCourse, hasCoursePayment: _hasCoursePayment, handleCourseSelect, handleSubmit, handlePaymentContinue, handleRetry, handleBookingModeChange } = useCourseRegistrationWizard(props);
 	const buttonClass = themeButtonClassName({
 		variant: buttonVariant,
 		size: "md"
@@ -1719,13 +1704,13 @@ function CourseRegistrationWizard(props) {
 							className: "cr-course-list",
 							children: scopedCourses.map((course) => /* @__PURE__ */ jsx(CourseCard, {
 								course,
-								isSelected: selectedCourse?.id === course.id,
+								isSelected: selectedCourse?.eventSeriesId === course.eventSeriesId,
 								onSelect: () => handleCourseSelect(course),
 								showSessions,
 								showPrice,
 								showCapacity,
 								showVenue
-							}, course.id))
+							}, course.eventSeriesId))
 						}),
 						step === "enter-details" && selectedCourseWithPricing && /* @__PURE__ */ jsxs("div", {
 							className: "cr-details",
@@ -1742,7 +1727,7 @@ function CourseRegistrationWizard(props) {
 									className: "cr-actions",
 									children: /* @__PURE__ */ jsx("button", {
 										type: "button",
-										onClick: () => setStep("select-course"),
+										onClick: () => goToStep("select-course"),
 										className: "cr-back-btn",
 										children: "← Back"
 									})
@@ -1761,7 +1746,7 @@ function CourseRegistrationWizard(props) {
 										/* @__PURE__ */ jsx(EnrollmentForm, {
 											formData,
 											errors,
-											onChange: setFormData,
+											onChange: updateFormData,
 											isEmailLocked: portalAuthState === "authenticated" || waitlistClaim.claim !== null,
 											isLoading: portalAuthState === "checking" || waitlistClaim.isLoading,
 											onLogout: handleLogout
@@ -1769,12 +1754,12 @@ function CourseRegistrationWizard(props) {
 										/* @__PURE__ */ jsx(CoursePricingSelector, {
 											pricing: selectedCourseWithPricing.pricing,
 											selectedPricingOptionId,
-											onSelect: setSelectedPricingOptionId
+											onSelect: choosePricingOption
 										}),
 										/* @__PURE__ */ jsx(CourseSlidingScaleInput, {
 											pricing: selectedCourseWithPricing.pricing,
 											value: selectedSlidingAmountInput,
-											onChange: setSelectedSlidingAmountInput
+											onChange: changeSlidingAmount
 										}),
 										showSpamProtection && /* @__PURE__ */ jsx("div", {
 											className: "cr-altcha",
@@ -1799,7 +1784,7 @@ function CourseRegistrationWizard(props) {
 											className: "cr-actions",
 											children: [scopedCourses.length > 1 && /* @__PURE__ */ jsx("button", {
 												type: "button",
-												onClick: () => setStep("select-course"),
+												onClick: () => goToStep("select-course"),
 												className: "cr-back-btn",
 												children: "← Back"
 											}), /* @__PURE__ */ jsx("button", {
@@ -1849,7 +1834,7 @@ function CourseRegistrationWizard(props) {
 									onBookingModeChange: handleBookingModeChange,
 									eligibleMemberships,
 									selectedMembershipId,
-									onMembershipSelect: setSelectedMembershipId,
+									onMembershipSelect: chooseMembership,
 									priceCents: selectedCoursePricing?.selectedPriceAmount ?? null,
 									currency: selectedCourseWithPricing.course.currency ?? "GBP"
 								}),
@@ -1857,7 +1842,7 @@ function CourseRegistrationWizard(props) {
 									className: "cr-actions",
 									children: [/* @__PURE__ */ jsx("button", {
 										type: "button",
-										onClick: () => setStep("enter-details"),
+										onClick: () => goToStep("enter-details"),
 										className: "cr-back-btn",
 										children: "← Back"
 									}), /* @__PURE__ */ jsx("button", {
@@ -1896,7 +1881,7 @@ function CourseRegistrationWizard(props) {
 														type: "radio",
 														name: "paymentChoice",
 														checked: paymentChoice === "membership",
-														onChange: () => setPaymentChoice("membership")
+														onChange: () => choosePaymentChoice("membership")
 													}), /* @__PURE__ */ jsx("span", { children: "Use a membership (free)" })]
 												}),
 												paymentChoice === "membership" && eligibleMemberships.length > 1 && /* @__PURE__ */ jsxs("div", {
@@ -1909,7 +1894,7 @@ function CourseRegistrationWizard(props) {
 														id: "cr-membership",
 														className: "cr-form__input",
 														value: selectedMembershipId ?? "",
-														onChange: (e) => setSelectedMembershipId(e.target.value || null),
+														onChange: (e) => chooseMembership(e.target.value || null),
 														children: [/* @__PURE__ */ jsx("option", {
 															value: "",
 															disabled: true,
@@ -1926,7 +1911,7 @@ function CourseRegistrationWizard(props) {
 														type: "radio",
 														name: "paymentChoice",
 														checked: paymentChoice === "checkout",
-														onChange: () => setPaymentChoice("checkout")
+														onChange: () => choosePaymentChoice("checkout")
 													}), /* @__PURE__ */ jsx("span", { children: "Pay by card" })]
 												})
 											]
@@ -1948,7 +1933,7 @@ function CourseRegistrationWizard(props) {
 										className: "cr-actions",
 										children: [/* @__PURE__ */ jsx("button", {
 											type: "button",
-											onClick: () => setStep("enter-details"),
+											onClick: () => goToStep("enter-details"),
 											className: "cr-back-btn",
 											children: "← Back"
 										}), /* @__PURE__ */ jsx("button", {