@riverbankcms/sdk 0.130.2 → 0.132.0

package/dist/client/bookings.mjs

@@ -7530,6 +7530,12 @@ const opaqueButtonColourTokenSchema = themeColorTokenSchema.refine((value) => pa
 	if (token === null) throw new Error("Invariant: opaque button token passed its schema");
 	return token;
 });
+const contextualButtonHoverSchema = z.strictObject({
+	kind: z.literal("shade-shift"),
+	seedToken: opaqueButtonColourTokenSchema,
+	fallbackDirection: z.enum(["lighter", "darker"]),
+	preferredToken: opaqueButtonColourTokenSchema.optional()
+});
 const buttonShadeAmountSchema = z.number().finite().min(0).max(900).multipleOf(100);
 const buttonShadowIntensitySchema = z.enum([
 	"subtle",
@@ -7869,6 +7875,7 @@ const buttonVariantSchema = z.strictObject({
 	shadow: variantShadowSchema.optional(),
 	border: buttonBorderSchema.optional(),
 	hoverBackgroundToken: opaqueButtonColourTokenSchema.optional(),
+	contextualHover: contextualButtonHoverSchema.optional(),
 	effects: variantEffectsSchema.optional(),
 	sizes: variantSizeOverridesSchema.optional(),
 	affordance: buttonVariantAffordanceSchema.optional()
@@ -8154,8 +8161,8 @@ const openCardRoleValue = "open";
 */
 const surfaceCardRoleValues = [...cardVariantRoleValues, openCardRoleValue];
 /**
-* The closed card-role vocabulary Looks and blocks address cards by — this is
-* `BoxStylesCardVariant` widened with `open`, not a parallel enum.
+* The closed role vocabulary Looks and blocks use for surfaced and boxless
+* card choices.
 *
 * - `none`        — no site-style card surface; the block's own composition and
 *                   the author's own card fields govern the item. This is *not*
@@ -8199,11 +8206,6 @@ const gradientDirectionSchema = z.enum([
 z.enum(cardVariantRoleValues);
 const surfaceCardRoleSchema = z.enum(surfaceCardRoleValues);
 const cardRoleSchema = z.enum(cardRoleValues);
-/**
-* Historical name for the role vocabulary as it reaches box styles. Widened to
-* the full `CardRole` set — old values keep parsing, `open` now parses too.
-*/
-const boxStylesCardVariantSchema = cardRoleSchema;
 const PRIORITY_ROLE_INFERENCE = {
 	1: "default",
 	2: "alternative"
@@ -9608,8 +9610,7 @@ const cardStylesOverrideSchema = z.object({
 	spacing: semanticSpacingSchema.nullable().optional(),
 	raised: z.boolean().nullable().optional(),
 	rounded: boxRoundedSchema.nullable().optional(),
-	role: cardRoleSchema.nullable().optional(),
-	cardVariant: boxStylesCardVariantSchema.nullable().optional()
+	role: cardRoleSchema.nullable().optional()
 });
 const blockStyleOverridesSchema = z.object({
 	sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
@@ -10238,13 +10239,7 @@ function shadeBackgroundEffect(config) {
 buttonSizeNameSchema.options;
 //#endregion
 //#region ../theme-core/src/buttons/styles/domain.ts
-const PUBLIC_BUTTON_ROLES = [
-	"primary",
-	"secondary",
-	"outline",
-	"ghost",
-	"accent"
-];
+const PUBLIC_BUTTON_ROLES = VARIANT_ROLES;
 function defineButtonStyleRecipe(recipe) {
 	return recipe;
 }
@@ -10340,6 +10335,14 @@ const BUTTON_STYLE_IDS = [
 	"quiet-arrow"
 ];
 const quietArrowParametersSchema = z.object({ secondaryTreatment: z.enum(["outlined", "solid-accent"]) }).strict();
+const flatInkHoverTreatmentSchema = z.enum([
+	"contextual",
+	"secondary",
+	"accent"
+]);
+const flatInkHoverPreferencesShape = Object.fromEntries(VARIANT_ROLES.map((role) => [role, flatInkHoverTreatmentSchema.optional()]));
+const flatInkHoverPreferencesSchema = z.strictObject(flatInkHoverPreferencesShape);
+const flatInkParametersSchema = z.strictObject({ hoverPreferences: flatInkHoverPreferencesSchema.optional() });
 const emptyParametersSchema$1 = z.object({}).strict();
 function selectionBranch(styleId, parameters) {
 	return z.object({
@@ -10354,7 +10357,7 @@ z.discriminatedUnion("styleId", [
 	selectionBranch("editorial-link", emptyParametersSchema$1),
 	selectionBranch("pebble", emptyParametersSchema$1),
 	selectionBranch("ink-stamp", emptyParametersSchema$1),
-	selectionBranch("flat-ink", emptyParametersSchema$1),
+	selectionBranch("flat-ink", flatInkParametersSchema),
 	selectionBranch("brushed-wash", emptyParametersSchema$1),
 	selectionBranch("showtime-pill", emptyParametersSchema$1),
 	selectionBranch("joy-stamp", emptyParametersSchema$1),
@@ -10491,6 +10494,189 @@ const quietArrowRecipe = defineButtonStyleRecipe({
 	})
 });
 //#endregion
+//#region ../theme-core/src/buttons/styles/recipes/flatInk.ts
+const contextualRoleConfig = {
+	primary: {
+		contextualSeedToken: unsafeAsOpaqueButtonColourToken("primary"),
+		fallbackDirection: "darker"
+	},
+	secondary: {
+		contextualSeedToken: unsafeAsOpaqueButtonColourToken("surfaceAlt"),
+		fallbackDirection: "darker"
+	},
+	outline: {
+		contextualSeedToken: unsafeAsOpaqueButtonColourToken("surfaceAlt"),
+		fallbackDirection: "darker"
+	},
+	ghost: {
+		contextualSeedToken: unsafeAsOpaqueButtonColourToken("surfaceAlt"),
+		fallbackDirection: "darker"
+	},
+	accent: {
+		contextualSeedToken: unsafeAsOpaqueButtonColourToken("accent"),
+		fallbackDirection: "darker"
+	}
+};
+const hoverControl = {
+	kind: "button-hover-by-role",
+	parameter: "hoverPreferences",
+	label: "Button hover",
+	roles: contextualRoleConfig,
+	options: [
+		{
+			value: "contextual",
+			label: "Contextual shade shift"
+		},
+		{
+			value: "secondary",
+			label: "Secondary button colour"
+		},
+		{
+			value: "accent",
+			label: "Accent button colour"
+		}
+	]
+};
+const lift = { effectId: "lift" };
+const flatInkRecipe = defineButtonStyleRecipe({
+	id: "flat-ink",
+	accessibilityLabel: "Flat rounded buttons with arrow affordances",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "editorial"
+	},
+	parameterSchema: flatInkParametersSchema,
+	defaultParameters: {},
+	controls: [hoverControl],
+	defineSystem: (parameters) => ({
+		global: {
+			cornerStyle: "rounded",
+			textTransform: "none",
+			fontWeight: 600,
+			typography: "body",
+			letterSpacing: "tight",
+			paddingPreset: "default",
+			hoverTransform: "lift",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.125rem",
+				fontSize: "text-sm"
+			},
+			md: { padding: "0.8125rem 1.375rem" },
+			lg: {
+				padding: "0.9375rem 1.625rem",
+				fontSize: "text-lg"
+			},
+			xl: {
+				padding: "1.0625rem 2rem",
+				fontSize: "text-xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: unsafeAsOpaqueButtonColourToken("primary")
+					},
+					borderRadius: "rounded-lg",
+					affordance: { iconId: "ArrowRight" },
+					...hoverAppearance("primary", parameters, [lift, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("secondary") }
+					}])
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					...hoverAppearance("secondary", parameters, [lift, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
+					}])
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					...hoverAppearance("outline", parameters, [lift, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
+					}])
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					...hoverAppearance("ghost", parameters, [lift])
+				}
+			},
+			accent: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: unsafeAsOpaqueButtonColourToken("accent")
+					},
+					borderRadius: "rounded-lg",
+					affordance: { iconId: "ArrowRight" },
+					...hoverAppearance("accent", parameters, [lift])
+				}
+			}
+		}
+	})
+});
+function hoverAppearance(role, parameters, recommended) {
+	const preference = parameters.hoverPreferences?.[role];
+	if (preference === void 0) return { effects: { hover: [...recommended] } };
+	if (preference === "contextual") {
+		const config = contextualRoleConfig[role];
+		return {
+			effects: { hover: [lift] },
+			contextualHover: {
+				kind: "shade-shift",
+				seedToken: config.contextualSeedToken,
+				fallbackDirection: config.fallbackDirection
+			}
+		};
+	}
+	const config = contextualRoleConfig[role];
+	return {
+		effects: { hover: [lift] },
+		contextualHover: {
+			kind: "shade-shift",
+			seedToken: config.contextualSeedToken,
+			fallbackDirection: config.fallbackDirection,
+			preferredToken: unsafeAsOpaqueButtonColourToken(paletteRole(preference))
+		}
+	};
+}
+function paletteRole(preference) {
+	return preference;
+}
+//#endregion
 //#region ../theme-core/src/buttons/styles/recipes/defineStaticButtonStyleRecipe.ts
 const emptyParametersSchema = z.object({}).strict();
 function defineStaticButtonStyleRecipe(input) {
@@ -11337,113 +11523,6 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 		}
 	}
 });
-const flatInkRecipe = defineStaticButtonStyleRecipe({
-	id: "flat-ink",
-	accessibilityLabel: "Flat rounded buttons with arrow affordances",
-	tags: {
-		tone: "classic",
-		energy: "calm",
-		motion: "subtle",
-		era: "editorial"
-	},
-	system: {
-		global: {
-			cornerStyle: "rounded",
-			textTransform: "none",
-			fontWeight: 600,
-			typography: "body",
-			letterSpacing: "tight",
-			paddingPreset: "default",
-			hoverTransform: "lift",
-			hoverColor: "none"
-		},
-		sizes: {
-			sm: {
-				padding: "0.625rem 1.125rem",
-				fontSize: "text-sm"
-			},
-			md: { padding: "0.8125rem 1.375rem" },
-			lg: {
-				padding: "0.9375rem 1.625rem",
-				fontSize: "text-lg"
-			},
-			xl: {
-				padding: "1.0625rem 2rem",
-				fontSize: "text-xl"
-			}
-		},
-		roles: {
-			primary: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "solid",
-						colorToken: "primary"
-					},
-					borderRadius: "rounded-lg",
-					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("secondary") }
-					}] }
-				}
-			},
-			secondary: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					border: { widthClass: "border" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
-					}] }
-				}
-			},
-			outline: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					border: { widthClass: "border" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
-					}] }
-				}
-			},
-			ghost: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					effects: { hover: [{ effectId: "lift" }] }
-				}
-			},
-			accent: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "solid",
-						colorToken: "accent"
-					},
-					borderRadius: "rounded-lg",
-					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{ effectId: "lift" }] }
-				}
-			}
-		}
-	}
-});
 const showtimePillRecipe = defineStaticButtonStyleRecipe({
 	id: "showtime-pill",
 	accessibilityLabel: "Bold uppercase pill buttons with playful movement",
@@ -12198,17 +12277,17 @@ function StepIndicator({ currentStep, totalSteps, stepLabels, classPrefix, emitS
 //#endregion
 //#region ../blocks/src/system/runtime/shared/components/DiscountCodeDisclosure.tsx
 const BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES = {
-	"course-registration": {
-		root: "cr-discount",
-		toggle: "cr-discount__toggle",
-		form: "cr-discount__form",
-		label: "cr-discount__label",
-		row: "cr-discount__row",
-		input: "cr-discount__input",
-		apply: "cr-discount__apply",
-		remove: "cr-discount__remove",
-		hint: "cr-discount__hint",
-		feedback: "cr-discount__feedback"
+	"whole-series-registration": {
+		root: "er-whole-series-discount",
+		toggle: "er-whole-series-discount__toggle",
+		form: "er-whole-series-discount__form",
+		label: "er-whole-series-discount__label",
+		row: "er-whole-series-discount__row",
+		input: "er-whole-series-discount__input",
+		apply: "er-whole-series-discount__apply",
+		remove: "er-whole-series-discount__remove",
+		hint: "er-whole-series-discount__hint",
+		feedback: "er-whole-series-discount__feedback"
 	},
 	"event-registration": {
 		root: "er-discount",
@@ -13764,6 +13843,15 @@ function existingRegistrationLookupReducer(state, action) {
 * Custom hooks for portal authentication and eligibility checking.
 * Extracted from the main EventRegistrationClient for better separation of concerns.
 */
+function scopePortalCreditStateToSubject(state, subjectEmail) {
+	if (!subjectEmail) return { kind: "not_authenticated" };
+	if (state.kind === "not_authenticated") return state;
+	const normalizedSubject = subjectEmail.trim().toLowerCase();
+	return state.subjectEmail === normalizedSubject ? state : {
+		kind: "loading",
+		subjectEmail: normalizedSubject
+	};
+}
 const eventRegistrationHooksDeps = { useBlockApi };
 /**
 * Hook for managing portal authentication state.
@@ -13778,27 +13866,54 @@ function usePortalAuthWithDeps(deps) {
 	const api = deps.useBlockApi();
 	const [authState, setAuthState] = useState("checking");
 	const [profile, setProfile] = useState(null);
+	const [creditState, setCreditState] = useState({ kind: "not_authenticated" });
 	useEffect(() => {
 		let cancelled = false;
 		async function checkPortalAuth() {
 			if ((api.config.authOverrides?.portal ?? api.config.auth).type !== "bearer") {
 				setAuthState("unauthenticated");
+				setProfile(null);
+				setCreditState({ kind: "not_authenticated" });
 				return;
 			}
 			setAuthState("checking");
+			setProfile(null);
+			setCreditState({ kind: "not_authenticated" });
 			try {
 				const me = await api.getPortalProfile();
 				if (cancelled) return;
-				setAuthState("authenticated");
-				setProfile({
+				const nextProfile = {
 					email: me.profile.email,
 					name: me.profile.name,
 					phone: me.profile.phone || ""
+				};
+				const subjectEmail = nextProfile.email.trim().toLowerCase();
+				setProfile(nextProfile);
+				setCreditState({
+					kind: "loading",
+					subjectEmail
 				});
+				setAuthState("authenticated");
+				try {
+					const credit = await api.getPortalCredit();
+					if (cancelled) return;
+					setCreditState({
+						kind: "loaded",
+						subjectEmail,
+						credit
+					});
+				} catch {
+					if (cancelled) return;
+					setCreditState({
+						kind: "unavailable",
+						subjectEmail
+					});
+				}
 			} catch {
 				if (cancelled) return;
 				setAuthState("unauthenticated");
 				setProfile(null);
+				setCreditState({ kind: "not_authenticated" });
 			}
 		}
 		checkPortalAuth();
@@ -13818,6 +13933,7 @@ function usePortalAuthWithDeps(deps) {
 		isAuthenticated: authState === "authenticated",
 		isChecking: authState === "checking",
 		profile,
+		creditState: scopePortalCreditStateToSubject(creditState, authState === "authenticated" ? profile?.email ?? null : null),
 		logout
 	};
 }
@@ -14058,9 +14174,14 @@ function getWaitlistClaimTokenSnapshot() {
 function useWaitlistClaim() {
 	return useWaitlistClaimWithDeps(useWaitlistClaimDeps);
 }
+function useWaitlistClaimForToken(token) {
+	return useResolvedWaitlistClaim(useWaitlistClaimDeps, token);
+}
 function useWaitlistClaimWithDeps(deps) {
+	return useResolvedWaitlistClaim(deps, useSyncExternalStore(subscribeToWaitlistClaimToken, getWaitlistClaimTokenSnapshot, () => null));
+}
+function useResolvedWaitlistClaim(deps, token) {
 	const api = deps.useBlockApi();
-	const token = useSyncExternalStore(subscribeToWaitlistClaimToken, getWaitlistClaimTokenSnapshot, () => null);
 	const [state, dispatch] = useReducer(waitlistClaimReducer, Boolean(token), createInitialWaitlistClaimState);
 	useEffect(() => {
 		let cancelled = false;
@@ -14773,19 +14894,171 @@ const RichTextDocSchema = z.object({
 	content: z.array(TipTapNodeSchema)
 }).strict();
 //#endregion
-//#region ../blocks/src/system/blocks/courses/shared/schemas.ts
-/**
-* Zod schema for course venue data
-*/
-const courseVenueSchema = z.object({
+//#region ../blocks/src/system/blocks/events/whole-series/pricing.ts
+function isSaleWindowOpen(option, now) {
+	if (!option.isActive) return false;
+	if (option.saleStartsAt && new Date(option.saleStartsAt) > now) return false;
+	if (option.saleEndsAt && new Date(option.saleEndsAt) < now) return false;
+	return true;
+}
+function toExactOrFreeDisplay(amount, currency) {
+	if (amount <= 0) return {
+		kind: "free",
+		currency
+	};
+	return {
+		kind: "exact",
+		amount,
+		currency
+	};
+}
+function getSelectableWholeSeriesPricingOptionsForNow(offering, now) {
+	if (offering.pricing.pricingStrategy !== "tiered") return [];
+	return [...offering.pricing.options].filter((option) => isSaleWindowOpen(option, now)).sort((left, right) => {
+		if (left.sortOrder !== right.sortOrder) return left.sortOrder - right.sortOrder;
+		if (left.priceAmount !== right.priceAmount) return left.priceAmount - right.priceAmount;
+		return left.name.localeCompare(right.name);
+	});
+}
+function resolveWholeSeriesPricingState(offering, selectedPricingOptionId, selectedSlidingAmountOrNowInput, nowInput = {}) {
+	const selection = normalizePricingSelectionInput(selectedSlidingAmountOrNowInput, nowInput);
+	const currency = offering.pricing.currency;
+	switch (offering.pricing.pricingStrategy) {
+		case "free": return resolveFreePricing(currency);
+		case "single": return resolveSinglePricing(offering.pricing.singlePriceAmount ?? 0, currency);
+		case "tiered": return resolveTieredPricing(offering, selectedPricingOptionId, selection.nowInput);
+		case "sliding_scale": return resolveSlidingScalePricing(offering, selection.selectedSlidingAmount);
+	}
+}
+function normalizePricingSelectionInput(selectedSlidingAmountOrNowInput, nowInput) {
+	return typeof selectedSlidingAmountOrNowInput === "object" && selectedSlidingAmountOrNowInput !== null ? {
+		selectedSlidingAmount: null,
+		nowInput: selectedSlidingAmountOrNowInput
+	} : {
+		selectedSlidingAmount: typeof selectedSlidingAmountOrNowInput === "number" || selectedSlidingAmountOrNowInput === null ? selectedSlidingAmountOrNowInput : null,
+		nowInput
+	};
+}
+function resolveFreePricing(currency) {
+	return {
+		currency,
+		display: {
+			kind: "free",
+			currency
+		},
+		selectableOptions: [],
+		requiresSelection: false,
+		selectedOption: null,
+		slidingScale: null,
+		selectedSlidingAmount: null,
+		selectedPriceAmount: 0,
+		selectedRequiresPayment: false,
+		hasPaidSelection: false,
+		hasFreeSelection: true
+	};
+}
+function resolveSinglePricing(amount, currency) {
+	return {
+		currency,
+		display: toExactOrFreeDisplay(amount, currency),
+		selectableOptions: [],
+		requiresSelection: false,
+		selectedOption: null,
+		slidingScale: null,
+		selectedSlidingAmount: null,
+		selectedPriceAmount: amount,
+		selectedRequiresPayment: amount > 0,
+		hasPaidSelection: amount > 0,
+		hasFreeSelection: amount <= 0
+	};
+}
+function resolveTieredPricing(offering, selectedPricingOptionId, nowInput) {
+	const currency = offering.pricing.currency;
+	const selectableOptions = getSelectableWholeSeriesPricingOptionsForNow(offering, resolvePlanningDateInput(nowInput));
+	const selectedOption = resolveSelectedTier(selectableOptions, selectedPricingOptionId);
+	return {
+		currency,
+		display: resolveTieredDisplay(selectableOptions.reduce((lowest, option) => lowest === null || option.priceAmount < lowest ? option.priceAmount : lowest, null), selectableOptions.length, currency),
+		selectableOptions,
+		requiresSelection: selectableOptions.length > 1,
+		selectedOption,
+		slidingScale: null,
+		selectedSlidingAmount: null,
+		selectedPriceAmount: selectedOption?.priceAmount ?? null,
+		selectedRequiresPayment: (selectedOption?.priceAmount ?? 0) > 0,
+		hasPaidSelection: selectableOptions.some((option) => option.priceAmount > 0),
+		hasFreeSelection: selectableOptions.some((option) => option.priceAmount === 0)
+	};
+}
+function resolveSelectedTier(options, selectedId) {
+	return (selectedId ? options.find((option) => option.id === selectedId) : null) ?? (options.length === 1 ? options[0] ?? null : null);
+}
+function resolveTieredDisplay(lowestAmount, optionCount, currency) {
+	if (lowestAmount === null) return {
+		kind: "unavailable",
+		currency
+	};
+	return optionCount > 1 && lowestAmount > 0 ? {
+		kind: "from",
+		amount: lowestAmount,
+		currency
+	} : toExactOrFreeDisplay(lowestAmount, currency);
+}
+function resolveSlidingScalePricing(offering, selectedSlidingAmount) {
+	const currency = offering.pricing.currency;
+	const minAmount = offering.pricing.slidingMinAmount ?? null;
+	const maxAmount = offering.pricing.slidingMaxAmount ?? null;
+	if (minAmount === null || maxAmount === null || minAmount < 0 || maxAmount < minAmount) return unavailableSlidingScale(currency);
+	const selectedAmount = Number.isFinite(selectedSlidingAmount) ? selectedSlidingAmount : null;
+	return {
+		currency,
+		display: {
+			kind: "range",
+			minAmount,
+			maxAmount,
+			currency
+		},
+		selectableOptions: [],
+		requiresSelection: selectedAmount === null,
+		selectedOption: null,
+		slidingScale: {
+			minAmount,
+			maxAmount,
+			suggestedAmount: offering.pricing.slidingSuggestedAmount ?? null
+		},
+		selectedSlidingAmount: selectedAmount,
+		selectedPriceAmount: selectedAmount,
+		selectedRequiresPayment: (selectedAmount ?? 0) > 0,
+		hasPaidSelection: maxAmount > 0,
+		hasFreeSelection: minAmount === 0
+	};
+}
+function unavailableSlidingScale(currency) {
+	return {
+		currency,
+		display: {
+			kind: "unavailable",
+			currency
+		},
+		selectableOptions: [],
+		requiresSelection: true,
+		selectedOption: null,
+		slidingScale: null,
+		selectedSlidingAmount: null,
+		selectedPriceAmount: null,
+		selectedRequiresPayment: false,
+		hasPaidSelection: false,
+		hasFreeSelection: false
+	};
+}
+//#endregion
+//#region ../blocks/src/system/blocks/events/whole-series/schemas.ts
+const wholeSeriesVenueSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	address: z.string().nullable()
 });
-/**
-* Zod schema for course session (occurrence) data
-*/
-const courseSessionSchema = z.object({
+const wholeSeriesSessionSchema = z.object({
 	id: z.string(),
 	startsAt: z.string(),
 	endsAt: z.string(),
@@ -14793,14 +15066,14 @@ const courseSessionSchema = z.object({
 	capacityOverride: z.number().nullable().optional(),
 	overrides: z.record(z.string(), z.unknown()).nullable().optional()
 });
-const courseTeamMemberSummarySchema = z.object({
+const wholeSeriesTeamMemberSummarySchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	roleLabel: z.string().nullable(),
 	summary: z.string().nullable(),
 	profilePath: z.string().nullable()
 });
-const coursePricingOptionSchema = z.object({
+const wholeSeriesPricingOptionSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	description: z.string().nullable(),
@@ -14816,7 +15089,7 @@ const coursePricingOptionSchema = z.object({
 		"both"
 	]).nullable().optional()
 });
-const coursePricingSchema = z.object({
+const wholeSeriesPricingSchema = z.object({
 	bookingRequirement: z.enum(["none", "required"]),
 	pricingStrategy: z.enum([
 		"free",
@@ -14830,20 +15103,17 @@ const coursePricingSchema = z.object({
 	slidingMaxAmount: z.number().nullable().optional(),
 	slidingSuggestedAmount: z.number().nullable().optional(),
 	paymentTerms: blockBookingPaymentTermsSchema,
-	options: z.array(coursePricingOptionSchema)
+	options: z.array(wholeSeriesPricingOptionSchema)
 });
-/**
-* Zod schema for public course data
-*/
 const publicWholeSeriesOfferingSchema = z.object({
 	eventSeriesId: z.string(),
 	eventOfferingId: z.string(),
 	title: z.string(),
 	slug: z.string(),
 	description: z.unknown().nullable(),
-	teamMembers: z.array(courseTeamMemberSummarySchema).optional(),
+	teamMembers: z.array(wholeSeriesTeamMemberSummarySchema).optional(),
 	enrollmentOpen: z.boolean(),
-	pricing: coursePricingSchema,
+	pricing: wholeSeriesPricingSchema,
 	currency: z.string(),
 	paymentTerms: blockBookingPaymentTermsSchema,
 	enrollmentCapacity: z.number().nullable(),
@@ -14856,8 +15126,8 @@ const publicWholeSeriesOfferingSchema = z.object({
 	sessionsCount: z.number(),
 	enrolledCount: z.number(),
 	availableSpots: z.number().nullable(),
-	sessions: z.array(courseSessionSchema),
-	venue: courseVenueSchema.nullable()
+	sessions: z.array(wholeSeriesSessionSchema),
+	venue: wholeSeriesVenueSchema.nullable()
 });
 z.array(publicWholeSeriesOfferingSchema);
 //#endregion
@@ -15170,7 +15440,7 @@ const publicEventSchema = z.object({
 	acceptsMemberships: z.boolean().optional(),
 	wholeSeries: z.object({
 		eventSeriesId: z.string(),
-		pricing: coursePricingSchema,
+		pricing: wholeSeriesPricingSchema,
 		currency: z.string(),
 		enrollmentOpen: z.boolean()
 	}).nullable().optional()
@@ -15700,7 +15970,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	const [registrationResult, setRegistrationResult] = useState(null);
 	const [errorMessage, setErrorMessage] = useState("");
 	const [altchaSolution, setAltchaSolution] = useState(null);
-	const { authState: portalAuthState, profile: portalProfile } = deps.usePortalAuth();
+	const { authState: portalAuthState, profile: portalProfile, creditState: portalCreditState } = deps.usePortalAuth();
 	const waitlistClaim = deps.useWaitlistClaim();
 	const [showMagicLinkModal, setShowMagicLinkModal] = useState(false);
 	const [pendingAttendeeId, setPendingAttendeeId] = useState(null);
@@ -16253,6 +16523,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		setAltchaSolution,
 		portalAuthState,
 		portalProfile,
+		portalCreditState,
 		showMagicLinkModal,
 		setShowMagicLinkModal,
 		handleLogout,
@@ -16307,7 +16578,7 @@ function buildEventRegistrationPaymentOptionsViewModel(input) {
 	return {
 		mode: selection.mode,
 		sectionTitle: selection.sectionTitle,
-		options: selection.options.map((option) => toEventDirectPaymentOption(option, selection.mode))
+		options: selection.options.map((option, index) => toEventDirectPaymentOption(option, supportedOptions[index] ?? DEFAULT_EVENT_DIRECT_PAYMENT_OPTION, selection.mode, input.totalPriceCents))
 	};
 }
 function selectSupportedEventDirectPaymentOptions(paymentTerms) {
@@ -16317,17 +16588,24 @@ function selectSupportedEventDirectPaymentOptions(paymentTerms) {
 function isSupportedEventDirectPaymentOption(option) {
 	return option.kind === "upfront" || option.kind === "flexible_balance";
 }
-function toEventDirectPaymentOption(option, mode) {
+function toEventDirectPaymentOption(option, sourceOption, mode, totalCents) {
 	switch (option.kind) {
 		case "upfront": return {
 			...option,
 			kind: "upfront",
-			label: mode === "choice_required" ? "Pay in full now" : "Pay by card"
+			label: mode === "choice_required" ? "Pay in full now" : "Pay by card",
+			totalCents,
+			configuredPaymentDueNowCents: totalCents
 		};
 		case "flexible_balance": return {
 			...option,
 			kind: "flexible_balance",
-			label: "Pay deposit now"
+			label: "Pay deposit now",
+			totalCents,
+			configuredPaymentDueNowCents: sourceOption.kind === "flexible_balance" ? resolveFlexibleBalanceInitialPaymentCents({
+				totalAmountCents: totalCents,
+				config: sourceOption.config
+			}) : totalCents
 		};
 		case "deferred_manual":
 		case "instalment_plan": throw new Error(`Unsupported event registration payment option: ${option.kind}`);
@@ -16660,13 +16938,13 @@ function resolveHeadlessDirectPaymentOptions(wizard) {
 	}).options;
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/utils.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/utils.ts
 /**
 * Anchor ID for the registration block, used for scroll targeting.
 */
-const COURSE_REGISTRATION_ANCHOR_ID = "course-registration";
+const WHOLE_SERIES_REGISTRATION_ANCHOR_ID = "event-registration";
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/pricing.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/pricing.ts
 function parseCurrencyInputToCents(value) {
 	const trimmed = value.trim();
 	if (!trimmed) return null;
@@ -16678,31 +16956,31 @@ function formatCentsAsCurrencyInput(amount) {
 	const major = amount / 100;
 	return Number.isInteger(major) ? String(major) : major.toFixed(2);
 }
-function getMissingCoursePricingSelectionMessage(pricing) {
+function getMissingWholeSeriesPricingSelectionMessage(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) {
+function buildWholeSeriesPricingOptionPayload(pricing) {
 	if (pricing?.selectedOption) return { pricingOptionId: pricing.selectedOption.id };
 	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null) return { selectedSlidingAmount: pricing.selectedSlidingAmount };
 	return {};
 }
-function defaultCoursePricingSelection(pricing, previousOptionId) {
+function defaultWholeSeriesPricingSelection(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
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wizardSteps.ts
 /**
 * Step labels for the wizard indicator
 */
 const STEP_LABELS = {
-	"select-course": "Course",
+	"select-run": "Run",
 	"enter-details": "Details",
 	"booking-mode": "Method",
 	"select-payment": "Payment",
@@ -16718,36 +16996,36 @@ const STEP_LABELS = {
 /**
 * Determine which wizard steps to show based on context and eligibility.
 *
-* @param hasPreSelectedCourse - Whether course is pre-selected (skips course selection)
-* @param requiresPayment - Whether the course requires payment
+* @param hasPreSelectedRun - Whether run is pre-selected (skips run selection)
+* @param requiresPayment - Whether the run requires payment
 * @param hasEligibleMemberships - Whether user has eligible memberships
 * @param bookingMode - Current booking mode selection
 * @param isMembershipFastTrack - Whether user qualifies for single-step membership flow
 * @returns Array of wizard steps to display
 */
-function getWizardStepsForContext(hasPreSelectedCourse, requiresPayment, hasEligibleMemberships, bookingMode, isMembershipFastTrack) {
-	if (isMembershipFastTrack) return hasPreSelectedCourse ? ["enter-details"] : ["select-course", "enter-details"];
-	if (!requiresPayment) return hasPreSelectedCourse ? ["enter-details"] : ["select-course", "enter-details"];
+function getWizardStepsForContext(hasPreSelectedRun, requiresPayment, hasEligibleMemberships, bookingMode, isMembershipFastTrack) {
+	if (isMembershipFastTrack) return hasPreSelectedRun ? ["enter-details"] : ["select-run", "enter-details"];
+	if (!requiresPayment) return hasPreSelectedRun ? ["enter-details"] : ["select-run", "enter-details"];
 	if (hasEligibleMemberships) {
 		const skipPayment = bookingMode === "membership";
-		if (hasPreSelectedCourse) return skipPayment ? ["enter-details", "booking-mode"] : [
+		if (hasPreSelectedRun) return skipPayment ? ["enter-details", "booking-mode"] : [
 			"enter-details",
 			"booking-mode",
 			"select-payment"
 		];
 		return skipPayment ? [
-			"select-course",
+			"select-run",
 			"enter-details",
 			"booking-mode"
 		] : [
-			"select-course",
+			"select-run",
 			"enter-details",
 			"booking-mode",
 			"select-payment"
 		];
 	}
-	return hasPreSelectedCourse ? ["enter-details", "select-payment"] : [
-		"select-course",
+	return hasPreSelectedRun ? ["enter-details", "select-payment"] : [
+		"select-run",
 		"enter-details",
 		"select-payment"
 	];
@@ -16759,21 +17037,21 @@ 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;
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wholeSeriesRegistrationViewState.ts
+function deriveWholeSeriesRegistrationViewState(input) {
+	const hasRunPayment = resolveWholeSeriesPaymentRequirement(input.pricing);
+	const canUseMembership = hasRunPayment && input.selectedRun?.acceptsMemberships === true && input.portalAuthState === "authenticated" && input.eligibleMembershipCount > 0;
+	const hasPreSelectedRun = input.scopedRuns.length === 1;
 	const fastTrack = canUseMembership && input.eligibleMembershipCount === 1 && input.bookingMode === "membership";
-	const wizardSteps = getWizardStepsForContext(hasPreSelectedCourse, hasCoursePayment, canUseMembership, input.bookingMode, fastTrack);
+	const wizardSteps = getWizardStepsForContext(hasPreSelectedRun, hasRunPayment, canUseMembership, input.bookingMode, fastTrack);
 	const showPortalAuthSidebar = shouldShowPortalAuthSidebar({
 		...input,
-		hasCoursePayment
+		hasRunPayment
 	});
 	return {
-		hasCoursePayment,
+		hasRunPayment,
 		canUseMembership,
-		hasPreSelectedCourse,
+		hasPreSelectedRun,
 		wizardSteps,
 		currentStepNumber: getStepNumber(input.step, wizardSteps),
 		totalSteps: wizardSteps.length,
@@ -16781,24 +17059,24 @@ function deriveCourseRegistrationViewState(input) {
 		showPortalAuthSidebar
 	};
 }
-function resolveCoursePaymentRequirement(pricing) {
+function resolveWholeSeriesPaymentRequirement(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";
+	return input.waitlistRequiresPortalLogin || input.hasRunPayment && input.selectedRun?.acceptsMemberships === true && input.step !== "select-run";
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseEligibility.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesEligibility.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;
+	if (!input.run || input.portalAuthState === "checking" || input.hasWaitlistClaimToken) return false;
+	const membershipCheck = input.portalAuthState === "authenticated" && input.hasPaidSelection && input.run.acceptsMemberships;
+	const capacityCheck = input.run.availableSpots !== null && input.run.availableSpots <= 0;
 	return membershipCheck || capacityCheck;
 }
-function useCourseEligibility(input) {
+function useWholeSeriesEligibility(input) {
 	const [loading, setLoading] = useState(false);
 	const [error, setError] = useState(null);
 	const [eligibility, setEligibility] = useState(null);
@@ -16819,15 +17097,15 @@ function useCourseEligibility(input) {
 		setError(null);
 		setPaymentChoice("checkout");
 		const eligibilityInput = {
-			course: input.selectedCourse,
+			run: input.selectedRun,
 			hasPaidSelection: input.hasPaidSelection,
 			portalAuthState: input.portalAuthState,
 			hasWaitlistClaimToken: input.waitlistClaimToken !== null
 		};
 		if (!shouldFetchEligibility(eligibilityInput)) return;
-		const course = eligibilityInput.course;
+		const run = eligibilityInput.run;
 		setLoading(true);
-		input.api.checkWholeSeriesEligibility({ eventSeriesId: course.eventSeriesId }).then((result) => {
+		input.api.checkWholeSeriesEligibility({ eventSeriesId: run.eventSeriesId }).then((result) => {
 			if (cancelled) return;
 			const eligibleMemberships = result.eligibleMemberships ?? [];
 			setEligibility(result);
@@ -16848,13 +17126,13 @@ function useCourseEligibility(input) {
 		input.api,
 		input.hasPaidSelection,
 		input.portalAuthState,
-		input.selectedCourse,
+		input.selectedRun,
 		input.waitlistClaimToken
 	]);
 	return {
 		eligibilityLoading: loading,
 		eligibilityError: error,
-		courseEligibility: eligibility,
+		runEligibility: eligibility,
 		eligibleMemberships: memberships,
 		paymentChoice,
 		choosePaymentChoice,
@@ -16863,149 +17141,12 @@ function useCourseEligibility(input) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/blocks/courses/shared/pricing.ts
-function isSaleWindowOpen(option, now) {
-	if (!option.isActive) return false;
-	if (option.saleStartsAt && new Date(option.saleStartsAt) > now) return false;
-	if (option.saleEndsAt && new Date(option.saleEndsAt) < now) return false;
-	return true;
-}
-function toExactOrFreeDisplay(amount, currency) {
-	if (amount <= 0) return {
-		kind: "free",
-		currency
-	};
-	return {
-		kind: "exact",
-		amount,
-		currency
-	};
-}
-function getSelectableCoursePricingOptionsForNow(course, now) {
-	if (course.pricing.pricingStrategy !== "tiered") return [];
-	return [...course.pricing.options].filter((option) => isSaleWindowOpen(option, now)).sort((left, right) => {
-		if (left.sortOrder !== right.sortOrder) return left.sortOrder - right.sortOrder;
-		if (left.priceAmount !== right.priceAmount) return left.priceAmount - right.priceAmount;
-		return left.name.localeCompare(right.name);
-	});
-}
-function resolveCoursePricingState(course, selectedPricingOptionId, selectedSlidingAmountOrNowInput, nowInput = {}) {
-	const selectedSlidingAmount = typeof selectedSlidingAmountOrNowInput === "number" || selectedSlidingAmountOrNowInput === null ? selectedSlidingAmountOrNowInput : null;
-	const effectiveNowInput = typeof selectedSlidingAmountOrNowInput === "object" && selectedSlidingAmountOrNowInput !== null ? selectedSlidingAmountOrNowInput : nowInput;
-	const currency = course.pricing.currency;
-	switch (course.pricing.pricingStrategy) {
-		case "free": return {
-			currency,
-			display: {
-				kind: "free",
-				currency
-			},
-			selectableOptions: [],
-			requiresSelection: false,
-			selectedOption: null,
-			slidingScale: null,
-			selectedSlidingAmount: null,
-			selectedPriceAmount: 0,
-			selectedRequiresPayment: false,
-			hasPaidSelection: false,
-			hasFreeSelection: true
-		};
-		case "single": {
-			const amount = course.pricing.singlePriceAmount ?? 0;
-			return {
-				currency,
-				display: toExactOrFreeDisplay(amount, currency),
-				selectableOptions: [],
-				requiresSelection: false,
-				selectedOption: null,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: amount,
-				selectedRequiresPayment: amount > 0,
-				hasPaidSelection: amount > 0,
-				hasFreeSelection: amount <= 0
-			};
-		}
-		case "tiered": {
-			const selectableOptions = getSelectableCoursePricingOptionsForNow(course, resolvePlanningDateInput(effectiveNowInput));
-			const selectedOption = (selectedPricingOptionId ? selectableOptions.find((option) => option.id === selectedPricingOptionId) : null) ?? (selectableOptions.length === 1 ? selectableOptions[0] ?? null : null);
-			const lowestAmount = selectableOptions.reduce((lowest, option) => {
-				if (lowest === null || option.priceAmount < lowest) return option.priceAmount;
-				return lowest;
-			}, null);
-			return {
-				currency,
-				display: lowestAmount === null ? {
-					kind: "unavailable",
-					currency
-				} : selectableOptions.length > 1 && lowestAmount > 0 ? {
-					kind: "from",
-					amount: lowestAmount,
-					currency
-				} : toExactOrFreeDisplay(lowestAmount, currency),
-				selectableOptions,
-				requiresSelection: selectableOptions.length > 1,
-				selectedOption,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: selectedOption?.priceAmount ?? null,
-				selectedRequiresPayment: (selectedOption?.priceAmount ?? 0) > 0,
-				hasPaidSelection: selectableOptions.some((option) => option.priceAmount > 0),
-				hasFreeSelection: selectableOptions.some((option) => option.priceAmount === 0)
-			};
-		}
-		case "sliding_scale": {
-			const minAmount = course.pricing.slidingMinAmount ?? null;
-			const maxAmount = course.pricing.slidingMaxAmount ?? null;
-			if (minAmount === null || maxAmount === null || minAmount < 0 || maxAmount < minAmount) return {
-				currency,
-				display: {
-					kind: "unavailable",
-					currency
-				},
-				selectableOptions: [],
-				requiresSelection: true,
-				selectedOption: null,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: null,
-				selectedRequiresPayment: false,
-				hasPaidSelection: false,
-				hasFreeSelection: false
-			};
-			const normalizedSelectedAmount = typeof selectedSlidingAmount === "number" && Number.isFinite(selectedSlidingAmount) ? selectedSlidingAmount : null;
-			return {
-				currency,
-				display: {
-					kind: "range",
-					minAmount,
-					maxAmount,
-					currency
-				},
-				selectableOptions: [],
-				requiresSelection: normalizedSelectedAmount === null,
-				selectedOption: null,
-				slidingScale: {
-					minAmount,
-					maxAmount,
-					suggestedAmount: course.pricing.slidingSuggestedAmount ?? null
-				},
-				selectedSlidingAmount: normalizedSelectedAmount,
-				selectedPriceAmount: normalizedSelectedAmount,
-				selectedRequiresPayment: (normalizedSelectedAmount ?? 0) > 0,
-				hasPaidSelection: maxAmount > 0,
-				hasFreeSelection: minAmount === 0
-			};
-		}
-	}
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/course-page-surface-scope.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wholeSeriesPageSurfaceScope.ts
 /**
-* Resolves native course-page ownership without falling back to entry or slug
+* Resolves native run-page ownership without falling back to entry or slug
 * coincidence when a page-surface subject is present but invalid.
 */
-function resolveCoursePageSurfaceScope(courses, subjectValue) {
+function resolveWholeSeriesPageSurfaceScope(runs, subjectValue) {
 	if (subjectValue === null || subjectValue === void 0) return { kind: "absent" };
 	const parsed = parseEventPageSurfaceSubject(subjectValue);
 	if (!parsed.ok) return {
@@ -17017,7 +17158,7 @@ function resolveCoursePageSurfaceScope(courses, subjectValue) {
 	return {
 		kind: "scoped",
 		subject: parsed.value,
-		courses: courses.filter((course) => allowedSeriesIds.has(course.eventSeriesId))
+		runs: runs.filter((run) => allowedSeriesIds.has(run.eventSeriesId))
 	};
 }
 function eventSeriesIdsForSubject(subject) {
@@ -17028,33 +17169,43 @@ function eventSeriesIdsForSubject(subject) {
 	}
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationSelection.ts
-function selectScopedCourses(props) {
-	const surfaceScope = resolveCoursePageSurfaceScope(props.courses ?? [], props.subject);
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationSelection.ts
+function selectScopedRuns(props) {
+	const surfaceScope = resolveWholeSeriesPageSurfaceScope(props.runs ?? [], props.subject);
 	if (surfaceScope.kind === "unsupported") return [];
-	if (surfaceScope.kind === "scoped") return surfaceScope.courses;
+	if (surfaceScope.kind === "scoped") return surfaceScope.runs;
 	return [];
 }
-function getCourseCheckoutSessionId() {
-	const fromSearch = new URLSearchParams(window.location.search).get("session_id");
+function getWholeSeriesCheckoutSessionId(location = window.location) {
+	const fromSearch = new URLSearchParams(location.search).get("session_id");
 	if (fromSearch) return fromSearch;
-	return window.location.hash.match(/[?&]session_id=([^&]+)/)?.[1] ?? null;
+	return location.hash.match(/[?&]session_id=([^&]+)/)?.[1] ?? 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 initialStep(runs, location) {
+	if (new URLSearchParams(location.search).get("enrollment") === "success" && getWholeSeriesCheckoutSessionId(location)) return "verifying-payment";
+	return runs.length === 1 ? "enter-details" : "select-run";
 }
-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);
+function useWholeSeriesRegistrationSelection(props, location = window.location) {
+	const scopeSnapshot = JSON.stringify({
+		runs: props.runs ?? [],
+		subject: props.subject ?? null
+	});
+	const stableScope = useRef(null);
+	if (stableScope.current?.snapshot !== scopeSnapshot) stableScope.current = {
+		snapshot: scopeSnapshot,
+		runs: selectScopedRuns(props)
+	};
+	const scopedRuns = stableScope.current.runs;
+	const [step, setStep] = useState(() => initialStep(scopedRuns, location));
+	const [selectedRunId, setSelectedRunId] = useState(scopedRuns.length === 1 ? scopedRuns[0]?.eventSeriesId ?? null : null);
+	const selectedRun = useMemo(() => scopedRuns.find((run) => run.eventSeriesId === selectedRunId) ?? (scopedRuns.length === 1 ? scopedRuns[0] ?? null : null), [scopedRuns, selectedRunId]);
 	const [selectedPricingOptionId, setSelectedPricingOptionId] = useState(null);
 	const [selectedSlidingAmountInput, setSelectedSlidingAmountInput] = useState("");
 	const goToStep = useCallback((nextStep) => {
 		setStep(nextStep);
 	}, []);
-	const chooseCourse = useCallback((course) => {
-		setSelectedCourse(course);
+	const chooseRun = useCallback((run) => {
+		setSelectedRunId(run.eventSeriesId);
 	}, []);
 	const choosePricingOption = useCallback((pricingOptionId) => {
 		setSelectedPricingOptionId(pricingOptionId);
@@ -17062,36 +17213,36 @@ function useCourseRegistrationSelection(props) {
 	const changeSlidingAmount = useCallback((amount) => {
 		setSelectedSlidingAmountInput(amount);
 	}, []);
-	const selectedCoursePricing = useMemo(() => selectedCourse ? resolveCoursePricingState(selectedCourse, selectedPricingOptionId, parseCurrencyInputToCents(selectedSlidingAmountInput)) : null, [
-		selectedCourse,
+	const selectedRunPricing = useMemo(() => selectedRun ? resolveWholeSeriesPricingState(selectedRun, selectedPricingOptionId, parseCurrencyInputToCents(selectedSlidingAmountInput)) : null, [
+		selectedRun,
 		selectedPricingOptionId,
 		selectedSlidingAmountInput
 	]);
 	useEffect(() => {
-		if (!selectedCourse) {
+		if (!selectedRun) {
 			setSelectedPricingOptionId(null);
 			setSelectedSlidingAmountInput("");
 			return;
 		}
-		const selection = defaultCoursePricingSelection(resolveCoursePricingState(selectedCourse, null), selectedPricingOptionId);
+		const selection = defaultWholeSeriesPricingSelection(resolveWholeSeriesPricingState(selectedRun, null), selectedPricingOptionId);
 		setSelectedPricingOptionId(selection.pricingOptionId);
 		setSelectedSlidingAmountInput(selection.slidingAmountInput);
-	}, [selectedCourse]);
+	}, [selectedRun?.eventSeriesId]);
 	return {
-		scopedCourses,
+		scopedRuns,
 		step,
 		goToStep,
-		selectedCourse,
-		chooseCourse,
+		selectedRun,
+		chooseRun,
 		selectedPricingOptionId,
 		choosePricingOption,
 		selectedSlidingAmountInput,
 		changeSlidingAmount,
-		selectedCoursePricing
+		selectedRunPricing
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCoursePaymentVerification.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesPaymentVerification.ts
 function applyTerminalStatus(status, setters) {
 	if (status === "enrolled" || status === "completed") {
 		setters.setEnrollmentResult({
@@ -17113,7 +17264,7 @@ function applyTerminalStatus(status, setters) {
 	setters.setStep("error");
 	return true;
 }
-async function pollCourseRegistrationStatus(api, sessionId, setters, isCancelled) {
+async function pollWholeSeriesRegistrationStatus(api, sessionId, setters, isCancelled) {
 	const startedAt = Date.now();
 	while (!isCancelled()) {
 		try {
@@ -17134,21 +17285,21 @@ async function pollCourseRegistrationStatus(api, sessionId, setters, isCancelled
 		await new Promise((resolve) => setTimeout(resolve, 1500));
 	}
 }
-function useCoursePaymentVerification(api, setters) {
+function useWholeSeriesPaymentVerification(api, setters, anchorId = WHOLE_SERIES_REGISTRATION_ANCHOR_ID, location = window.location) {
 	useEffect(() => {
 		let cancelled = false;
-		const enrollment = new URLSearchParams(window.location.search).get("enrollment");
-		const sessionId = getCourseCheckoutSessionId();
+		const enrollment = new URLSearchParams(location.search).get("enrollment");
+		const sessionId = getWholeSeriesCheckoutSessionId(location);
 		if (enrollment === "cancelled") {
-			scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
+			scrollToBlock(anchorId);
 			setters.setErrorMessage("Payment was cancelled. You can try again.");
 			setters.setStep("error");
 			return;
 		}
 		if (enrollment !== "success" || !sessionId) return;
-		scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
+		scrollToBlock(anchorId);
 		setters.setStep("verifying-payment");
-		pollCourseRegistrationStatus(api, sessionId, setters, () => cancelled);
+		pollWholeSeriesRegistrationStatus(api, sessionId, setters, () => cancelled);
 		return () => {
 			cancelled = true;
 		};
@@ -17156,11 +17307,13 @@ function useCoursePaymentVerification(api, setters) {
 		api,
 		setters.setEnrollmentResult,
 		setters.setErrorMessage,
-		setters.setStep
+		setters.setStep,
+		anchorId,
+		location
 	]);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationActions.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationActions.ts
 function blocked(message, setters) {
 	setters.setErrorMessage(message);
 	setters.setStep("error");
@@ -17170,16 +17323,16 @@ function blocked(message, setters) {
 	};
 }
 function validateSubmission(state, setters) {
-	if (!state.selectedCourse) return {
+	if (!state.selectedRun) return {
 		kind: "blocked",
 		message: "Choose an available set of dates to continue."
 	};
 	const errors = validateFormData$1(state.formData);
 	setters.setErrors(errors);
 	if (Object.keys(errors).length > 0) return { kind: "validation-failed" };
-	const pricingMessage = getMissingCoursePricingSelectionMessage(state.pricing);
+	const pricingMessage = getMissingWholeSeriesPricingSelectionMessage(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 (!state.hasClaim && state.eligibility?.isFull && !state.eligibility.canJoinWaitlist) return blocked(state.eligibility.reason ?? "This run is fully booked.", setters);
 	if (isSpamProtectionEnabled() && !state.altchaSolution) return blocked("Please complete the verification check.", setters);
 	return null;
 }
@@ -17192,8 +17345,8 @@ function enrollmentPayload(state, payment) {
 }
 function registrantPayload(state) {
 	return {
-		eventSeriesId: state.selectedCourse.eventSeriesId,
-		...buildCoursePricingOptionPayload(state.pricing),
+		eventSeriesId: state.selectedRun.eventSeriesId,
+		...buildWholeSeriesPricingOptionPayload(state.pricing),
 		email: state.formData.email.trim().toLowerCase(),
 		name: state.formData.name.trim(),
 		phone: state.formData.phone.trim() || void 0,
@@ -17226,7 +17379,7 @@ async function enroll(state, setters, payment) {
 async function checkout(state, setters) {
 	setters.setStep("submitting");
 	try {
-		const urls = buildCheckoutReturnUrls("enrollment", COURSE_REGISTRATION_ANCHOR_ID);
+		const urls = buildCheckoutReturnUrls("enrollment", state.options.anchorId ?? "event-registration");
 		const result = await state.api.createWholeSeriesCheckout({
 			...registrantPayload(state),
 			discountCode: state.discountCode.trim() || void 0,
@@ -17261,10 +17414,10 @@ async function checkout(state, setters) {
 }
 async function submitDetails(state, setters) {
 	const invalid = validateSubmission(state, setters);
-	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (invalid || !state.selectedRun) 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;
+	const canUseMembership = requiresPayment && state.selectedRun.acceptsMemberships && state.portalAuthState === "authenticated" && state.eligibleMemberships.length > 0;
 	if (requiresPayment && canUseMembership) {
 		setters.setStep("select-payment");
 		return { kind: "state-updated" };
@@ -17274,7 +17427,7 @@ async function submitDetails(state, setters) {
 }
 async function continuePayment(state, setters) {
 	const invalid = validateSubmission(state, setters);
-	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (invalid || !state.selectedRun) return invalid ?? { kind: "validation-failed" };
 	if (!state.pricing?.selectedRequiresPayment) {
 		setters.setStep("enter-details");
 		return { kind: "state-updated" };
@@ -17289,7 +17442,7 @@ async function continuePayment(state, setters) {
 	}
 	return checkout(selectedState, setters);
 }
-function useCourseRegistrationActions(state, setStep) {
+function useWholeSeriesRegistrationActions(state, setStep) {
 	const [errors, setErrors] = useState({});
 	const [enrollmentResult, setEnrollmentResult] = useState(null);
 	const [errorMessage, setErrorMessage] = useState("");
@@ -17316,14 +17469,14 @@ function useCourseRegistrationActions(state, setStep) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationPortal.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationPortal.ts
 const EMPTY_FORM = {
 	name: "",
 	email: "",
 	phone: "",
 	notes: ""
 };
-function useCourseRegistrationPortal(api) {
+function useWholeSeriesRegistrationPortal(api) {
 	const [formData, setFormData] = useState(EMPTY_FORM);
 	const [portalAuthState, setPortalAuthState] = useState("checking");
 	const updateFormData = useCallback((updater) => {
@@ -17359,19 +17512,19 @@ function useCourseRegistrationPortal(api) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseWaitlistSelection.ts
-function useCourseWaitlistSelection(input) {
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesWaitlistSelection.ts
+function useWholeSeriesWaitlistSelection(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.");
+		const run = input.scopedRuns.find((candidate) => candidate.eventSeriesId === eventSeriesId);
+		if (!run) {
+			input.reportError("This waitlist claim is for a different run.");
 			input.goToStep("error");
 			return;
 		}
-		input.chooseCourse(course);
+		input.chooseRun(run);
 		input.updateFormData((current) => ({
 			...current,
 			email: claim.prefill.email,
@@ -17379,12 +17532,12 @@ function useCourseWaitlistSelection(input) {
 			phone: claim.prefill.phone ?? "",
 			notes: claim.prefill.notes ?? ""
 		}));
-		if (input.step === "select-course") input.goToStep("enter-details");
+		if (input.step === "select-run") input.goToStep("enter-details");
 	}, [
-		input.chooseCourse,
+		input.chooseRun,
 		input.goToStep,
 		input.reportError,
-		input.scopedCourses,
+		input.scopedRuns,
 		input.step,
 		input.updateFormData,
 		input.waitlistClaim.claim
@@ -17401,40 +17554,48 @@ function useCourseWaitlistSelection(input) {
 	]);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.ts
-function useCourseRegistrationWizard(props, options = {}) {
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationWizard.ts
+function useWholeSeriesRegistrationWizard(props, options = {}) {
+	return useWholeSeriesRegistrationWizardWithDeps(wholeSeriesRegistrationWizardDeps, props, options);
+}
+const wholeSeriesRegistrationWizardDeps = { readLocation: () => ({
+	search: window.location.search,
+	hash: window.location.hash
+}) };
+function useWholeSeriesRegistrationWizardWithDeps(deps, props, options = {}) {
 	const api = useBlockApi();
-	const selection = useCourseRegistrationSelection(props);
-	const portal = useCourseRegistrationPortal(api);
-	const waitlistClaim = useWaitlistClaim();
+	const [location] = useState(deps.readLocation);
+	const selection = useWholeSeriesRegistrationSelection(props, location);
+	const portal = useWholeSeriesRegistrationPortal(api);
+	const waitlistClaim = useWaitlistClaimForToken(new URLSearchParams(location.search).get("waitlist_claim")?.trim() || null);
 	const [bookingMode, setBookingMode] = useState(null);
 	const [altchaSolution, setAltchaSolution] = useState(null);
-	const eligibility = useCourseEligibility({
+	const eligibility = useWholeSeriesEligibility({
 		api,
-		selectedCourse: selection.selectedCourse,
-		hasPaidSelection: selection.selectedCoursePricing?.hasPaidSelection ?? false,
+		selectedRun: selection.selectedRun,
+		hasPaidSelection: selection.selectedRunPricing?.hasPaidSelection ?? false,
 		portalAuthState: portal.portalAuthState,
 		waitlistClaimToken: waitlistClaim.token
 	});
 	const discountUi = useDiscountCodeUi({
 		api,
-		discountContext: useMemo(() => selection.selectedCourse && selection.selectedCoursePricing?.selectedRequiresPayment && eligibility.paymentChoice === "checkout" ? {
+		discountContext: useMemo(() => selection.selectedRun && selection.selectedRunPricing?.selectedRequiresPayment && eligibility.paymentChoice === "checkout" ? {
 			type: "whole_series",
-			eventSeriesId: selection.selectedCourse.eventSeriesId
+			eventSeriesId: selection.selectedRun.eventSeriesId
 		} : null, [
 			eligibility.paymentChoice,
-			selection.selectedCourse,
-			selection.selectedCoursePricing?.selectedRequiresPayment
+			selection.selectedRun,
+			selection.selectedRunPricing?.selectedRequiresPayment
 		]),
-		subtotalCents: selection.selectedCoursePricing?.selectedPriceAmount ?? void 0
+		subtotalCents: selection.selectedRunPricing?.selectedPriceAmount ?? void 0
 	});
-	const actions = useCourseRegistrationActions({
+	const actions = useWholeSeriesRegistrationActions({
 		api,
-		selectedCourse: selection.selectedCourse,
-		pricing: selection.selectedCoursePricing,
+		selectedRun: selection.selectedRun,
+		pricing: selection.selectedRunPricing,
 		formData: portal.formData,
 		portalAuthState: portal.portalAuthState,
-		eligibility: eligibility.courseEligibility,
+		eligibility: eligibility.runEligibility,
 		eligibleMemberships: eligibility.eligibleMemberships,
 		paymentChoice: eligibility.paymentChoice,
 		selectedMembershipId: eligibility.selectedMembershipId,
@@ -17444,14 +17605,16 @@ function useCourseRegistrationWizard(props, options = {}) {
 		discountCode: discountUi.discountCode,
 		options
 	}, selection.goToStep);
-	useCourseRegistrationEffects({
+	useWholeSeriesRegistrationEffects({
 		api,
 		actions,
 		portal,
 		selection,
-		waitlistClaim
+		waitlistClaim,
+		anchorId: options.anchorId ?? "event-registration",
+		location
 	});
-	return buildCourseRegistrationWizardResult({
+	return buildWholeSeriesRegistrationWizardResult({
 		api,
 		selection,
 		portal,
@@ -17459,10 +17622,10 @@ function useCourseRegistrationWizard(props, options = {}) {
 		actions,
 		discountUi,
 		waitlistClaim,
-		view: deriveCourseRegistrationViewState({
-			scopedCourses: selection.scopedCourses,
-			selectedCourse: selection.selectedCourse,
-			pricing: selection.selectedCoursePricing,
+		view: deriveWholeSeriesRegistrationViewState({
+			scopedRuns: selection.scopedRuns,
+			selectedRun: selection.selectedRun,
+			pricing: selection.selectedRunPricing,
 			portalAuthState: portal.portalAuthState,
 			eligibleMembershipCount: eligibility.eligibleMemberships.length,
 			bookingMode,
@@ -17472,26 +17635,27 @@ function useCourseRegistrationWizard(props, options = {}) {
 		bookingMode,
 		setBookingMode,
 		altchaSolution,
-		setAltchaSolution
+		setAltchaSolution,
+		anchorId: options.anchorId ?? "event-registration"
 	});
 }
-function useCourseRegistrationEffects(input) {
-	useCoursePaymentVerification(input.api, {
+function useWholeSeriesRegistrationEffects(input) {
+	useWholeSeriesPaymentVerification(input.api, {
 		setStep: input.selection.goToStep,
 		setErrorMessage: input.actions.reportError,
 		setEnrollmentResult: input.actions.recordEnrollmentResult
-	});
-	useCourseWaitlistSelection({
+	}, input.anchorId, input.location);
+	useWholeSeriesWaitlistSelection({
 		waitlistClaim: input.waitlistClaim,
-		scopedCourses: input.selection.scopedCourses,
+		scopedRuns: input.selection.scopedRuns,
 		step: input.selection.step,
 		goToStep: input.selection.goToStep,
-		chooseCourse: input.selection.chooseCourse,
+		chooseRun: input.selection.chooseRun,
 		updateFormData: input.portal.updateFormData,
 		reportError: input.actions.reportError
 	});
 }
-function buildCourseRegistrationWizardResult(parts) {
+function buildWholeSeriesRegistrationWizardResult(parts) {
 	const handleBookingModeChange = (mode) => {
 		parts.setBookingMode(mode);
 		parts.eligibility.choosePaymentChoice(mode === "membership" ? "membership" : "checkout");
@@ -17515,30 +17679,30 @@ function buildCourseRegistrationWizardResult(parts) {
 		manualCodeEntryAllowed: parts.discountUi.manualCodeEntryAllowed,
 		discountsAvailableLoading: parts.discountUi.discountsAvailableLoading,
 		...parts.view,
-		handleCourseSelect: (course) => {
-			parts.selection.chooseCourse(course);
+		handleRunSelect: (run) => {
+			parts.selection.chooseRun(run);
 			parts.selection.goToStep("enter-details");
 		},
 		handleRetry: () => {
-			parts.selection.goToStep(parts.selection.scopedCourses.length === 1 ? "enter-details" : "select-course");
+			parts.selection.goToStep(parts.selection.scopedRuns.length === 1 ? "enter-details" : "select-run");
 			parts.actions.reportError("");
 		},
 		handleBookingModeChange,
-		handleLogout: parts.portal.portalAuthState === "authenticated" ? () => logoutPortal(COURSE_REGISTRATION_ANCHOR_ID) : void 0,
-		selectedCoursePricingPayload: buildCoursePricingOptionPayload(parts.selection.selectedCoursePricing)
+		handleLogout: parts.portal.portalAuthState === "authenticated" ? () => logoutPortal(parts.anchorId) : void 0,
+		selectedRunPricingPayload: buildWholeSeriesPricingOptionPayload(parts.selection.selectedRunPricing)
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/whole-series-registration.headless.planning.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/whole-series-registration.headless.planning.ts
 const STEP_IDS = {
-	"select-course": "select-run",
+	"select-run": "select-run",
 	"enter-details": "enter-details",
 	"booking-mode": "select-booking-method",
 	"select-payment": "select-payment"
 };
 function toPublicStepId(step) {
 	switch (step) {
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment": return STEP_IDS[step];
@@ -17598,7 +17762,7 @@ function resolveWholeSeriesRegistrationStatus(wizard) {
 			tag: "error",
 			message: wizard.errorMessage
 		};
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment": return { tag: "ready" };
@@ -17632,7 +17796,7 @@ function resolveWholeSeriesRegistrationView(wizard) {
 			kind: "error",
 			message: "Waitlist registration completed without a result."
 		};
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment":
@@ -17669,7 +17833,7 @@ function resolveWholeSeriesPaymentSelection(input) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useHeadlessWholeSeriesRegistrationFlow.ts
-const wholeSeriesRegistrationControllerDeps = { useCourseRegistrationWizard };
+const wholeSeriesRegistrationControllerDeps = { useWholeSeriesRegistrationWizard };
 function createWholeSeriesRegistrationBlockApiConfig(input) {
 	return {
 		baseUrl: input.apiBaseUrl,
@@ -17695,8 +17859,8 @@ function useHeadlessWholeSeriesRegistrationFlow(options) {
 	return useWholeSeriesRegistrationControllerWithDeps(options, wholeSeriesRegistrationControllerDeps);
 }
 function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
-	const wizard = deps.useCourseRegistrationWizard({
-		courses: (options.runs ?? []).map(toPublicCourse),
+	const wizard = deps.useWholeSeriesRegistrationWizard({
+		runs: (options.runs ?? []).map(toPublicWholeSeriesOffering),
 		subject: options.subject ?? null
 	}, { onCheckoutRedirect: () => {} });
 	const steps = useMemo(() => deriveWholeSeriesRegistrationSteps({
@@ -17704,11 +17868,11 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		step: wizard.step
 	}), [wizard.step, wizard.wizardSteps]);
 	const currentStep = steps.find((step) => step.state === "active") ?? null;
-	const pricingSelection = resolveWholeSeriesPricingSelection(wizard.selectedCoursePricing);
+	const pricingSelection = resolveWholeSeriesPricingSelection(wizard.selectedRunPricing);
 	const paymentSelection = resolveWholeSeriesPaymentSelection({
 		paymentChoice: wizard.paymentChoice,
 		selectedMembershipId: wizard.selectedMembershipId,
-		required: wizard.selectedCoursePricing?.selectedRequiresPayment ?? false
+		required: wizard.selectedRunPricing?.selectedRequiresPayment ?? false
 	});
 	const updateRegistrant = useCallback((values) => wizard.updateFormData(values), [wizard]);
 	const setSlidingAmountCents = useCallback((amount) => {
@@ -17734,8 +17898,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		const blocked = resolveActionBlocker(wizard);
 		if (blocked) return blocked;
 		switch (wizard.step) {
-			case "select-course":
-				if (!wizard.selectedCourse) return {
+			case "select-run":
+				if (!wizard.selectedRun) return {
 					ok: false,
 					reason: "blocked",
 					message: "Choose an available set of dates to continue."
@@ -17765,7 +17929,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 	const back = useCallback(() => {
 		switch (wizard.step) {
 			case "enter-details":
-				if (!wizard.hasPreSelectedCourse) wizard.goToStep("select-course");
+				if (!wizard.hasPreSelectedRun) wizard.goToStep("select-run");
 				return;
 			case "booking-mode":
 				wizard.goToStep("enter-details");
@@ -17773,7 +17937,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			case "select-payment":
 				wizard.goToStep(wizard.canUseMembership ? "booking-mode" : "enter-details");
 				return;
-			case "select-course":
+			case "select-run":
 			case "submitting":
 			case "redirecting":
 			case "verifying-payment":
@@ -17785,7 +17949,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		}
 	}, [wizard]);
 	const payment = {
-		required: wizard.selectedCoursePricing?.selectedRequiresPayment ?? false,
+		required: wizard.selectedRunPricing?.selectedRequiresPayment ?? false,
 		selection: paymentSelection,
 		canUseMembership: wizard.canUseMembership,
 		eligibleMemberships: wizard.eligibleMemberships.map((membership) => ({
@@ -17795,7 +17959,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		eligibility: wizard.eligibilityLoading ? { tag: "loading" } : wizard.eligibilityError ? {
 			tag: "error",
 			message: wizard.eligibilityError
-		} : wizard.courseEligibility || wizard.portalAuthState !== "checking" ? { tag: "loaded" } : { tag: "idle" }
+		} : wizard.runEligibility || wizard.portalAuthState !== "checking" ? { tag: "loaded" } : { tag: "idle" }
 	};
 	const spamProtection = wizard.showSpamProtection ? {
 		enabled: true,
@@ -17806,13 +17970,13 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		},
 		solution: wizard.altchaSolution
 	} : { enabled: false };
-	const selectedRun = wizard.selectedCourse;
-	const isFull = wizard.courseEligibility?.isFull ?? (selectedRun?.availableSpots !== null && selectedRun?.availableSpots !== void 0 ? selectedRun.availableSpots <= 0 : false);
+	const selectedRun = wizard.selectedRun;
+	const isFull = wizard.runEligibility?.isFull ?? (selectedRun?.availableSpots !== null && selectedRun?.availableSpots !== void 0 ? selectedRun.availableSpots <= 0 : false);
 	return {
 		status: resolveWholeSeriesRegistrationStatus(wizard),
 		view: resolveWholeSeriesRegistrationView({
 			step: wizard.step,
-			scopedRunsCount: wizard.scopedCourses.length,
+			scopedRunsCount: wizard.scopedRuns.length,
 			selectedRun,
 			enrollmentResult: wizard.enrollmentResult,
 			errorMessage: wizard.errorMessage
@@ -17820,10 +17984,10 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		steps,
 		currentStep,
 		runs: {
-			items: (options.runs ?? []).map((run) => toWholeSeriesRegistrationRun(toPublicCourse(run))),
-			scoped: wizard.scopedCourses.map(toWholeSeriesRegistrationRun),
+			items: (options.runs ?? []).map((run) => toWholeSeriesRegistrationRun(toPublicWholeSeriesOffering(run))),
+			scoped: wizard.scopedRuns.map(toWholeSeriesRegistrationRun),
 			selected: selectedRun ? toWholeSeriesRegistrationRun(selectedRun) : null,
-			hasPreSelectedRun: wizard.hasPreSelectedCourse,
+			hasPreSelectedRun: wizard.hasPreSelectedRun,
 			subject: options.subject ?? null
 		},
 		registrant: {
@@ -17831,7 +17995,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			errors: wizard.errors
 		},
 		pricing: {
-			...toWholeSeriesRegistrationPricing(wizard.selectedCoursePricing),
+			...toWholeSeriesRegistrationPricing(wizard.selectedRunPricing),
 			selectedOptionId: wizard.selectedPricingOptionId,
 			selection: pricingSelection
 		},
@@ -17847,8 +18011,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			enrollmentOpen: selectedRun?.enrollmentOpen ?? false,
 			availableSpots: selectedRun?.availableSpots ?? null,
 			isFull,
-			canJoinWaitlist: wizard.courseEligibility?.canJoinWaitlist ?? false,
-			message: wizard.courseEligibility?.reason ?? null
+			canJoinWaitlist: wizard.runEligibility?.canJoinWaitlist ?? false,
+			message: wizard.runEligibility?.reason ?? null
 		},
 		portalAuth: {
 			state: wizard.portalAuthState,
@@ -17862,8 +18026,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		},
 		actions: {
 			selectRun: (runId) => {
-				const run = wizard.scopedCourses.find((candidate) => candidate.eventSeriesId === runId) ?? null;
-				if (run) wizard.handleCourseSelect(run);
+				const run = wizard.scopedRuns.find((candidate) => candidate.eventSeriesId === runId) ?? null;
+				if (run) wizard.handleRunSelect(run);
 			},
 			updateRegistrant,
 			selectPricingOption: wizard.choosePricingOption,
@@ -17907,8 +18071,8 @@ function toHeadlessActionResult(result) {
 		};
 	}
 }
-function toPublicCourse(run) {
-	const pricing = toCoursePricing(run.pricing);
+function toPublicWholeSeriesOffering(run) {
+	const pricing = toWholeSeriesPricing(run.pricing);
 	return {
 		eventSeriesId: run.registrationTarget.eventSeriesId,
 		eventOfferingId: run.eventOfferingId,
@@ -17933,7 +18097,7 @@ function toPublicCourse(run) {
 		venue: run.venue
 	};
 }
-function toCoursePricing(pricing) {
+function toWholeSeriesPricing(pricing) {
 	const common = {
 		bookingRequirement: pricing.bookingRequirement,
 		pricingStrategy: pricing.pricingStrategy,
@@ -18060,8 +18224,8 @@ function resolveWaitlistClaim(wizard) {
 	return { tag: "none" };
 }
 function resolveActionBlocker(wizard) {
-	if (!wizard.selectedCourse) return null;
-	if (!wizard.selectedCourse.enrollmentOpen) return {
+	if (!wizard.selectedRun) return null;
+	if (!wizard.selectedRun.enrollmentOpen) return {
 		ok: false,
 		reason: "blocked",
 		message: "Sign-up is closed."
@@ -18071,10 +18235,10 @@ function resolveActionBlocker(wizard) {
 		reason: "blocked",
 		message: "Availability is still being checked."
 	};
-	if (wizard.courseEligibility?.isFull && !wizard.courseEligibility.canJoinWaitlist) return {
+	if (wizard.runEligibility?.isFull && !wizard.runEligibility.canJoinWaitlist) return {
 		ok: false,
 		reason: "blocked",
-		message: wizard.courseEligibility.reason ?? "There are no places available."
+		message: wizard.runEligibility.reason ?? "There are no places available."
 	};
 	return null;
 }