@riverbankcms/sdk 0.130.0 → 0.132.0

package/dist/client/bookings.mjs

@@ -2465,23 +2465,6 @@ function createDeduplicationCache(options = {}) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/api/requestBody.ts
-function omitUndefinedOverrides(overrides) {
-	return Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
-}
-/**
-* Forward a typed request body unchanged, then apply a small set of explicit overrides.
-*
-* Undefined override values are stripped before merging so callers do not accidentally
-* clobber an existing field when they mean "no override".
-*/
-function withRequestOverrides(body, overrides) {
-	return {
-		...body,
-		...omitUndefinedOverrides(overrides)
-	};
-}
-//#endregion
 //#region ../blocks/src/system/runtime/api/endpoints.ts
 /**
 * Build endpoint path with parameter substitution
@@ -2567,7 +2550,8 @@ const EVENTS = {
 	register: {
 		path: "/public/sites/{siteId}/events/register",
 		method: "POST",
-		authScope: "portal"
+		authScope: "portal",
+		skipPreviewStage: true
 	},
 	checkout: {
 		path: "/public/sites/{siteId}/events/checkout",
@@ -2591,7 +2575,8 @@ const WHOLE_SERIES = {
 	enroll: {
 		path: "/public/sites/{siteId}/dated-offerings/whole-series/enroll",
 		method: "POST",
-		authScope: "portal"
+		authScope: "portal",
+		skipPreviewStage: true
 	},
 	checkout: {
 		path: "/public/sites/{siteId}/dated-offerings/whole-series/checkout",
@@ -3169,7 +3154,7 @@ function createBlockApi(config) {
 			const path = buildPath(EVENTS.register.path, { siteId: sid });
 			return request(EVENTS.register, {
 				path,
-				body: withRequestOverrides(data, shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {})
+				body: data
 			});
 		},
 		async createEventCheckout(data) {
@@ -3202,7 +3187,7 @@ function createBlockApi(config) {
 			const path = buildPath(WHOLE_SERIES.enroll.path, { siteId: sid });
 			return request(WHOLE_SERIES.enroll, {
 				path,
-				body: withRequestOverrides(data, shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {})
+				body: data
 			});
 		},
 		async checkWholeSeriesEligibility(data) {
@@ -3833,18 +3818,32 @@ function isFreePublicEventPriceDisplay(display) {
 }
 //#endregion
 //#region ../core/src/event-page-surface-subject.ts
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
+	return bookingScope === "whole_series" ? {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope,
+		isWholeSeriesBooking: true
+	} : {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope
+	};
+}
 function parseEventPageSurfaceSubject(value) {
 	if (!isRecord$6(value)) return err$1({ kind: "notObject" });
 	switch (value.kind) {
 		case "eventSeries": {
 			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
-			return eventSeriesId.ok ? ok({
-				kind: "eventSeries",
-				eventSeriesId: eventSeriesId.value
-			}) : err$1({
+			if (!eventSeriesId.ok) return err$1({
 				kind: "invalidEventSeriesId",
 				error: eventSeriesId.error
 			});
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") return err$1({
+				kind: "invalidEventSeriesBookingScope",
+				bookingScope: value.bookingScope
+			});
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -5711,8 +5710,12 @@ function formatScheduleDate(isoString, locale) {
 	return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(date);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
-const unsafeAsBookingFieldId = (id) => id;
+//#region ../blocks/src/system/runtime/nodes/booking-form.validationErrors.ts
+function omitRecordKey(record, key) {
+	if (!(key in record)) return record;
+	const { [key]: _removed, ...rest } = record;
+	return rest;
+}
 function createEmptyBookingValidationErrors() {
 	return {
 		formError: null,
@@ -5747,6 +5750,9 @@ function clearBookingFieldError(errors, fieldId) {
 		fieldErrors: omitRecordKey(errors.fieldErrors, fieldId)
 	};
 }
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
+const unsafeAsBookingFieldId = (id) => id;
 function createInitialBookingFlowReducerState(input) {
 	const initialData = input.initialData ?? {};
 	return {
@@ -5758,6 +5764,7 @@ function createInitialBookingFlowReducerState(input) {
 		selectedSlot: null,
 		fieldValues: collectInitialFieldValues(initialData),
 		touchedFields: {},
+		attemptedStepIds: {},
 		discountCode: toOptionalString(initialData.discountCode) ?? "",
 		selectedSlidingAmountInput: toOptionalString(initialData.selectedSlidingAmountInput) ?? "",
 		selectedCollectionOptionKind: toSelectedCollectionOptionKind(initialData.selectedCollectionOptionKind),
@@ -5799,6 +5806,25 @@ function toOptionalCustomerPassId(value) {
 function isBookingFieldValue(value) {
 	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+/**
+* Send the flow back to the date step when the slot it was holding went away,
+* leaving a scoped feedback message. A completed booking is left alone.
+*/
+function applyAvailabilitySelectionInvalidation(state, invalidation) {
+	if (state.phase !== "editing") return state;
+	return {
+		...state,
+		currentStepId: "datetime-selection",
+		selectedDate: invalidation.kind === "date_unavailable" ? void 0 : state.selectedDate,
+		selectedSlot: null,
+		feedback: {
+			kind: "error",
+			scope: "availability",
+			message: invalidation.message
+		},
+		validationErrors: clearBookingFormError(state.validationErrors)
+	};
+}
 function bookingFlowReducer(state, event) {
 	switch (event.type) {
 		case "service-selected": return {
@@ -5847,6 +5873,13 @@ function bookingFlowReducer(state, event) {
 				[event.fieldId]: true
 			}
 		};
+		case "step-advance-attempted": return state.attemptedStepIds[event.stepId] ? state : {
+			...state,
+			attemptedStepIds: {
+				...state.attemptedStepIds,
+				[event.stepId]: true
+			}
+		};
 		case "payment-option-selected": return {
 			...state,
 			selectedCollectionOptionKind: event.kind ?? void 0,
@@ -5893,20 +5926,7 @@ function bookingFlowReducer(state, event) {
 			phase: event.feedback.kind === "success" ? "completed" : "editing",
 			feedback: event.feedback
 		};
-		case "availability-selection-invalidated":
-			if (state.phase !== "editing") return state;
-			return {
-				...state,
-				currentStepId: "datetime-selection",
-				selectedDate: event.invalidation.kind === "date_unavailable" ? void 0 : state.selectedDate,
-				selectedSlot: null,
-				feedback: {
-					kind: "error",
-					scope: "availability",
-					message: event.invalidation.message
-				},
-				validationErrors: clearBookingFormError(state.validationErrors)
-			};
+		case "availability-selection-invalidated": return applyAvailabilitySelectionInvalidation(state, event.invalidation);
 		case "feedback-cleared": return {
 			...state,
 			phase: "editing",
@@ -6137,6 +6157,7 @@ function deriveBookingFlowSteps(input) {
 		requiresResourceSelection: input.requiresResourceSelection,
 		paymentResolution: stepResolution.paymentResolution
 	}));
+	const attemptedStepIds = input.attemptedStepIds ?? {};
 	const steps = stepPlan.map((step, index) => {
 		const validation = validations.get(step.id) ?? { ok: true };
 		const state = index < currentStepIndex ? "complete" : index === currentStepIndex ? "active" : "available";
@@ -6146,7 +6167,7 @@ function deriveBookingFlowSteps(input) {
 			state,
 			index,
 			visibleIndex: index,
-			errors: validation.ok ? createEmptyBookingValidationErrors() : validation.errors,
+			errors: validation.ok || !attemptedStepIds[step.id] ? createEmptyBookingValidationErrors() : validation.errors,
 			canEnter: index <= currentStepIndex,
 			canLeave: validation.ok
 		};
@@ -6415,11 +6436,6 @@ function isBlankFieldValue(value) {
 	if (Array.isArray(value)) return value.length === 0;
 	return false;
 }
-function omitRecordKey(record, key) {
-	if (!(key in record)) return record;
-	const { [key]: _removed, ...rest } = record;
-	return rest;
-}
 function readAppointmentBookingOverrideData(value) {
 	if (!isRecord$4(value)) return null;
 	const services = normalizeBookingServices(value.services);
@@ -6518,9 +6534,11 @@ function useHeadlessBookingFlow(options) {
 		currentStepId: state.currentStepId,
 		requiresServiceSelection: options.requiresServiceSelection,
 		requiresResourceSelection: options.requiresResourceSelection,
-		enableAppointmentPackages: options.enableAppointmentPackages
+		enableAppointmentPackages: options.enableAppointmentPackages,
+		attemptedStepIds: state.attemptedStepIds
 	}), [
 		data,
+		state.attemptedStepIds,
 		defaultServiceId,
 		defaultResourceId,
 		options.enableAppointmentPackages,
@@ -6872,6 +6890,10 @@ function useHeadlessBookingFlow(options) {
 			if (!latest.currentStep) return { ok: true };
 			const validation = latest.validations.get(latest.currentStep.id) ?? { ok: true };
 			if (!validation.ok) {
+				dispatch({
+					type: "step-advance-attempted",
+					stepId: latest.currentStep.id
+				});
 				dispatch({
 					type: "validation-errors-set",
 					errors: validation.errors
@@ -7508,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",
@@ -7847,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()
@@ -8125,6 +8154,26 @@ const paletteSchema = z.object({
 //#region ../theme-core/src/cards/types.ts
 const cardVariantRoleValues = ["default", "alternative"];
 const boxlessCardVariantValue = "none";
+const openCardRoleValue = "open";
+/**
+* The roles a site style implements with an actual card variant. `none` is
+* deliberately absent: it is a role value only, never a variant.
+*/
+const surfaceCardRoleValues = [...cardVariantRoleValues, openCardRoleValue];
+/**
+* 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*
+*                   a promise of visible boxlessness: a block whose base class
+*                   draws a border still draws one. It says the Look is not
+*                   asking the site style for a card.
+* - `open`        — boxless but marked (a rule or accent edge, no enclosing box)
+* - `default`     — the site's quiet everyday card
+* - `alternative` — the statement card carrying the site's personality
+*/
+const cardRoleValues = [...surfaceCardRoleValues, boxlessCardVariantValue];
 const cardSpacingSchema = z.enum([
 	"none",
 	"compact",
@@ -8133,6 +8182,17 @@ const cardSpacingSchema = z.enum([
 	"comfortable",
 	"spacious"
 ]);
+/** Per-axis padding, for boxless cards whose inline padding differs from block. */
+const cardSpacingAxesSchema = z.object({
+	block: cardSpacingSchema,
+	inline: cardSpacingSchema
+});
+/**
+* A card's content padding: one value for both axes, or one per axis. Two
+* fields would let a variant say both and leave the reader to guess, so this is
+* a union — the legacy `spacingAxes` key is lifted into it on parse.
+*/
+const cardSpacingValueSchema = z.union([cardSpacingSchema, cardSpacingAxesSchema]);
 const gradientDirectionSchema = z.enum([
 	"to-r",
 	"to-l",
@@ -8144,7 +8204,21 @@ const gradientDirectionSchema = z.enum([
 	"to-bl"
 ]);
 z.enum(cardVariantRoleValues);
-const boxStylesCardVariantSchema = z.enum([...cardVariantRoleValues, boxlessCardVariantValue]);
+const surfaceCardRoleSchema = z.enum(surfaceCardRoleValues);
+const cardRoleSchema = z.enum(cardRoleValues);
+const PRIORITY_ROLE_INFERENCE = {
+	1: "default",
+	2: "alternative"
+};
+/**
+* Role inference for legacy card systems authored before variants carried a
+* `role`. Priority 1 is the everyday card, priority 2 the statement card —
+* which is how variants are surfaced today. `open` is never inferred: a site
+* style has to opt into it.
+*/
+function inferCardVariantRoleFromPriority(priority) {
+	return PRIORITY_ROLE_INFERENCE[priority] ?? null;
+}
 const cardBackgroundSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("solid"),
@@ -8170,17 +8244,19 @@ const cardCornerValueSchema = z.enum([
 	"pill",
 	"expressive"
 ]);
+const cardEdgeSchema = z.enum([
+	"left",
+	"top",
+	"right",
+	"bottom"
+]);
 /**
-* A single accented card edge (e.g. a left accent bar). When set, it replaces
-* the full `border` so the card reads as edge-accented rather than outlined.
+* Legacy single accented card edge (e.g. a left accent bar). Persisted and
+* curated data may still carry it; it lifts into a one-element `decorations`
+* list at the parse boundary and has no representation after that.
 */
 const cardAccentEdgeSchema = z.object({
-	edge: z.enum([
-		"left",
-		"top",
-		"right",
-		"bottom"
-	]),
+	edge: cardEdgeSchema,
 	colorToken: themeColorTokenSchema,
 	width: z.enum([
 		"thin",
@@ -8189,13 +8265,43 @@ const cardAccentEdgeSchema = z.object({
 		"heavy"
 	])
 });
+/** `hairline` (1px) is the widening the boxless `open` role needs. */
+const cardEdgeRuleWidthSchema = z.enum([
+	"hairline",
+	"thin",
+	"medium",
+	"thick",
+	"heavy"
+]);
+const cardEdgeRuleLengthSchema = z.enum(["full", "short"]);
+const cardEdgeRuleAlignSchema = z.enum([
+	"start",
+	"center",
+	"end"
+]);
+/**
+* Decorations are edge rules today. The alias exists so the list can grow into
+* a discriminated union without every call site changing.
+*/
+const cardDecorationSchema = z.object({
+	edge: cardEdgeSchema,
+	colorToken: themeColorTokenSchema,
+	width: cardEdgeRuleWidthSchema,
+	/** Defaults to `full`. */
+	length: cardEdgeRuleLengthSchema.optional(),
+	/** Where a `short` rule sits along its edge. Defaults to `start`. */
+	align: cardEdgeRuleAlignSchema.optional(),
+	/** Opacity applied to `colorToken`, 0–1. Scoped here, not on the token. */
+	alpha: z.number().min(0).max(1).optional()
+});
+const cardDecorationsSchema = z.array(cardDecorationSchema).max(2);
 const cardCornerRadiiSchema = z.object({
 	topLeft: cardCornerValueSchema.optional(),
 	topRight: cardCornerValueSchema.optional(),
 	bottomLeft: cardCornerValueSchema.optional(),
 	bottomRight: cardCornerValueSchema.optional()
 });
-const cardVariantSchema = z.object({
+const cardVariantInputSchema = z.object({
 	id: z.string(),
 	name: z.string().min(1).max(20),
 	enabled: z.boolean(),
@@ -8204,8 +8310,10 @@ const cardVariantSchema = z.object({
 		z.literal(2),
 		z.literal(3)
 	]),
+	role: surfaceCardRoleSchema.optional(),
 	background: cardBackgroundSchema,
-	spacing: cardSpacingSchema,
+	spacing: cardSpacingValueSchema,
+	spacingAxes: cardSpacingAxesSchema.optional(),
 	foregroundToken: themeColorTokenSchema.optional(),
 	shadow: z.object({
 		elevation: z.enum([
@@ -8229,9 +8337,91 @@ const cardVariantSchema = z.object({
 	]).optional(),
 	cornerRadii: cardCornerRadiiSchema.optional(),
 	border: cardBorderSchema.optional(),
+	decorations: cardDecorationsSchema.optional(),
 	accentEdge: cardAccentEdgeSchema.optional()
 });
-const cardSystemSchema = z.object({ variants: z.array(cardVariantSchema).min(1).max(3) });
+/**
+* Lift a legacy `accentEdge` into the decoration list. The old emitter reset
+* `border: 0` implicitly whenever an accent edge was present; conversion drops
+* the border instead, so the output is unchanged and the data says so.
+*/
+function normalizeLegacyAccentEdge(variant) {
+	const { accentEdge, ...rest } = normalizeLegacySpacingAxes(variant);
+	if (!accentEdge) return rest;
+	const { border: _droppedByAccentEdgeReset, ...withoutBorder } = rest;
+	return {
+		...withoutBorder,
+		decorations: [{
+			...accentEdge,
+			length: "full"
+		}]
+	};
+}
+/**
+* Lift a legacy `spacingAxes` into `spacing`. It always won over the flat value
+* when both were set, so the lift preserves the emitted padding exactly.
+*/
+function normalizeLegacySpacingAxes(variant) {
+	const { spacingAxes, ...rest } = variant;
+	return spacingAxes ? {
+		...rest,
+		spacing: spacingAxes
+	} : variant;
+}
+function validateSingleDecorationSource(variant, ctx) {
+	if (!variant.accentEdge || !variant.decorations) return;
+	ctx.addIssue({
+		code: "custom",
+		path: ["decorations"],
+		message: "A card variant carries either the legacy `accentEdge` or `decorations`, never both."
+	});
+}
+const cardVariantSchema = cardVariantInputSchema.superRefine(validateSingleDecorationSource).transform(normalizeLegacyAccentEdge);
+/**
+* Fill in roles for legacy systems whose variants declare none. Inference is
+* collision-tolerant on purpose: first claimant wins and a later variant that
+* would infer a taken role simply gets no role. Legacy data is not obliged to
+* be well-formed, and a card system that fails to parse takes the whole theme
+* down with it.
+*/
+function withInferredRoles(variants) {
+	const claimed = new Set(variants.flatMap((variant) => variant.role ? [variant.role] : []));
+	return variants.map((variant) => {
+		if (variant.role) return variant;
+		const inferred = inferCardVariantRoleFromPriority(variant.priority);
+		if (!inferred || claimed.has(inferred)) return variant;
+		claimed.add(inferred);
+		return {
+			...variant,
+			role: inferred
+		};
+	});
+}
+/**
+* Only *declared* roles are validated — a site style saying "these two
+* variants are both the default card" is an authoring error worth rejecting.
+*/
+function validateUniqueDeclaredCardVariantRoles(system, ctx) {
+	const declared = /* @__PURE__ */ new Set();
+	system.variants.forEach((variant, index) => {
+		const role = variant.role;
+		if (!role) return;
+		if (declared.has(role)) {
+			ctx.addIssue({
+				code: "custom",
+				path: [
+					"variants",
+					index,
+					"role"
+				],
+				message: `Card role "${role}" is already implemented by another variant.`
+			});
+			return;
+		}
+		declared.add(role);
+	});
+}
+const cardSystemSchema = z.object({ variants: z.array(cardVariantSchema).min(1).max(3) }).superRefine(validateUniqueDeclaredCardVariantRoles).transform((system) => ({ variants: withInferredRoles(system.variants) }));
 //#endregion
 //#region ../theme-core/src/accordions/types.ts
 /**
@@ -9052,6 +9242,58 @@ const siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 * palette context and happens in `parseThemeColorReference`.
 */
 const tokenOrCssColorValueSchema = z.string();
+//#endregion
+//#region ../theme-core/src/header/legacyHeaderVariant.ts
+/**
+* The header variants the system actually renders.
+*
+* Each one has a layout row in the site-header block and a paint target in
+* `paintTargets.ts`. This is the canonical list: the block transform's variant
+* class allowlist and the AI theme generator's enum both derive from it, so
+* they cannot drift.
+*/
+const headerVariantValues = [
+	"classic",
+	"centered",
+	"floating"
+];
+z.enum(headerVariantValues);
+/**
+* Header variant spellings that were once authorable but no longer name a
+* layout of their own, and the variant they read as now.
+*
+* `transparent` was an overlay header with no CSS of its own: everything it
+* did (transparent root background, overlay content flow) is what `floating`
+* already does, and it had zero persisted usage in production or locally when
+* it was retired. It survives here as a one-boundary alias so a theme authored
+* against the old vocabulary still parses.
+*
+* This matters because the theme schema is strict and has no per-field
+* `.catch()`: an out-of-enum variant fails `themeSchema.safeParse` for the
+* *whole* theme, which silently swaps the site's theme for
+* `modernMinimalTheme`. Aliasing here keeps that from happening.
+*/
+const legacyHeaderVariants = { transparent: "floating" };
+const legacyHeaderVariantValues = Object.keys(legacyHeaderVariants);
+/**
+* The header variant boundary for themes that go through `themeSchema`:
+* canonical variants pass through, legacy spellings normalize to the variant
+* they meant, everything else fails the parse.
+*
+* Deliberately an enum plus a transform rather than a `z.preprocess`, so the
+* schema's *input* type stays an accurate union (the legacy spelling is still
+* accepted on the wire) instead of widening to `unknown`. `SdkThemeWire` in
+* `@riverbankcms/api` is `z.input<typeof themeSchema>`, so a widened input here
+* would leak straight into a public type.
+*
+* Not every read of a persisted theme goes through the schema:
+* `resolveRuntimeTheme` in
+* `apps/dashboard/src/server/services/sites/runtimeSiteResponse.ts` returns the
+* raw database JSON asserted as `Theme` with no parse, so a theme still
+* carrying a legacy spelling reaches the theme editor un-aliased. That gap
+* predates this alias and is harmless while persisted usage is zero.
+*/
+const headerVariantWithLegacyAliasSchema = z.enum([...headerVariantValues, ...legacyHeaderVariantValues]).transform((value) => value in legacyHeaderVariants ? legacyHeaderVariants[value] : value);
 const BREAKPOINT_LG = 1024;
 const BREAKPOINT_XL = 1280;
 const BREAKPOINT_LG_DOWN = BREAKPOINT_LG - 1;
@@ -9368,15 +9610,7 @@ const cardStylesOverrideSchema = z.object({
 	spacing: semanticSpacingSchema.nullable().optional(),
 	raised: z.boolean().nullable().optional(),
 	rounded: boxRoundedSchema.nullable().optional(),
-	treatment: z.enum([
-		"accent-quote",
-		"editorial-rule",
-		"soft-panel",
-		"editorial-serif-quote",
-		"editorial-open",
-		"color-blocked"
-	]).nullable().optional(),
-	cardVariant: boxStylesCardVariantSchema.nullable().optional()
+	role: cardRoleSchema.nullable().optional()
 });
 const blockStyleOverridesSchema = z.object({
 	sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
@@ -9481,30 +9715,6 @@ const motion = z.object({
 	]).nullable()
 });
 z.object({ shape: corners });
-z.object({
-	elevation: z.enum([
-		"none",
-		"low",
-		"medium",
-		"high"
-	]),
-	border: z.enum([
-		"none",
-		"subtle",
-		"defined"
-	]),
-	shape: corners,
-	headerStyle: z.enum([
-		"plain",
-		"accentBar",
-		"subtleBg"
-	]).nullable(),
-	mediaTreatment: z.enum([
-		"square",
-		"rounded",
-		"bleed"
-	]).nullable()
-});
 const inputStyle = z.object({
 	shape: corners,
 	border: z.enum([
@@ -9519,12 +9729,6 @@ const inputStyle = z.object({
 	]),
 	label: z.enum(["inside", "above"])
 });
-const headerVariant = z.enum([
-	"classic",
-	"centered",
-	"transparent",
-	"floating"
-]);
 const headerPositioning = z.enum([
 	"static",
 	"sticky",
@@ -9668,7 +9872,7 @@ const headerBackgroundSchema = z.object({
 	textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
 const headerSchema = z.object({
-	variant: headerVariant,
+	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
 	maxWidth: headerMaxWidth,
@@ -10035,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;
 }
@@ -10137,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({
@@ -10151,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),
@@ -10288,93 +10494,276 @@ const quietArrowRecipe = defineButtonStyleRecipe({
 	})
 });
 //#endregion
-//#region ../theme-core/src/buttons/styles/recipes/defineStaticButtonStyleRecipe.ts
-const emptyParametersSchema = z.object({}).strict();
-function defineStaticButtonStyleRecipe(input) {
-	const system = normalizeSystem(input.system);
-	return defineButtonStyleRecipe({
-		id: input.id,
-		accessibilityLabel: input.accessibilityLabel,
-		tags: input.tags,
-		parameterSchema: emptyParametersSchema,
-		defaultParameters: {},
-		controls: [],
-		defineSystem: () => system
-	});
-}
-function normalizeSystem(input) {
-	return {
-		global: buttonGlobalSettingsSchema.parse(input.global),
-		...input.sizes ? { sizes: input.sizes } : {},
-		roles: {
-			primary: normalizeCompleteRole(input.roles.primary),
-			secondary: normalizeCompleteRole(input.roles.secondary),
-			outline: normalizeSupportingRole(input.roles.outline),
-			ghost: normalizeSupportingRole(input.roles.ghost),
-			accent: normalizeSupportingRole(input.roles.accent)
+//#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"
 		}
-	};
-}
-function normalizeCompleteRole(role) {
-	return {
-		kind: "complete",
-		appearance: normalizeAppearance(role.appearance)
-	};
-}
-function normalizeSupportingRole(role) {
-	if (role.kind === "complete") return normalizeCompleteRole(role);
-	return {
-		kind: "derive",
-		from: role.from,
-		...role.overrides ? { overrides: normalizeAppearanceOverrides(role.overrides) } : {}
-	};
-}
-function normalizeAppearance(appearance) {
-	const { background, hoverBackgroundToken, ...rest } = appearance;
-	return {
-		...rest,
-		background: buttonColourTreatmentSchema.parse(background),
-		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
-	};
-}
-function normalizeAppearanceOverrides(overrides) {
-	const { background, hoverBackgroundToken, ...rest } = overrides;
-	return {
-		...rest,
-		...background ? { background: buttonColourTreatmentSchema.parse(background) } : {},
-		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
-	};
-}
-//#endregion
-//#region ../theme-core/src/buttons/styles/recipes/staticRecipes.ts
-const softPillRecipe = defineStaticButtonStyleRecipe({
-	id: "soft-pill",
-	accessibilityLabel: "Rounded pill buttons with a gentle hover lift",
+	]
+};
+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: "organic"
+		era: "editorial"
 	},
-	system: {
+	parameterSchema: flatInkParametersSchema,
+	defaultParameters: {},
+	controls: [hoverControl],
+	defineSystem: (parameters) => ({
 		global: {
-			cornerStyle: "pill",
-			shadow: "low",
+			cornerStyle: "rounded",
 			textTransform: "none",
-			fontWeight: 500,
+			fontWeight: 600,
+			typography: "body",
+			letterSpacing: "tight",
+			paddingPreset: "default",
 			hoverTransform: "lift",
 			hoverColor: "none"
 		},
-		roles: {
-			primary: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "solid",
-						colorToken: "primary"
-					},
-					borderRadius: "rounded-full",
-					shadow: {
+		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) {
+	const system = normalizeSystem(input.system);
+	return defineButtonStyleRecipe({
+		id: input.id,
+		accessibilityLabel: input.accessibilityLabel,
+		tags: input.tags,
+		parameterSchema: emptyParametersSchema,
+		defaultParameters: {},
+		controls: [],
+		defineSystem: () => system
+	});
+}
+function normalizeSystem(input) {
+	return {
+		global: buttonGlobalSettingsSchema.parse(input.global),
+		...input.sizes ? { sizes: input.sizes } : {},
+		roles: {
+			primary: normalizeCompleteRole(input.roles.primary),
+			secondary: normalizeCompleteRole(input.roles.secondary),
+			outline: normalizeSupportingRole(input.roles.outline),
+			ghost: normalizeSupportingRole(input.roles.ghost),
+			accent: normalizeSupportingRole(input.roles.accent)
+		}
+	};
+}
+function normalizeCompleteRole(role) {
+	return {
+		kind: "complete",
+		appearance: normalizeAppearance(role.appearance)
+	};
+}
+function normalizeSupportingRole(role) {
+	if (role.kind === "complete") return normalizeCompleteRole(role);
+	return {
+		kind: "derive",
+		from: role.from,
+		...role.overrides ? { overrides: normalizeAppearanceOverrides(role.overrides) } : {}
+	};
+}
+function normalizeAppearance(appearance) {
+	const { background, hoverBackgroundToken, ...rest } = appearance;
+	return {
+		...rest,
+		background: buttonColourTreatmentSchema.parse(background),
+		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
+	};
+}
+function normalizeAppearanceOverrides(overrides) {
+	const { background, hoverBackgroundToken, ...rest } = overrides;
+	return {
+		...rest,
+		...background ? { background: buttonColourTreatmentSchema.parse(background) } : {},
+		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
+	};
+}
+//#endregion
+//#region ../theme-core/src/buttons/styles/recipes/staticRecipes.ts
+const softPillRecipe = defineStaticButtonStyleRecipe({
+	id: "soft-pill",
+	accessibilityLabel: "Rounded pill buttons with a gentle hover lift",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			shadow: "low",
+			textTransform: "none",
+			fontWeight: 500,
+			hoverTransform: "lift",
+			hoverColor: "none"
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					shadow: {
 						elevation: "low",
 						softness: "soft",
 						position: "bottom"
@@ -11134,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",
@@ -11656,13 +11938,25 @@ function presetCategory(recipe) {
 function joinClasses(...parts) {
 	return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
 }
-function FeedbackMessage({ tone, children, className, id, title, titleClassName, bodyClassName, role = "status", live }) {
+/**
+* The class each treatment contributes on top of whatever the caller passed.
+*
+* `panel` contributes nothing: its callers already pass `alert alert-*`, so
+* adopting the vocabulary changes no existing rendering. `field-note` needs a
+* single hook — its tone styling keys off `data-feedback-tone` in the
+* theme-generated CSS rather than off a second class.
+*/
+function treatmentClass(treatment) {
+	return treatment === "field-note" ? "feedback-note" : void 0;
+}
+function FeedbackMessage({ tone, treatment = "panel", children, className, id, title, titleClassName, bodyClassName, role = "status", live }) {
 	const resolvedLive = live ?? (role === "alert" ? "assertive" : "polite");
-	const shouldWrapBody = Boolean(title || bodyClassName);
+	const shouldWrapBody = Boolean(title || bodyClassName) || treatment === "field-note";
 	return /* @__PURE__ */ jsxs("div", {
 		id,
-		className,
+		className: joinClasses(className, treatmentClass(treatment)) || void 0,
 		"data-feedback-tone": tone,
+		"data-feedback-treatment": treatment,
 		role,
 		"aria-live": resolvedLive === "off" ? void 0 : resolvedLive,
 		children: [title ? /* @__PURE__ */ jsx("p", {
@@ -11983,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",
@@ -12841,16 +13135,10 @@ function DefaultBookingErrorSummary({ errors, id }) {
 	if (!hasBookingValidationErrors(errors)) return null;
 	return /* @__PURE__ */ jsxs(FeedbackMessage, {
 		tone: "error",
-		className: "rb-mt-6 alert alert-error",
+		treatment: "field-note",
 		id,
 		role: "alert",
-		children: [errors.formError ? /* @__PURE__ */ jsx("p", {
-			className: "rb-caption",
-			children: /* @__PURE__ */ jsx("strong", { children: errors.formError })
-		}) : null, Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx("p", {
-			className: "rb-caption",
-			children: message
-		}, key))]
+		children: [errors.formError ? /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("strong", { children: errors.formError }) }) : null, Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx("p", { children: message }, key))]
 	});
 }
 function SelectedCheck() {
@@ -13555,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.
@@ -13569,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();
@@ -13609,6 +13933,7 @@ function usePortalAuthWithDeps(deps) {
 		isAuthenticated: authState === "authenticated",
 		isChecking: authState === "checking",
 		profile,
+		creditState: scopePortalCreditStateToSubject(creditState, authState === "authenticated" ? profile?.email ?? null : null),
 		logout
 	};
 }
@@ -13849,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;
@@ -14564,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(),
@@ -14584,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(),
@@ -14607,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",
@@ -14621,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(),
@@ -14647,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
@@ -14657,6 +15136,7 @@ const eventPresetSchema = z.enum([
 	"event",
 	"class",
 	"course",
+	"term",
 	"workshop",
 	"retreat",
 	"performance"
@@ -14715,57 +15195,49 @@ z.enum([
 */
 const accessRestrictionSchema = z.enum(["none", "category"]);
 z.enum(["single", "ticket_types"]);
+const freePriceDisplaySchema = z.object({
+	kind: z.literal("free"),
+	currency: z.string()
+});
+const exactPriceDisplaySchema = z.object({
+	kind: z.literal("exact"),
+	amount: z.number(),
+	currency: z.string()
+});
+const fromPriceDisplaySchema = z.object({
+	kind: z.literal("from"),
+	amount: z.number(),
+	currency: z.string()
+});
+const unavailablePriceDisplaySchema = z.object({
+	kind: z.literal("unavailable"),
+	currency: z.string()
+});
+const rangePriceDisplaySchema = z.object({
+	kind: z.literal("range"),
+	minAmount: z.number(),
+	maxAmount: z.number(),
+	currency: z.string()
+});
+const mixedPriceDisplaySchema = z.object({
+	kind: z.literal("mixed"),
+	paidFromAmount: z.number(),
+	paidToAmount: z.number(),
+	currency: z.string()
+});
 const publicCoursePriceDisplaySchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	})
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	unavailablePriceDisplaySchema
 ]);
 z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("range"),
-		minAmount: z.number(),
-		maxAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("mixed"),
-		paidFromAmount: z.number(),
-		paidToAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	}),
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	rangePriceDisplaySchema,
+	mixedPriceDisplaySchema,
+	unavailablePriceDisplaySchema,
 	z.object({
 		kind: z.literal("external"),
 		label: z.string()
@@ -14776,36 +15248,12 @@ z.discriminatedUnion("kind", [
 	})
 ]);
 const publicEventTicketTypePriceDisplaySchema = z.union([
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("range"),
-		minAmount: z.number(),
-		maxAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("mixed"),
-		paidFromAmount: z.number(),
-		paidToAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	})
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	rangePriceDisplaySchema,
+	mixedPriceDisplaySchema,
+	unavailablePriceDisplaySchema
 ]);
 const publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
 const publicEventAttendanceModeAvailabilitySchema = z.object({
@@ -14919,6 +15367,22 @@ const publicTeamMemberSummarySchema = z.object({
 	summary: z.string().nullable(),
 	profilePath: z.string().nullable()
 });
+const publicEventBookingAvailabilitySchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("open") }), z.object({
+	kind: z.literal("closed"),
+	reason: z.enum([
+		"occurrence_cancelled",
+		"occurrence_completed",
+		"series_draft",
+		"series_cancelled",
+		"series_completed",
+		"series_archived",
+		"parent_archived",
+		"parent_inconsistent",
+		"not_public",
+		"already_started",
+		"enrollment_closed"
+	])
+})]);
 /**
 * Zod schema for public event data
 */
@@ -14943,6 +15407,7 @@ const publicEventSchema = z.object({
 	path: z.string().nullable(),
 	destination: publicEventDestinationSchema,
 	requiresRegistration: z.boolean(),
+	bookingAvailability: publicEventBookingAvailabilitySchema,
 	deliveryMode: z.enum([
 		"in_person",
 		"online",
@@ -14961,6 +15426,8 @@ const publicEventSchema = z.object({
 	status: z.enum([
 		"active",
 		"draft",
+		"cancelled",
+		"completed",
 		"archived"
 	]).optional(),
 	timeZone: z.string(),
@@ -14973,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()
@@ -14984,6 +15451,7 @@ const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
 	reason: z.enum([
 		"unsupportedSubject",
 		"invalidEventSeriesId",
+		"invalidEventSeriesBookingScope",
 		"invalidEventOfferingId"
 	])
 });
@@ -15014,6 +15482,10 @@ function normalizeEventRegistrationPageSurfaceSubject(value) {
 			kind: "unsupported",
 			reason: "invalidEventSeriesId"
 		};
+		case "invalidEventSeriesBookingScope": return {
+			kind: "unsupported",
+			reason: "invalidEventSeriesBookingScope"
+		};
 		case "invalidEventOfferingId": return {
 			kind: "unsupported",
 			reason: "invalidEventOfferingId"
@@ -15126,8 +15598,8 @@ function normalizePublicEventLike(value) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.planning.ts
-function getRegistrableStatuses(isPreview) {
-	return isPreview ? ["active", "draft"] : ["active"];
+function isEventRegistrationAvailable(event) {
+	return event.bookingAvailability.kind === "open";
 }
 function normalizeEventRegistrationMaxTickets(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
@@ -15283,8 +15755,7 @@ function resolveHeadlessEventRegistrationView(wizard) {
 		kind: "empty",
 		message: "No events available for registration."
 	};
-	const allowedStatuses = getRegistrableStatuses(wizard.api.config.isPreview);
-	if (!wizard.scopedEvents.some((event) => !event.status || allowedStatuses.includes(event.status)) && !wizard.occurrenceContext) return {
+	if (!wizard.scopedEvents.some(isEventRegistrationAvailable) && !wizard.occurrenceContext) return {
 		kind: "unavailable",
 		message: "Registration is not currently available for this event."
 	};
@@ -15499,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);
@@ -16052,6 +16523,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		setAltchaSolution,
 		portalAuthState,
 		portalProfile,
+		portalCreditState,
 		showMagicLinkModal,
 		setShowMagicLinkModal,
 		handleLogout,
@@ -16106,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) {
@@ -16116,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}`);
@@ -16459,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;
@@ -16477,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",
@@ -16517,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"
 	];
@@ -16558,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,
@@ -16580,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);
@@ -16618,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);
@@ -16647,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,
@@ -16662,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 {
@@ -16816,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) {
@@ -16827,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);
@@ -16861,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({
@@ -16912,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 {
@@ -16933,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;
 		};
@@ -16955,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");
@@ -16969,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;
 }
@@ -16991,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,
@@ -17025,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,
@@ -17060,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" };
@@ -17073,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" };
@@ -17088,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("");
@@ -17115,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) => {
@@ -17158,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,
@@ -17178,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
@@ -17200,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,
@@ -17243,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,
@@ -17258,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,
@@ -17271,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");
@@ -17314,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];
@@ -17397,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" };
@@ -17431,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":
@@ -17468,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,
@@ -17494,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({
@@ -17503,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) => {
@@ -17533,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."
@@ -17564,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");
@@ -17572,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":
@@ -17584,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) => ({
@@ -17594,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,
@@ -17605,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
@@ -17619,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: {
@@ -17630,7 +17995,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			errors: wizard.errors
 		},
 		pricing: {
-			...toWholeSeriesRegistrationPricing(wizard.selectedCoursePricing),
+			...toWholeSeriesRegistrationPricing(wizard.selectedRunPricing),
 			selectedOptionId: wizard.selectedPricingOptionId,
 			selection: pricingSelection
 		},
@@ -17646,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,
@@ -17661,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,
@@ -17706,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,
@@ -17732,7 +18097,7 @@ function toPublicCourse(run) {
 		venue: run.venue
 	};
 }
-function toCoursePricing(pricing) {
+function toWholeSeriesPricing(pricing) {
 	const common = {
 		bookingRequirement: pricing.bookingRequirement,
 		pricingStrategy: pricing.pricingStrategy,
@@ -17859,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."
@@ -17870,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;
 }