@riverbankcms/sdk 0.130.2 → 0.134.0

package/dist/client/bookings.mjs

@@ -3211,20 +3211,7 @@ function createBlockApi(config) {
 			const path = buildPath(WHOLE_SERIES.checkout.path, { siteId: sid });
 			return request(WHOLE_SERIES.checkout, {
 				path,
-				body: {
-					eventSeriesId: data.eventSeriesId,
-					...data.pricingOptionId ? { pricingOptionId: data.pricingOptionId } : {},
-					...data.selectedSlidingAmount !== void 0 ? { selectedSlidingAmount: data.selectedSlidingAmount } : {},
-					email: data.email,
-					name: data.name,
-					phone: data.phone,
-					formData: data.formData,
-					altchaSolution: data.altchaSolution,
-					discountCode: data.discountCode,
-					successUrl: data.successUrl,
-					cancelUrl: data.cancelUrl,
-					claimToken: data.claimToken
-				}
+				body: data
 			});
 		},
 		async getWholeSeriesRegistrationStatus(params) {
@@ -3676,7 +3663,7 @@ function getChallengeUrl() {
 }
 //#endregion
 //#region ../core/src/result.ts
-function ok(value) {
+function ok$1(value) {
 	return {
 		ok: true,
 		value
@@ -3696,11 +3683,14 @@ function parseUuidBrand(value, unsafeConstructor) {
 	const normalized = value.trim().toLowerCase();
 	if (normalized.length === 0) return err$1({ kind: "empty_string" });
 	if (!UUID_PATTERN.test(normalized)) return err$1({ kind: "invalid_uuid" });
-	return ok(unsafeConstructor(normalized));
+	return ok$1(unsafeConstructor(normalized));
 }
 const unsafeAsSiteId = (id) => id;
 const unsafeAsEventOfferingId = (id) => id;
 const unsafeAsEventSeriesId = (id) => id;
+const unsafeAsMediaAssetId = (id) => id;
+const unsafeAsStorageBucketName = (value) => value;
+const unsafeAsStoragePath = (value) => value;
 const unsafeAsFormId = (id) => id;
 const unsafeAsPassId = (id) => id;
 const unsafeAsCustomerPassId = (id) => id;
@@ -3843,7 +3833,7 @@ function parseEventPageSurfaceSubject(value) {
 				kind: "invalidEventSeriesBookingScope",
 				bookingScope: value.bookingScope
 			});
-			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
+			return ok$1(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -3864,7 +3854,7 @@ function parseEventPageSurfaceSubject(value) {
 				});
 				parsedSeriesIds.push(eventSeriesId.value);
 			}
-			return ok({
+			return ok$1({
 				kind: "eventOffering",
 				eventOfferingId: eventOfferingId.value,
 				availableEventSeriesIds: parsedSeriesIds
@@ -3982,7 +3972,7 @@ function parseBookingTimeZone(timeZone) {
 	if (typeof timeZone !== "string") return err$1("invalid-time-zone");
 	const normalized = timeZone.trim();
 	if (normalized.length === 0 || NUMERIC_OFFSET_TIME_ZONE_PATTERN.test(normalized) || !isValidBookingTimeZone(normalized)) return err$1("invalid-time-zone");
-	return ok(normalized);
+	return ok$1(normalized);
 }
 //#endregion
 //#region ../core/src/booking-date-time.ts
@@ -4061,7 +4051,7 @@ function parseUtcIsoDateTimeString(value) {
 	if (!hasUtcSuffix && !hasExplicitOffset) return err$1("missing-timezone-offset");
 	const date = new Date(normalized);
 	if (Number.isNaN(date.getTime())) return err$1("invalid-date-time");
-	return ok(date.toISOString());
+	return ok$1(date.toISOString());
 }
 function toUtcIsoDateTimeString(value) {
 	const parsed = parseUtcIsoDateTimeString(value);
@@ -4213,6 +4203,109 @@ function assertNever(value, message) {
 	throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 //#endregion
+//#region ../blocks/src/system/manifest/richTextSchema.ts
+/**
+* Shared Rich Text Schema
+*
+* This module provides a single source of truth for TipTap rich text validation
+* across both the block-form editor and the block rendering system.
+*
+* Rich-text fields use one canonical root shape:
+* `{ type: 'doc', content: [...] }`.
+*/
+/**
+* TipTap document node schema (recursive structure)
+*
+* Supports the full TipTap document structure including:
+* - type: Node type (e.g., 'doc', 'paragraph', 'text')
+* - content: Nested array of child nodes
+* - text: Text content for text nodes
+* - attrs: Node attributes (e.g., alignment, color)
+* - marks: Text formatting marks (e.g., bold, italic)
+*/
+const TipTapMarkSchema = z.object({
+	type: z.string().min(1),
+	attrs: z.record(z.string(), z.unknown()).optional()
+}).strict();
+const TipTapNodeSchema = z.lazy(() => z.object({
+	type: z.string().min(1),
+	content: z.array(TipTapNodeSchema).optional(),
+	text: z.string().optional(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	marks: z.array(TipTapMarkSchema).optional()
+}).strict().superRefine((node, ctx) => {
+	if (node.type === "doc") ctx.addIssue({
+		code: "custom",
+		path: ["type"],
+		message: "Document nodes are only valid at the rich-text root"
+	});
+	if (node.type === "text") {
+		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "Text nodes require a non-empty text value"
+		});
+		if (node.content !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["content"],
+			message: "Text nodes cannot contain child nodes"
+		});
+		return;
+	}
+	if (node.text !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["text"],
+		message: "Only text nodes can contain a text value"
+	});
+}));
+/**
+* Canonical schema for a TipTap rich-text document root.
+*
+* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
+* `content` is required (possibly empty). This is the shape every producer
+* (dummy content, editor output, migrations) must emit, and the shape every
+* non-legacy consumer can rely on.
+*
+*/
+const RichTextDocSchema = z.object({
+	type: z.literal("doc"),
+	content: z.array(TipTapNodeSchema)
+}).strict();
+//#endregion
+//#region ../blocks/src/system/blocks/shared/bookingConsent.ts
+const BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX = "booking_requirement_consent_";
+function toBookingRequirementConsentFieldId(requirementId) {
+	return `${BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX}${requirementId}`;
+}
+function isBookingRequirementConsentFieldId(value) {
+	return value.startsWith(BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX);
+}
+function toBookingRequirementConsentField(consent) {
+	return {
+		id: toBookingRequirementConsentFieldId(consent.requirementId),
+		label: consent.title,
+		type: "booking_requirement_consent",
+		required: true,
+		agreement: consent.agreement,
+		checkboxLabel: consent.checkboxLabel
+	};
+}
+const blockBookingConsentSchema = z.object({
+	requirementId: z.string(),
+	title: z.string(),
+	agreement: RichTextDocSchema,
+	checkboxLabel: z.string()
+});
+const bookingRequirementConsentFieldSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	type: z.literal("booking_requirement_consent"),
+	required: z.literal(true),
+	agreement: RichTextDocSchema,
+	checkboxLabel: z.string().min(1)
+});
+z.union([blockBookingConsentSchema, bookingRequirementConsentFieldSchema]);
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.reserved-fields.ts
 const BOOKING_FORM_DATA_RESERVED_KEY_VALUES = [
 	"serviceId",
@@ -4226,6 +4319,28 @@ const BOOKING_FORM_DATA_RESERVED_KEY_VALUES = [
 ];
 const BOOKING_FORM_DATA_RESERVED_KEYS = new Set(BOOKING_FORM_DATA_RESERVED_KEY_VALUES);
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.consent.ts
+function resolveSelectedAppointmentConsent(service) {
+	return service?.consent ? {
+		kind: "required-for-selected-service",
+		field: toBookingRequirementConsentField(service.consent)
+	} : { kind: "not-applicable" };
+}
+function projectSelectedAppointmentConsentIntoForm(form, selectedConsent) {
+	if (!form) return null;
+	const sourceFields = form.schema?.fields ?? [];
+	const baseFields = sourceFields.filter((field) => field.type !== "booking_requirement_consent");
+	const fields = selectedConsent.kind === "required-for-selected-service" ? [...baseFields, selectedConsent.field] : baseFields;
+	if (selectedConsent.kind === "not-applicable" && baseFields.length === sourceFields.length) return form;
+	return {
+		...form,
+		schema: {
+			...form.schema,
+			fields
+		}
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.state.ts
 function toTrimmedString(value) {
 	const trimmed = value?.trim();
@@ -4408,7 +4523,6 @@ function readBookingFieldType(value) {
 		case "select":
 		case "radio":
 		case "checkbox":
-		case "booking_requirement_consent":
 		case "tel":
 		case "url":
 		case "number":
@@ -4443,7 +4557,7 @@ function normalizeBookingSettings(value) {
 	};
 }
 function isBookingFormService(value) {
-	return isRecord$5(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string";
+	return isRecord$5(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string" && (value.consent === void 0 || blockBookingConsentSchema.safeParse(value.consent).success);
 }
 function collectBookingCustomFields(data) {
 	const customFields = {};
@@ -4687,6 +4801,11 @@ function getBookingSuccessMessage(successMessage) {
 	return successMessage?.trim() || "Your appointment has been booked! Check your email for confirmation.";
 }
 //#endregion
+//#region ../blocks/src/system/runtime/hooks/useSelectedAppointmentConsentForm.ts
+function useSelectedAppointmentConsentForm(form, selectedService) {
+	return useMemo(() => projectSelectedAppointmentConsentIntoForm(form, resolveSelectedAppointmentConsent(selectedService)), [form, selectedService]);
+}
+//#endregion
 //#region ../blocks/src/utils/date-formatting.ts
 /**
 * Resolve the browser/runtime timezone for booking surfaces.
@@ -5751,6 +5870,19 @@ function clearBookingFieldError(errors, fieldId) {
 	};
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.field-values.ts
+function collectInitialBookingFieldValues(initialData) {
+	const values = {};
+	for (const [key, value] of Object.entries(initialData)) if (!BOOKING_FORM_DATA_RESERVED_KEYS.has(key) && !isBookingRequirementConsentFieldId(key) && isBookingFieldValue(value)) values[key] = value;
+	return values;
+}
+function omitBookingConsentEntries(record) {
+	return Object.fromEntries(Object.entries(record).filter(([key]) => !isBookingRequirementConsentFieldId(key)));
+}
+function isBookingFieldValue(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
 const unsafeAsBookingFieldId = (id) => id;
 function createInitialBookingFlowReducerState(input) {
@@ -5762,7 +5894,7 @@ function createInitialBookingFlowReducerState(input) {
 		selectedResourceId: toOptionalAppointmentResourceId(toOptionalString(initialData.resourceId) ?? input.defaultResourceId),
 		selectedDate: toOptionalString(initialData.selectedDate),
 		selectedSlot: null,
-		fieldValues: collectInitialFieldValues(initialData),
+		fieldValues: collectInitialBookingFieldValues(initialData),
 		touchedFields: {},
 		attemptedStepIds: {},
 		discountCode: toOptionalString(initialData.discountCode) ?? "",
@@ -5774,14 +5906,6 @@ function createInitialBookingFlowReducerState(input) {
 		feedback: { kind: "none" }
 	};
 }
-function collectInitialFieldValues(initialData) {
-	const values = {};
-	for (const [key, value] of Object.entries(initialData)) {
-		if (BOOKING_FORM_DATA_RESERVED_KEYS.has(key) || !isBookingFieldValue(value)) continue;
-		values[key] = value;
-	}
-	return values;
-}
 function toOptionalString(value) {
 	if (typeof value !== "string") return void 0;
 	const trimmed = value.trim();
@@ -5803,9 +5927,6 @@ function toOptionalAppointmentResourceId(value) {
 function toOptionalCustomerPassId(value) {
 	return toOptionalBrandedId(value, unsafeAsCustomerPassId);
 }
-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.
@@ -5827,17 +5948,7 @@ function applyAvailabilitySelectionInvalidation(state, invalidation) {
 }
 function bookingFlowReducer(state, event) {
 	switch (event.type) {
-		case "service-selected": return {
-			...state,
-			selectedServiceId: event.serviceId,
-			selectedResourceId: void 0,
-			selectedDate: void 0,
-			selectedSlot: null,
-			selectedAppointmentPackageId: void 0,
-			selectedSlidingAmountInput: "",
-			selectedCollectionOptionKind: void 0,
-			validationErrors: clearBookingFormError(state.validationErrors)
-		};
+		case "service-selected": return applyBookingServiceSelection(state, event.serviceId);
 		case "resource-selected": return {
 			...state,
 			selectedResourceId: event.resourceId ?? void 0,
@@ -5944,6 +6055,24 @@ function bookingFlowReducer(state, event) {
 		default: return assertNever(event);
 	}
 }
+function applyBookingServiceSelection(state, serviceId) {
+	return {
+		...state,
+		selectedServiceId: serviceId,
+		selectedResourceId: void 0,
+		selectedDate: void 0,
+		selectedSlot: null,
+		selectedAppointmentPackageId: void 0,
+		selectedSlidingAmountInput: "",
+		selectedCollectionOptionKind: void 0,
+		fieldValues: omitBookingConsentEntries(state.fieldValues),
+		touchedFields: omitBookingConsentEntries(state.touchedFields),
+		validationErrors: {
+			...clearBookingFormError(state.validationErrors),
+			fieldErrors: omitBookingConsentEntries(state.validationErrors.fieldErrors)
+		}
+	};
+}
 function clearAvailabilityFeedback(feedback) {
 	return feedback.kind === "error" && feedback.scope === "availability" ? { kind: "none" } : feedback;
 }
@@ -6104,7 +6233,8 @@ function validateBookingFields(input) {
 	return errors;
 }
 function validateBookingField(field, value) {
-	if (field.required && isBlankFieldValue(value)) return `${field.label} is required`;
+	const requiredError = validateRequiredBookingField(field, value);
+	if (requiredError) return requiredError;
 	if (isBlankFieldValue(value)) return null;
 	const strValue = typeof value === "string" ? value : String(value);
 	if (field.type === "email") return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue) ? null : "Please enter a valid email address";
@@ -6133,6 +6263,10 @@ function validateBookingField(field, value) {
 	}
 	return null;
 }
+function validateRequiredBookingField(field, value) {
+	if (field.type === "booking_requirement_consent") return value === true ? null : `${field.label} is required`;
+	return field.required && isBlankFieldValue(value) ? `${field.label} is required` : null;
+}
 function deriveBookingFlowSteps(input) {
 	const stepResolution = buildBookingStepResolution({
 		form: input.form,
@@ -6204,7 +6338,8 @@ function deriveBookingFieldViews(input) {
 	return (input.form?.schema?.fields ?? []).map((field) => {
 		const fieldId = unsafeAsBookingFieldId(field.id);
 		const inputId = `${input.idPrefix}-${fieldId}`;
-		const helpTextId = field.helpText ? `${inputId}-help` : null;
+		const helpText = field.type === "booking_requirement_consent" ? null : field.helpText ?? null;
+		const helpTextId = helpText ? `${inputId}-help` : null;
 		const fieldValue = input.values[field.id] ?? null;
 		const localError = input.touched?.[field.id] ? validateBookingField(field, fieldValue) : null;
 		const error = input.errors[field.id] ?? localError;
@@ -6214,17 +6349,17 @@ function deriveBookingFieldViews(input) {
 			field,
 			id: fieldId,
 			label: field.label,
-			type: field.type,
 			value: fieldValue,
 			required: Boolean(field.required),
 			error,
-			helpText: field.helpText ?? null,
+			helpText,
 			inputId,
 			labelId: `${inputId}-label`,
 			helpTextId,
 			errorId,
 			describedBy,
-			ariaInvalid: Boolean(error)
+			ariaInvalid: Boolean(error),
+			type: field.type
 		};
 	});
 }
@@ -6486,6 +6621,7 @@ function useHeadlessBookingFlow(options) {
 	const selectedServiceId = state.selectedServiceId ?? defaultServiceId;
 	const selectedResourceId = state.selectedResourceId ?? defaultResourceId;
 	const selectedService = options.services.find((service) => service.id === selectedServiceId) ?? null;
+	const runtimeForm = useSelectedAppointmentConsentForm(options.form, selectedService);
 	const lastSlidingServiceIdRef = useRef(null);
 	useEffect(() => {
 		const selectedId = selectedService?.id ?? null;
@@ -6526,7 +6662,7 @@ function useHeadlessBookingFlow(options) {
 		viewerTimeZone
 	]);
 	const stepState = useMemo(() => deriveBookingFlowSteps({
-		form: options.form,
+		form: runtimeForm,
 		services: options.services,
 		data,
 		defaultServiceId,
@@ -6542,7 +6678,7 @@ function useHeadlessBookingFlow(options) {
 		defaultServiceId,
 		defaultResourceId,
 		options.enableAppointmentPackages,
-		options.form,
+		runtimeForm,
 		options.requiresResourceSelection,
 		options.requiresServiceSelection,
 		options.services,
@@ -6596,13 +6732,13 @@ function useHeadlessBookingFlow(options) {
 		state.selectedSlot
 	]);
 	const fields = useMemo(() => deriveBookingFieldViews({
-		form: options.form,
+		form: runtimeForm,
 		values: state.fieldValues,
 		errors: state.validationErrors.fieldErrors,
 		touched: state.touchedFields,
 		idPrefix: `booking-${options.formId}`
 	}), [
-		options.form,
+		runtimeForm,
 		options.formId,
 		state.fieldValues,
 		state.touchedFields,
@@ -6722,7 +6858,7 @@ function useHeadlessBookingFlow(options) {
 	const latestRef = useLatestRef({
 		state,
 		data,
-		form: options.form,
+		form: runtimeForm,
 		formId: formKey,
 		services: options.services,
 		defaultServiceId,
@@ -6974,7 +7110,7 @@ function useHeadlessBookingFlow(options) {
 		phase: state.phase
 	});
 	const view = resolveHeadlessBookingView({
-		form: options.form,
+		form: runtimeForm,
 		feedback: state.feedback
 	});
 	const appointmentPackagesModel = resolveAppointmentPackagesModel({
@@ -7530,6 +7666,12 @@ const opaqueButtonColourTokenSchema = themeColorTokenSchema.refine((value) => pa
 	if (token === null) throw new Error("Invariant: opaque button token passed its schema");
 	return token;
 });
+const contextualButtonHoverSchema = z.strictObject({
+	kind: z.literal("shade-shift"),
+	seedToken: opaqueButtonColourTokenSchema,
+	fallbackDirection: z.enum(["lighter", "darker"]),
+	preferredToken: opaqueButtonColourTokenSchema.optional()
+});
 const buttonShadeAmountSchema = z.number().finite().min(0).max(900).multipleOf(100);
 const buttonShadowIntensitySchema = z.enum([
 	"subtle",
@@ -7869,6 +8011,7 @@ const buttonVariantSchema = z.strictObject({
 	shadow: variantShadowSchema.optional(),
 	border: buttonBorderSchema.optional(),
 	hoverBackgroundToken: opaqueButtonColourTokenSchema.optional(),
+	contextualHover: contextualButtonHoverSchema.optional(),
 	effects: variantEffectsSchema.optional(),
 	sizes: variantSizeOverridesSchema.optional(),
 	affordance: buttonVariantAffordanceSchema.optional()
@@ -8154,8 +8297,8 @@ const openCardRoleValue = "open";
 */
 const surfaceCardRoleValues = [...cardVariantRoleValues, openCardRoleValue];
 /**
-* The closed card-role vocabulary Looks and blocks address cards by — this is
-* `BoxStylesCardVariant` widened with `open`, not a parallel enum.
+* The closed role vocabulary Looks and blocks use for surfaced and boxless
+* card choices.
 *
 * - `none`        — no site-style card surface; the block's own composition and
 *                   the author's own card fields govern the item. This is *not*
@@ -8199,11 +8342,6 @@ const gradientDirectionSchema = z.enum([
 z.enum(cardVariantRoleValues);
 const surfaceCardRoleSchema = z.enum(surfaceCardRoleValues);
 const cardRoleSchema = z.enum(cardRoleValues);
-/**
-* Historical name for the role vocabulary as it reaches box styles. Widened to
-* the full `CardRole` set — old values keep parsing, `open` now parses too.
-*/
-const boxStylesCardVariantSchema = cardRoleSchema;
 const PRIORITY_ROLE_INFERENCE = {
 	1: "default",
 	2: "alternative"
@@ -9608,8 +9746,7 @@ const cardStylesOverrideSchema = z.object({
 	spacing: semanticSpacingSchema.nullable().optional(),
 	raised: z.boolean().nullable().optional(),
 	rounded: boxRoundedSchema.nullable().optional(),
-	role: cardRoleSchema.nullable().optional(),
-	cardVariant: boxStylesCardVariantSchema.nullable().optional()
+	role: cardRoleSchema.nullable().optional()
 });
 const blockStyleOverridesSchema = z.object({
 	sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
@@ -10238,13 +10375,7 @@ function shadeBackgroundEffect(config) {
 buttonSizeNameSchema.options;
 //#endregion
 //#region ../theme-core/src/buttons/styles/domain.ts
-const PUBLIC_BUTTON_ROLES = [
-	"primary",
-	"secondary",
-	"outline",
-	"ghost",
-	"accent"
-];
+const PUBLIC_BUTTON_ROLES = VARIANT_ROLES;
 function defineButtonStyleRecipe(recipe) {
 	return recipe;
 }
@@ -10340,6 +10471,14 @@ const BUTTON_STYLE_IDS = [
 	"quiet-arrow"
 ];
 const quietArrowParametersSchema = z.object({ secondaryTreatment: z.enum(["outlined", "solid-accent"]) }).strict();
+const flatInkHoverTreatmentSchema = z.enum([
+	"contextual",
+	"secondary",
+	"accent"
+]);
+const flatInkHoverPreferencesShape = Object.fromEntries(VARIANT_ROLES.map((role) => [role, flatInkHoverTreatmentSchema.optional()]));
+const flatInkHoverPreferencesSchema = z.strictObject(flatInkHoverPreferencesShape);
+const flatInkParametersSchema = z.strictObject({ hoverPreferences: flatInkHoverPreferencesSchema.optional() });
 const emptyParametersSchema$1 = z.object({}).strict();
 function selectionBranch(styleId, parameters) {
 	return z.object({
@@ -10354,7 +10493,7 @@ z.discriminatedUnion("styleId", [
 	selectionBranch("editorial-link", emptyParametersSchema$1),
 	selectionBranch("pebble", emptyParametersSchema$1),
 	selectionBranch("ink-stamp", emptyParametersSchema$1),
-	selectionBranch("flat-ink", emptyParametersSchema$1),
+	selectionBranch("flat-ink", flatInkParametersSchema),
 	selectionBranch("brushed-wash", emptyParametersSchema$1),
 	selectionBranch("showtime-pill", emptyParametersSchema$1),
 	selectionBranch("joy-stamp", emptyParametersSchema$1),
@@ -10491,105 +10630,288 @@ 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"
 		},
+		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-full",
-					shadow: {
-						elevation: "low",
-						softness: "soft",
-						position: "bottom"
+						colorToken: unsafeAsOpaqueButtonColourToken("primary")
 					},
-					effects: {
-						hover: [{ effectId: "lift" }],
-						active: [{
-							effectId: "scale-down",
-							options: { scale: "0.98" }
-						}]
-					}
-				}
+					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"
+					},
+					effects: {
+						hover: [{ effectId: "lift" }],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.98" }
+						}]
+					}
+				}
 			},
 			secondary: {
 				kind: "complete",
@@ -11337,113 +11659,6 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 		}
 	}
 });
-const flatInkRecipe = defineStaticButtonStyleRecipe({
-	id: "flat-ink",
-	accessibilityLabel: "Flat rounded buttons with arrow affordances",
-	tags: {
-		tone: "classic",
-		energy: "calm",
-		motion: "subtle",
-		era: "editorial"
-	},
-	system: {
-		global: {
-			cornerStyle: "rounded",
-			textTransform: "none",
-			fontWeight: 600,
-			typography: "body",
-			letterSpacing: "tight",
-			paddingPreset: "default",
-			hoverTransform: "lift",
-			hoverColor: "none"
-		},
-		sizes: {
-			sm: {
-				padding: "0.625rem 1.125rem",
-				fontSize: "text-sm"
-			},
-			md: { padding: "0.8125rem 1.375rem" },
-			lg: {
-				padding: "0.9375rem 1.625rem",
-				fontSize: "text-lg"
-			},
-			xl: {
-				padding: "1.0625rem 2rem",
-				fontSize: "text-xl"
-			}
-		},
-		roles: {
-			primary: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "solid",
-						colorToken: "primary"
-					},
-					borderRadius: "rounded-lg",
-					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("secondary") }
-					}] }
-				}
-			},
-			secondary: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					border: { widthClass: "border" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
-					}] }
-				}
-			},
-			outline: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					border: { widthClass: "border" },
-					effects: { hover: [{ effectId: "lift" }, {
-						effectId: "background-on-hover",
-						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
-					}] }
-				}
-			},
-			ghost: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "surface",
-						role: "link"
-					},
-					borderRadius: "rounded-lg",
-					effects: { hover: [{ effectId: "lift" }] }
-				}
-			},
-			accent: {
-				kind: "complete",
-				appearance: {
-					background: {
-						type: "solid",
-						colorToken: "accent"
-					},
-					borderRadius: "rounded-lg",
-					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{ effectId: "lift" }] }
-				}
-			}
-		}
-	}
-});
 const showtimePillRecipe = defineStaticButtonStyleRecipe({
 	id: "showtime-pill",
 	accessibilityLabel: "Bold uppercase pill buttons with playful movement",
@@ -12198,17 +12413,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",
@@ -12316,27 +12531,789 @@ function DiscountCodeDisclosure({ surface, isOpen, code, onOpen, onChange, onRem
 	});
 }
 //#endregion
-//#region ../blocks/src/system/runtime/shared/components/FieldValidationMessage.tsx
-function getFieldValidationControlProps({ message, messageId, describedBy }) {
-	const hasMessage = Boolean(message);
-	const ariaDescribedBy = [describedBy, hasMessage ? messageId : void 0].filter((part) => typeof part === "string" && part.length > 0).join(" ");
-	return {
-		"aria-invalid": hasMessage ? "true" : void 0,
-		"aria-describedby": ariaDescribedBy || void 0
-	};
+//#region ../blocks/src/system/runtime/shared/components/FieldValidationMessage.tsx
+function getFieldValidationControlProps({ message, messageId, describedBy }) {
+	const hasMessage = Boolean(message);
+	const ariaDescribedBy = [describedBy, hasMessage ? messageId : void 0].filter((part) => typeof part === "string" && part.length > 0).join(" ");
+	return {
+		"aria-invalid": hasMessage ? "true" : void 0,
+		"aria-describedby": ariaDescribedBy || void 0
+	};
+}
+function FieldValidationMessage({ id, children, className, live = "assertive" }) {
+	return /* @__PURE__ */ jsx("p", {
+		id,
+		className,
+		"data-field-validation-message": true,
+		"data-field-validation-tone": "error",
+		role: "alert",
+		"aria-live": live === "off" ? void 0 : live,
+		children
+	});
+}
+//#endregion
+//#region ../blocks/src/primitives/content/utils/sanitizeHref.ts
+const SAFE_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+]);
+const CONTROL_CHARS_PATTERN = /[\u0000-\u001F\u007F]+/g;
+function normalizeInput(value) {
+	return value.replace(CONTROL_CHARS_PATTERN, "").trim();
+}
+function decodeForSchemeCheck(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Returns a safe href for rich-text anchors, or null when the value should not be rendered.
+*
+* Policy:
+* - Allow absolute URLs with protocols: http, https, mailto, tel.
+* - Allow root-relative ("/path") and hash-only ("#section") links.
+* - Reject protocol-relative URLs ("//example.com"), bare domains ("example.com"),
+*   executable schemes (javascript/data/vbscript), malformed URLs, and empty values.
+* - Preserve percent-encoding from the original normalized input.
+*/
+function sanitizeHref(raw) {
+	if (typeof raw !== "string") return null;
+	const normalized = normalizeInput(raw);
+	if (!normalized) return null;
+	if (normalized.startsWith("//")) return null;
+	if (normalized.startsWith("/")) return normalized;
+	if (normalized.startsWith("#")) return normalized;
+	const schemeMatch = normalizeInput(decodeForSchemeCheck(normalized)).match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
+	if (!schemeMatch) return null;
+	const rawScheme = schemeMatch[1];
+	if (!rawScheme) return null;
+	const protocol = `${rawScheme.toLowerCase()}:`;
+	if (!SAFE_PROTOCOLS.has(protocol)) return null;
+	try {
+		const parsed = new URL(normalized);
+		if (!SAFE_PROTOCOLS.has(parsed.protocol.toLowerCase())) return null;
+	} catch {
+		return null;
+	}
+	return normalized;
+}
+//#endregion
+//#region ../media-core/src/fileSafety.ts
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/u;
+function containsUnsafePathSegmentCharacter(value) {
+	return value.includes("/") || value.includes("\\") || CONTROL_CHARACTER_PATTERN.test(value);
+}
+function isReservedPathSegment(value) {
+	return value === "." || value === "..";
+}
+function isUnsafePathSegment(segment) {
+	return segment.trim().length === 0 || segment !== segment.trim() || isReservedPathSegment(segment) || containsUnsafePathSegmentCharacter(segment);
+}
+({
+	publicSite: unsafeAsStorageBucketName("media"),
+	privateSite: unsafeAsStorageBucketName("site-files-private"),
+	temporary: unsafeAsStorageBucketName("temp-uploads")
+}).publicSite;
+function parseStoragePath(value) {
+	return joinStoragePathSegments(value.split("/"));
+}
+/**
+* Joins already-branded path segments while preserving the Storage RLS invariant
+* that every tenant/site identifier remains one segment, never a nested path.
+*/
+function joinStoragePathSegments(segments) {
+	if (segments.some(isUnsafePathSegment)) return err$1("unsafe-path-segment");
+	return ok$1(unsafeAsStoragePath(segments.join("/")));
+}
+//#endregion
+//#region ../media-core/src/storagePathDomain.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function fail(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+function normalizeStringInput(value) {
+	if (typeof value !== "string") return fail({ tag: "MISSING" });
+	const trimmed = value.trim();
+	if (!trimmed) return fail({ tag: "EMPTY" });
+	return ok(trimmed);
+}
+function validateRelativeStoragePath(value) {
+	if (value.startsWith("sites/")) return fail({ tag: "SITE_SCOPED_PATH" });
+	if (value.startsWith("/")) return fail({ tag: "LEADING_SLASH" });
+	if (value.includes("//")) return fail({ tag: "DOUBLE_SLASH" });
+	if (value.includes("%")) return fail({ tag: "PERCENT_ENCODING" });
+	if (value.split("/").some((segment) => segment === "." || segment === "..")) return fail({ tag: "TRAVERSAL" });
+	return ok(value);
+}
+function brandRelativeStoragePath(value) {
+	return value;
+}
+function parseRelativeStoragePath(value) {
+	const normalized = normalizeStringInput(value);
+	if (!normalized.ok) return normalized;
+	const validated = validateRelativeStoragePath(normalized.value);
+	if (!validated.ok) return validated;
+	return ok(brandRelativeStoragePath(validated.value));
+}
+//#endregion
+//#region ../media-core/src/url.ts
+const DEFAULT_BASE_PATH = "/api/img";
+function isSiteScopedDirectImageStoragePath(storagePath) {
+	return storagePath.startsWith("sites/") && parseStoragePath(storagePath).ok;
+}
+function encodeStoragePath(storagePath) {
+	return storagePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function resolveDirectImagePathTarget(target) {
+	switch (target.kind) {
+		case "relative": return `sites/${target.siteId}/${target.storagePath}`;
+		case "site-scoped":
+		case "bucket-scoped": return target.storagePath;
+	}
+}
+function getDirectImageUrl(supabaseUrl, target, storageBucket = "media", options) {
+	const baseUrl = supabaseUrl.replace(/\/$/, "");
+	const encodedPath = encodeStoragePath(resolveDirectImagePathTarget(target));
+	const isSvg = target.storagePath.toLowerCase().endsWith(".svg");
+	if (options && !isSvg && (options.width || options.height)) {
+		const params = new URLSearchParams();
+		if (options.width) params.set("width", String(options.width));
+		if (options.height) params.set("height", String(options.height));
+		if (options.quality) params.set("quality", String(options.quality));
+		if (options.resize) params.set("resize", options.resize);
+		return `${baseUrl}/storage/v1/render/image/public/${storageBucket}/${encodedPath}?${params.toString()}`;
+	}
+	return `${baseUrl}/storage/v1/object/public/${storageBucket}/${encodedPath}`;
+}
+function getDirectImageUrlForRelativePath(supabaseUrl, storagePath, siteId, storageBucket = "media", options) {
+	return getDirectImageUrl(supabaseUrl, {
+		kind: "relative",
+		storagePath,
+		siteId
+	}, storageBucket, options);
+}
+function getDirectImageUrlForSiteScopedPath(supabaseUrl, storagePath, storageBucket = "media", options) {
+	return getDirectImageUrl(supabaseUrl, {
+		kind: "site-scoped",
+		storagePath
+	}, storageBucket, options);
+}
+const formatNumber = (value) => Number.isInteger(value) ? value.toString() : value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+const ORDER = [
+	"w",
+	"h",
+	"fit",
+	"rect",
+	"q",
+	"autoFormat",
+	"or"
+];
+const getImageUrl = (asset, params = {}, basePath = DEFAULT_BASE_PATH) => {
+	const path = `${basePath.endsWith("/") ? basePath.slice(0, Math.max(basePath.length - 1, 0)) : basePath}/${encodeURIComponent(asset.id)}`;
+	const searchParams = new URLSearchParams();
+	if (params.w !== void 0) searchParams.set("w", formatNumber(params.w));
+	if (params.h !== void 0) searchParams.set("h", formatNumber(params.h));
+	if (params.fit !== void 0) searchParams.set("fit", params.fit);
+	if (params.rect) searchParams.set("rect", params.rect.map(formatNumber).join(","));
+	if (params.q !== void 0) searchParams.set("q", formatNumber(params.q));
+	if (params.autoFormat) searchParams.append("auto", "format");
+	if (params.or !== void 0) searchParams.set("or", String(params.or));
+	const sorted = new URLSearchParams();
+	ORDER.forEach((key) => {
+		if (key === "autoFormat") {
+			if (params.autoFormat) sorted.append("auto", "format");
+			return;
+		}
+		const value = searchParams.get(key);
+		if (value !== null) sorted.set(key, value);
+	});
+	const query = sorted.toString();
+	return query ? `${path}?${query}` : path;
+};
+//#endregion
+//#region ../media-core/src/transformRect.ts
+function isValidTransformRectStructure(rect) {
+	if (!Array.isArray(rect) || rect.length !== 4) return false;
+	const [left, top, width, height] = rect;
+	return Number.isFinite(left) && Number.isFinite(top) && Number.isFinite(width) && Number.isFinite(height) && left >= 0 && top >= 0 && width > 0 && height > 0;
+}
+//#endregion
+//#region ../media-core/src/aspectTransforms.ts
+const DEFAULT_RECT_EPSILON = .5;
+function parseAspectRatioValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized) return void 0;
+	if (normalized === "auto") return void 0;
+	if (normalized.includes(":") || normalized.includes("/")) {
+		const delimiter = normalized.includes(":") ? ":" : "/";
+		const [wRaw, hRaw] = normalized.split(delimiter);
+		const width = Number(wRaw?.trim());
+		const height = Number(hRaw?.trim());
+		if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return;
+		return width / height;
+	}
+	const numeric = Number(normalized);
+	if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
+	return numeric;
+}
+const MAX_ASPECT_DISTANCE = .25;
+function resolveMediaTransformForAspect(transform, targetAspect) {
+	if (!transform) return {};
+	const base = {
+		rect: transform.rect,
+		hotspot: transform.hotspot,
+		rotation: transform.rotation
+	};
+	const target = parseAspectRatioValue(targetAspect);
+	const crops = transform.aspectCrops;
+	if (!target || !crops || Object.keys(crops).length === 0) return base;
+	let best = null;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (const [key, candidate] of Object.entries(crops)) {
+		const candidateAspect = parseAspectRatioValue(candidate.aspect ?? key);
+		if (!candidateAspect) continue;
+		const distance = Math.abs(Math.log(candidateAspect / target));
+		if (distance < bestDistance) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	if (!best) return base;
+	if (bestDistance > MAX_ASPECT_DISTANCE) return base;
+	return {
+		rect: best.rect ?? base.rect,
+		hotspot: best.hotspot ?? base.hotspot,
+		rotation: best.rotation ?? base.rotation
+	};
+}
+function isValidTransformRect(rect) {
+	return isValidTransformRectStructure(rect);
+}
+function isExplicitRectCrop(rect, sourceWidth, sourceHeight, epsilon = DEFAULT_RECT_EPSILON) {
+	if (!isValidTransformRect(rect)) return false;
+	if (!(typeof sourceWidth === "number" && Number.isFinite(sourceWidth) && sourceWidth > 0 && typeof sourceHeight === "number" && Number.isFinite(sourceHeight) && sourceHeight > 0)) return true;
+	const [x, y, width, height] = rect;
+	return !(Math.abs(x) <= epsilon && Math.abs(y) <= epsilon && Math.abs(width - sourceWidth) <= epsilon && Math.abs(height - sourceHeight) <= epsilon);
+}
+//#endregion
+//#region ../media-core/src/renderableMediaAsset.ts
+function attachRenderableMediaAssetFields(media, asset) {
+	return {
+		...media,
+		assetId: asset.id,
+		id: asset.id,
+		identifier: mediaIdentifierOrFallback(media.identifier, asset.identifier),
+		storageBucket: asset.storageBucket ?? media.storageBucket,
+		storagePath: asset.storagePath ?? media.storagePath,
+		width: asset.width ?? media.width,
+		height: asset.height ?? media.height,
+		mimeType: asset.mimeType ?? media.mimeType
+	};
+}
+/**
+* Preserve an explicit per-usage identifier when one exists. Otherwise prefer
+* the canonical asset identifier, while keeping intentionally blank legacy
+* string values from becoming null.
+*/
+function mediaIdentifierOrFallback(current, fallback) {
+	if (typeof current === "string" && current.trim().length > 0) return current;
+	return fallback ?? (typeof current === "string" ? current : void 0);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/media.tsx
+const MAX_RENDER_DIMENSION = 4096;
+const RELATIVE_IMG_PROXY_BASE_PATH = "/api/img";
+function getValidSourceDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function isExplicitCropProxyEnabled() {
+	const raw = process.env.NEXT_PUBLIC_MEDIA_EXPLICIT_CROP_PROXY_ENABLED ?? process.env.MEDIA_EXPLICIT_CROP_PROXY_ENABLED;
+	if (!raw) return true;
+	const normalized = raw.trim().toLowerCase();
+	return !(normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off");
+}
+function getRequestedDimension(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return Math.min(MAX_RENDER_DIMENSION, Math.max(1, Math.round(value)));
+}
+function mapResizeToFit(resize) {
+	if (resize === "contain") return "clip";
+	return "crop";
+}
+function shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight) {
+	if ("original" in options && options.original) return false;
+	if (!isExplicitCropProxyEnabled()) return false;
+	if (!value.assetId) return false;
+	if (typeof resolvedTransform.rotation === "number" && resolvedTransform.rotation !== 0) return true;
+	return isExplicitRectCrop(resolvedTransform.rect, sourceWidth, sourceHeight);
+}
+function buildProxyTransformParams(options, resolvedTransform) {
+	const params = {
+		w: "width" in options ? getRequestedDimension(options.width) : void 0,
+		h: "height" in options ? getRequestedDimension(options.height) : void 0,
+		q: "quality" in options ? options.quality : void 0,
+		fit: mapResizeToFit("resize" in options ? options.resize : void 0),
+		autoFormat: true
+	};
+	if (resolvedTransform.rect) params.rect = resolvedTransform.rect;
+	if (resolvedTransform.rotation) params.or = resolvedTransform.rotation;
+	return params;
+}
+function buildDirectTransformOptions(options) {
+	if ("original" in options && options.original) return void 0;
+	return {
+		width: "width" in options ? getRequestedDimension(options.width) : void 0,
+		height: "height" in options ? getRequestedDimension(options.height) : void 0,
+		quality: "quality" in options ? options.quality : void 0,
+		resize: "resize" in options ? options.resize : void 0
+	};
+}
+function resolveTransformResolution(value, targetAspectRatio) {
+	return {
+		resolvedTransform: resolveMediaTransformForAspect(value.transform, targetAspectRatio),
+		sourceWidth: getValidSourceDimension(value.width),
+		sourceHeight: getValidSourceDimension(value.height)
+	};
+}
+function getProxyImageUrl(value, options, transformAspectRatio, resolved) {
+	if (!value.assetId) return void 0;
+	const targetAspect = transformAspectRatio ?? resolveTargetAspectRatio(options);
+	const { resolvedTransform, sourceWidth, sourceHeight } = resolved ?? resolveTransformResolution(value, targetAspect);
+	if (!shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight)) return void 0;
+	const params = buildProxyTransformParams(options, resolvedTransform);
+	const proxyBasePath = getImageProxyBasePath();
+	const proxyUrl = getImageUrl({ id: unsafeAsMediaAssetId(value.assetId) }, params, proxyBasePath);
+	debugMediaNodeLog("resolve:proxy-img", {
+		assetId: value.assetId,
+		params,
+		proxyBasePath,
+		proxyUrl
+	});
+	return proxyUrl;
+}
+function warnForMediaUrlResolution(result) {
+	switch (result.kind) {
+		case "missing-site-context":
+			console.warn(`[blocks] Relative storagePath "${result.storagePath}" requires siteId context. Media URL may be incorrect. Ensure siteId is set via runWithMediaContext or setContextSiteId.`);
+			return;
+		case "missing-supabase-url":
+			console.warn(`[blocks] ${result.message} Media URL may be unavailable. Ensure NEXT_PUBLIC_SUPABASE_URL is configured or pass supabaseUrl in the media context.`);
+			return;
+		case "invalid-storage-path":
+			console.warn(`[blocks] Invalid media storagePath "${result.storagePath}".`);
+			return;
+		case "resolved":
+		case "unsupported-media-type":
+		case "missing-storage-path":
+		case "missing-image-url": return;
+	}
+}
+function resolveMediaStorageUrlResult(value, context, transformOptions) {
+	const canonical = resolveMediaWithCanonicalAsset(value, context ?? void 0);
+	if (!canonical.storagePath || canonical.storagePath.length === 0) return {
+		kind: "missing-storage-path",
+		assetId: canonical.assetId,
+		identifier: canonical.identifier
+	};
+	const siteId = context?.siteId ?? getSiteId();
+	const bucket = canonical.storageBucket ?? "media";
+	const siteScopedPath = isSiteScopedDirectImageStoragePath(canonical.storagePath) ? canonical.storagePath : null;
+	let supabaseUrl;
+	try {
+		supabaseUrl = context?.supabaseUrl?.replace(/\/$/, "") ?? getSupabaseUrl();
+	} catch (error) {
+		return {
+			kind: "missing-supabase-url",
+			message: error instanceof Error ? error.message : "Supabase URL is not configured."
+		};
+	}
+	let directUrl;
+	if (siteScopedPath) directUrl = getDirectImageUrlForSiteScopedPath(supabaseUrl, siteScopedPath, bucket, transformOptions);
+	else {
+		const relativePath = parseRelativeStoragePath(canonical.storagePath);
+		if (!relativePath.ok) return {
+			kind: "invalid-storage-path",
+			storagePath: canonical.storagePath
+		};
+		if (!siteId) return {
+			kind: "missing-site-context",
+			storagePath: canonical.storagePath
+		};
+		directUrl = getDirectImageUrlForRelativePath(supabaseUrl, relativePath.value, siteId, bucket, transformOptions);
+	}
+	debugMediaNodeLog("resolve:direct-supabase", {
+		storagePath: canonical.storagePath,
+		siteId,
+		bucket,
+		directUrl,
+		transformOptions
+	});
+	return {
+		kind: "resolved",
+		url: directUrl
+	};
+}
+function getDirectImageUrlForValue(value, options, context) {
+	const result = resolveMediaStorageUrlResult(value, context, buildDirectTransformOptions(options));
+	return result.kind === "resolved" ? result.url : void 0;
+}
+function resolveStorageImageUrl(value, options, context, transformAspectRatio, resolved) {
+	const proxyUrl = getProxyImageUrl(value, options, transformAspectRatio, resolved);
+	if (proxyUrl) return proxyUrl;
+	const directUrl = getDirectImageUrlForValue(value, options, context);
+	if (directUrl) return directUrl;
+}
+/**
+* Common image size presets.
+* Use these for consistent sizing across the application.
+*/
+const ImagePresets = {
+	/** Small thumbnails (200px) - for block previews, lists */
+	thumbnail: {
+		width: 200,
+		quality: 80,
+		resize: "contain"
+	},
+	/** Card-sized images (600px) - for cards, grids */
+	card: {
+		width: 600,
+		quality: 80,
+		resize: "contain"
+	},
+	/** Hero images (1200px) - for above-fold content */
+	hero: {
+		width: 1200,
+		quality: 85,
+		resize: "contain"
+	},
+	/** Full-width images (1920px) - for backgrounds, large displays */
+	full: {
+		width: 1920,
+		quality: 85,
+		resize: "contain"
+	}
+};
+/**
+* Server-side: AsyncLocalStorage for request isolation.
+* Prevents race conditions when multiple requests are processed concurrently.
+*
+* Lazy initialization to avoid issues in environments that don't support async_hooks.
+*/
+let _serverStorage = null;
+let _serverStorageChecked = false;
+function getServerStorage() {
+	if (typeof window !== "undefined") return null;
+	if (_serverStorageChecked) return _serverStorage;
+	_serverStorageChecked = true;
+	try {
+		const globalWithNonWebpackRequire = globalThis;
+		const AsyncLocalStorage = (typeof globalWithNonWebpackRequire.__non_webpack_require__ === "function" ? globalWithNonWebpackRequire.__non_webpack_require__ : new Function("id", "return require(id)"))("async_hooks").AsyncLocalStorage;
+		if (AsyncLocalStorage) {
+			_serverStorage = new AsyncLocalStorage();
+			return _serverStorage;
+		}
+		return null;
+	} catch {
+		console.warn("[blocks] AsyncLocalStorage not available - using module-level state");
+		return null;
+	}
+}
+/**
+* Client-side context storage.
+* Safe because browsers are single-threaded per tab.
+*
+* IMPORTANT: This must be shared across bundles.
+* SDK preview mode can load multiple independently-bundled entrypoints
+* (e.g. `@riverbankcms/sdk/rendering` + `@riverbankcms/sdk/preview-next/client`),
+* which can otherwise each get their own module-scoped singleton.
+*/
+const RB_MEDIA_CONTEXT_KEY = Symbol.for("riverbankcms.blocks.mediaContext");
+function getClientContextStore() {
+	const g = globalThis;
+	const existing = g[RB_MEDIA_CONTEXT_KEY];
+	if (existing && typeof existing === "object") return existing;
+	const next = {};
+	g[RB_MEDIA_CONTEXT_KEY] = next;
+	return next;
+}
+/**
+* Get the current media context.
+* Server-side: Uses AsyncLocalStorage for request isolation.
+* Client-side: Uses module-level state (safe in single-threaded browser).
+*/
+function getMediaContext() {
+	const storage = getServerStorage();
+	if (storage) return storage.getStore() ?? {};
+	return getClientContextStore();
+}
+function getCurrentResolveImageUrlContext() {
+	const context = getMediaContext();
+	if (!context.supabaseUrl && !context.siteId && !context.mediaAssetIndex) return;
+	return {
+		supabaseUrl: context.supabaseUrl,
+		siteId: context.siteId,
+		mediaAssetIndex: context.mediaAssetIndex
+	};
+}
+/**
+* Get the Supabase URL for constructing direct storage URLs.
+* Used for serving images directly from Supabase storage CDN.
+*
+* Resolution order:
+* 1. Context URL (set via runWithMediaContext or setContextSupabaseUrl)
+* 2. Environment variable NEXT_PUBLIC_SUPABASE_URL
+*
+* SDK sites receive the URL from the API, so they don't need the env var.
+* Dashboard and frontend apps use the env var.
+*/
+function getSupabaseUrl() {
+	const context = getMediaContext();
+	if (context.supabaseUrl) return context.supabaseUrl;
+	const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+	if (!url) throw new Error("NEXT_PUBLIC_SUPABASE_URL is not configured. Set it to your Supabase project URL (e.g., https://xxx.supabase.co)");
+	return url.replace(/\/$/, "");
+}
+function resolveDashboardOrigin(raw) {
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	if (!trimmed) return void 0;
+	const withoutApiSuffix = trimmed.replace(/\/+$/, "").replace(/\/api\/?$/, "");
+	const normalized = /^https?:\/\//i.test(withoutApiSuffix) ? withoutApiSuffix : `http://${withoutApiSuffix.replace(/^\/+/, "")}`;
+	try {
+		return new URL(normalized).origin;
+	} catch {
+		return;
+	}
+}
+function getImageProxyBasePath() {
+	const dashboardOrigin = resolveDashboardOrigin(process.env.NEXT_PUBLIC_DASHBOARD_URL);
+	if (!dashboardOrigin) return RELATIVE_IMG_PROXY_BASE_PATH;
+	return `${dashboardOrigin}${RELATIVE_IMG_PROXY_BASE_PATH}`;
+}
+/**
+* Get the site ID for constructing storage paths.
+* Required for relative path resolution.
+*/
+function getSiteId() {
+	return getMediaContext().siteId;
+}
+function getMediaAssetIndex(context) {
+	return context?.mediaAssetIndex ?? getMediaContext().mediaAssetIndex;
+}
+function resolveCanonicalMediaAsset(value, context) {
+	const index = getMediaAssetIndex(context);
+	if (!index) return void 0;
+	if (value.assetId) {
+		const hit = index.byId.get(value.assetId);
+		if (hit) return hit;
+	}
+	const identifier = typeof value.identifier === "string" ? value.identifier.trim() : "";
+	if (identifier) {
+		const hit = index.byIdentifier.get(identifier);
+		if (hit) return hit;
+	}
+}
+function resolveMediaWithCanonicalAsset(value, context) {
+	const asset = resolveCanonicalMediaAsset(value, context);
+	if (!asset) return value;
+	return attachRenderableMediaAssetFields(value, asset);
+}
+const debugMediaNodeLog = (...args) => {
+	if (typeof window === "undefined") return;
+	if (Reflect.get(window, "__DEBUG_MEDIA_NODE__") === true) console.log("[MediaNode]", ...args);
+};
+function resolveTargetAspectRatio(size) {
+	if ("original" in size) return void 0;
+	if ("width" in size && "height" in size && typeof size.width === "number" && typeof size.height === "number") return size.width / size.height;
+}
+function resolveImageUrlWithContext(value, options, context, transformAspectRatio) {
+	const result = resolveImageUrlWithContextResult(value, options, context, transformAspectRatio);
+	warnForMediaUrlResolution(result);
+	return result.kind === "resolved" ? result.url : void 0;
+}
+function resolveImageUrlWithContextResult(value, options, context, transformAspectRatio) {
+	if (value.type !== "image") return {
+		kind: "unsupported-media-type",
+		mediaType: value.type
+	};
+	const url = resolveImageUrlWithContextInternal(value, options, context ?? void 0, transformAspectRatio);
+	if (url) return {
+		kind: "resolved",
+		url
+	};
+	const canonical = resolveMediaWithCanonicalAsset(value, context ?? void 0);
+	if (canonical.storagePath && canonical.storagePath.length > 0) return resolveMediaStorageUrlResult(canonical, context, buildDirectTransformOptions(options));
+	return {
+		kind: "missing-image-url",
+		assetId: canonical.assetId,
+		identifier: canonical.identifier
+	};
+}
+function resolveImageUrlWithContextInternal(value, options, context, transformAspectRatio, resolved) {
+	if (value.type !== "image") return void 0;
+	const canonical = resolveMediaWithCanonicalAsset(value, context);
+	debugMediaNodeLog("resolveImageUrl input", {
+		assetId: canonical.assetId,
+		storagePath: canonical.storagePath,
+		src: canonical.src,
+		type: canonical.type,
+		options
+	});
+	if (canonical.storagePath && canonical.storagePath.length > 0) {
+		const resolvedStorageUrl = resolveStorageImageUrl(canonical, options, context, transformAspectRatio, resolved);
+		if (resolvedStorageUrl) return resolvedStorageUrl;
+	}
+	if (typeof canonical.src === "string" && canonical.src.length > 0) {
+		debugMediaNodeLog("resolve:explicit-src", { src: canonical.src });
+		return canonical.src;
+	}
+	const legacyUrl = typeof canonical === "object" && canonical !== null ? Reflect.get(canonical, "url") : void 0;
+	debugMediaNodeLog("resolve:fallback-url", { fallbackUrl: typeof legacyUrl === "string" ? legacyUrl : null });
+	return typeof legacyUrl === "string" ? legacyUrl : void 0;
+}
+//#endregion
+//#region ../blocks/src/primitives/content/components/RichText.tsx
+function parseDimension(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.round(value);
+	if (typeof value === "string" && value.trim().length > 0) {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed > 0) return Math.round(parsed);
+	}
 }
-function FieldValidationMessage({ id, children, className, live = "assertive" }) {
-	return /* @__PURE__ */ jsx("p", {
-		id,
-		className,
-		"data-field-validation-message": true,
-		"data-field-validation-tone": "error",
-		role: "alert",
-		"aria-live": live === "off" ? void 0 : live,
-		children
+function normalizeRel(target, rel) {
+	const normalizedRel = rel?.trim();
+	if (target !== "_blank") return normalizedRel && normalizedRel.length > 0 ? normalizedRel : void 0;
+	const tokens = new Set((normalizedRel ?? "").split(/\s+/).map((token) => token.trim().toLowerCase()).filter(Boolean));
+	tokens.add("noopener");
+	tokens.add("noreferrer");
+	return Array.from(tokens).join(" ");
+}
+function renderMarks(text, marks, key, linkTarget) {
+	if (!marks || marks.length === 0) return text;
+	return marks.reduce((acc, mark) => {
+		switch (mark.type) {
+			case "bold":
+			case "strong": return /* @__PURE__ */ jsx("strong", { children: acc }, `${key}-b`);
+			case "italic":
+			case "em": return /* @__PURE__ */ jsx("em", { children: acc }, `${key}-i`);
+			case "link": {
+				if (typeof acc === "string" && acc.length === 0) return acc;
+				const attrs = mark.attrs ?? {};
+				const href = sanitizeHref(attrs.href);
+				if (!href) return acc;
+				const storedTarget = typeof attrs.target === "string" && attrs.target.trim().length > 0 ? attrs.target.trim() : void 0;
+				const target = linkTarget === "new-tab" ? "_blank" : storedTarget;
+				return /* @__PURE__ */ jsx("a", {
+					href,
+					target,
+					rel: normalizeRel(target, typeof attrs.rel === "string" ? attrs.rel : void 0),
+					children: acc
+				}, `${key}-l`);
+			}
+			default: return acc;
+		}
+	}, text);
+}
+function renderDoc(node, key, imageResolveContext, linkTarget) {
+	if (!node || !node.type) return null;
+	const children = node.content?.map((child, index) => renderDoc(child, `${key}-${index}`, imageResolveContext, linkTarget));
+	switch (node.type) {
+		case "doc": return /* @__PURE__ */ jsx(Fragment, { children });
+		case "paragraph":
+			if (!children && !node.text) return /* @__PURE__ */ jsx("p", {}, key);
+			return /* @__PURE__ */ jsx("p", { children: children ?? renderMarks(node.text ?? "", node.marks, key, linkTarget) }, key);
+		case "heading": {
+			const headingTag = `h${Math.min(Math.max(node.attrs?.level ?? 2, 1), 6)}`;
+			return React.createElement(headingTag, { key }, children);
+		}
+		case "bulletList": return /* @__PURE__ */ jsx("ul", { children }, key);
+		case "orderedList": return /* @__PURE__ */ jsx("ol", { children }, key);
+		case "listItem": return /* @__PURE__ */ jsx("li", { children }, key);
+		case "blockquote": return /* @__PURE__ */ jsx("blockquote", { children }, key);
+		case "horizontalRule": return /* @__PURE__ */ jsx("hr", {}, key);
+		case "hardBreak": return /* @__PURE__ */ jsx("br", {}, key);
+		case "image": {
+			const attrs = node.attrs ?? {};
+			const src = typeof attrs.src === "string" ? attrs.src.trim() : "";
+			const identifier = typeof attrs.identifier === "string" ? attrs.identifier.trim() : "";
+			const alt = typeof attrs.alt === "string" ? attrs.alt : "";
+			const title = typeof attrs.title === "string" && attrs.title.trim().length > 0 ? attrs.title : void 0;
+			const width = parseDimension(attrs.width);
+			const height = parseDimension(attrs.height);
+			const resolvedSrc = src || (identifier ? resolveImageUrlWithContext({
+				type: "image",
+				identifier
+			}, width ? {
+				width,
+				resize: "contain",
+				quality: 85
+			} : height ? {
+				height,
+				resize: "contain",
+				quality: 85
+			} : ImagePresets.full, imageResolveContext ?? void 0) ?? "" : "");
+			if (!resolvedSrc) return null;
+			return /* @__PURE__ */ jsx("img", {
+				src: resolvedSrc,
+				alt,
+				title,
+				width,
+				height,
+				loading: "lazy",
+				decoding: "async"
+			}, key);
+		}
+		case "text": return renderMarks(node.text ?? "", node.marks, key, linkTarget);
+		default: return null;
+	}
+}
+const DEFAULT_RICH_TEXT_CLASS = "rb-prose rb-max-w-none";
+function RichText({ as: Comp = "div", className, doc, path, linkTarget = "stored" }) {
+	const imageResolveContext = getCurrentResolveImageUrlContext() ?? null;
+	const content = doc ? renderDoc(doc, "doc", imageResolveContext, linkTarget) : null;
+	const dataAttributes = path ? { "data-builder-richtext": path } : void 0;
+	return /* @__PURE__ */ jsx(Comp, {
+		className: className?.trim() || DEFAULT_RICH_TEXT_CLASS,
+		...dataAttributes,
+		children: content
 	});
 }
 //#endregion
+//#region ../blocks/src/system/runtime/shared/components/BookingConsentAgreement.tsx
+function BookingConsentAgreement({ agreement, showTitle = true, title, titleId }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [showTitle ? /* @__PURE__ */ jsxs("div", {
+		id: titleId,
+		className: "form-label",
+		children: [title, /* @__PURE__ */ jsx("span", {
+			className: "required-marker",
+			children: "*"
+		})]
+	}) : null, /* @__PURE__ */ jsx("div", {
+		role: "group",
+		"aria-label": showTitle ? void 0 : title,
+		"aria-labelledby": showTitle ? titleId : void 0,
+		children: /* @__PURE__ */ jsx(RichText, {
+			doc: agreement,
+			linkTarget: "new-tab",
+			className: "rb-prose rb-max-w-none"
+		})
+	})] });
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.default-ui.tsx
 function optionCardClassName(isSelected) {
 	return `rb-option-card${isSelected ? " rb-option-card--selected" : ""}`;
@@ -12785,7 +13762,11 @@ function DefaultDynamicField({ booking, field }) {
 	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-space-y-2",
 		children: [
-			/* @__PURE__ */ jsxs("label", {
+			field.field.type === "booking_requirement_consent" ? /* @__PURE__ */ jsx(BookingConsentAgreement, {
+				agreement: field.field.agreement,
+				title: field.label,
+				titleId: field.labelId
+			}) : /* @__PURE__ */ jsxs("label", {
 				id: field.labelId,
 				htmlFor: field.inputId,
 				className: "form-label",
@@ -12830,7 +13811,7 @@ function DefaultFieldInput({ describedBy, error, errorId, field, onBlur, onChang
 		required: field.required,
 		...validationProps
 	};
-	switch (field.type) {
+	switch (field.field.type) {
 		case "textarea": return /* @__PURE__ */ jsx("textarea", {
 			...commonProps,
 			value: strValue,
@@ -12944,7 +13925,7 @@ function DefaultFieldInput({ describedBy, error, errorId, field, onBlur, onChang
 				className: "form-checkbox rb-mt-0.5"
 			}), /* @__PURE__ */ jsx("span", {
 				className: "rb-caption",
-				children: field.field.placeholder || field.label
+				children: field.field.checkboxLabel
 			})]
 		});
 		case "number": return /* @__PURE__ */ jsx("input", {
@@ -13013,10 +13994,10 @@ function DefaultBookingDiscount({ booking }) {
 			children: /* @__PURE__ */ jsxs("p", {
 				className: "ab-text",
 				children: [
-					"Discount available: ",
-					booking.discount.autoAppliedDiscount.publicLabel,
+					"Discount available:",
 					" ",
-					"will apply automatically at checkout."
+					booking.discount.autoAppliedDiscount.publicLabel,
+					" will apply automatically at checkout."
 				]
 			})
 		}) : null]
@@ -13601,11 +14582,21 @@ function readAmount(value) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/validation.ts
-function validateFormData(formData) {
+function createInitialRegistrationFormData() {
+	return {
+		name: "",
+		email: "",
+		phone: "",
+		notes: "",
+		consentAccepted: false
+	};
+}
+function validateFormData(formData, requiresConsent = false) {
 	const errors = {};
 	if (!formData.name.trim()) errors.name = "Name is required";
 	if (!formData.email.trim()) errors.email = "Email is required";
 	else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) errors.email = "Invalid email address";
+	if (requiresConsent && formData.consentAccepted !== true) errors.consentAccepted = "Please read and accept the agreement before continuing.";
 	return errors;
 }
 /**
@@ -13764,6 +14755,15 @@ function existingRegistrationLookupReducer(state, action) {
 * Custom hooks for portal authentication and eligibility checking.
 * Extracted from the main EventRegistrationClient for better separation of concerns.
 */
+function scopePortalCreditStateToSubject(state, subjectEmail) {
+	if (!subjectEmail) return { kind: "not_authenticated" };
+	if (state.kind === "not_authenticated") return state;
+	const normalizedSubject = subjectEmail.trim().toLowerCase();
+	return state.subjectEmail === normalizedSubject ? state : {
+		kind: "loading",
+		subjectEmail: normalizedSubject
+	};
+}
 const eventRegistrationHooksDeps = { useBlockApi };
 /**
 * Hook for managing portal authentication state.
@@ -13778,27 +14778,54 @@ function usePortalAuthWithDeps(deps) {
 	const api = deps.useBlockApi();
 	const [authState, setAuthState] = useState("checking");
 	const [profile, setProfile] = useState(null);
+	const [creditState, setCreditState] = useState({ kind: "not_authenticated" });
 	useEffect(() => {
 		let cancelled = false;
 		async function checkPortalAuth() {
 			if ((api.config.authOverrides?.portal ?? api.config.auth).type !== "bearer") {
 				setAuthState("unauthenticated");
+				setProfile(null);
+				setCreditState({ kind: "not_authenticated" });
 				return;
 			}
 			setAuthState("checking");
+			setProfile(null);
+			setCreditState({ kind: "not_authenticated" });
 			try {
 				const me = await api.getPortalProfile();
 				if (cancelled) return;
-				setAuthState("authenticated");
-				setProfile({
+				const nextProfile = {
 					email: me.profile.email,
 					name: me.profile.name,
 					phone: me.profile.phone || ""
+				};
+				const subjectEmail = nextProfile.email.trim().toLowerCase();
+				setProfile(nextProfile);
+				setCreditState({
+					kind: "loading",
+					subjectEmail
 				});
+				setAuthState("authenticated");
+				try {
+					const credit = await api.getPortalCredit();
+					if (cancelled) return;
+					setCreditState({
+						kind: "loaded",
+						subjectEmail,
+						credit
+					});
+				} catch {
+					if (cancelled) return;
+					setCreditState({
+						kind: "unavailable",
+						subjectEmail
+					});
+				}
 			} catch {
 				if (cancelled) return;
 				setAuthState("unauthenticated");
 				setProfile(null);
+				setCreditState({ kind: "not_authenticated" });
 			}
 		}
 		checkPortalAuth();
@@ -13818,6 +14845,7 @@ function usePortalAuthWithDeps(deps) {
 		isAuthenticated: authState === "authenticated",
 		isChecking: authState === "checking",
 		profile,
+		creditState: scopePortalCreditStateToSubject(creditState, authState === "authenticated" ? profile?.email ?? null : null),
 		logout
 	};
 }
@@ -14058,9 +15086,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;
@@ -14487,6 +15520,7 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 				name: options.formData.name.trim(),
 				phone: options.formData.phone.trim() || void 0,
 				notes: options.formData.notes.trim() || void 0,
+				consentAccepted: options.formData.consentAccepted,
 				altchaSolution: options.altchaSolution,
 				paymentMethod: method,
 				customerPassId: method === "pass" ? passId : void 0,
@@ -14704,88 +15738,171 @@ function requiresPaymentStep(params) {
 	return !isEntitlementSelection(params.paymentSelection);
 }
 //#endregion
-//#region ../blocks/src/system/manifest/richTextSchema.ts
-/**
-* Shared Rich Text Schema
-*
-* This module provides a single source of truth for TipTap rich text validation
-* across both the block-form editor and the block rendering system.
-*
-* Rich-text fields use one canonical root shape:
-* `{ type: 'doc', content: [...] }`.
-*/
-/**
-* TipTap document node schema (recursive structure)
-*
-* Supports the full TipTap document structure including:
-* - type: Node type (e.g., 'doc', 'paragraph', 'text')
-* - content: Nested array of child nodes
-* - text: Text content for text nodes
-* - attrs: Node attributes (e.g., alignment, color)
-* - marks: Text formatting marks (e.g., bold, italic)
-*/
-const TipTapMarkSchema = z.object({
-	type: z.string().min(1),
-	attrs: z.record(z.string(), z.unknown()).optional()
-}).strict();
-const TipTapNodeSchema = z.lazy(() => z.object({
-	type: z.string().min(1),
-	content: z.array(TipTapNodeSchema).optional(),
-	text: z.string().optional(),
-	attrs: z.record(z.string(), z.unknown()).optional(),
-	marks: z.array(TipTapMarkSchema).optional()
-}).strict().superRefine((node, ctx) => {
-	if (node.type === "doc") ctx.addIssue({
-		code: "custom",
-		path: ["type"],
-		message: "Document nodes are only valid at the rich-text root"
+//#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);
 	});
-	if (node.type === "text") {
-		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
-			code: "custom",
-			path: ["text"],
-			message: "Text nodes require a non-empty text value"
-		});
-		if (node.content !== void 0) ctx.addIssue({
-			code: "custom",
-			path: ["content"],
-			message: "Text nodes cannot contain child nodes"
-		});
-		return;
+}
+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);
 	}
-	if (node.text !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["text"],
-		message: "Only text nodes can contain a text value"
-	});
-}));
-/**
-* Canonical schema for a TipTap rich-text document root.
-*
-* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
-* `content` is required (possibly empty). This is the shape every producer
-* (dummy content, editor output, migrations) must emit, and the shape every
-* non-legacy consumer can rely on.
-*
-*/
-const RichTextDocSchema = z.object({
-	type: z.literal("doc"),
-	content: z.array(TipTapNodeSchema)
-}).strict();
+}
+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/courses/shared/schemas.ts
-/**
-* Zod schema for course venue data
-*/
-const courseVenueSchema = z.object({
+//#region ../blocks/src/system/blocks/events/whole-series/schemas.ts
+const wholeSeriesVenueSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	address: z.string().nullable()
 });
-/**
-* Zod schema for course session (occurrence) data
-*/
-const courseSessionSchema = z.object({
+const wholeSeriesSessionSchema = z.object({
 	id: z.string(),
 	startsAt: z.string(),
 	endsAt: z.string(),
@@ -14793,14 +15910,14 @@ const courseSessionSchema = z.object({
 	capacityOverride: z.number().nullable().optional(),
 	overrides: z.record(z.string(), z.unknown()).nullable().optional()
 });
-const courseTeamMemberSummarySchema = z.object({
+const wholeSeriesTeamMemberSummarySchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	roleLabel: z.string().nullable(),
 	summary: z.string().nullable(),
 	profilePath: z.string().nullable()
 });
-const coursePricingOptionSchema = z.object({
+const wholeSeriesPricingOptionSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	description: z.string().nullable(),
@@ -14816,7 +15933,7 @@ const coursePricingOptionSchema = z.object({
 		"both"
 	]).nullable().optional()
 });
-const coursePricingSchema = z.object({
+const wholeSeriesPricingSchema = z.object({
 	bookingRequirement: z.enum(["none", "required"]),
 	pricingStrategy: z.enum([
 		"free",
@@ -14830,22 +15947,20 @@ 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,
+	consent: blockBookingConsentSchema.nullable(),
 	enrollmentCapacity: z.number().nullable(),
 	acceptsMemberships: z.boolean(),
 	status: z.enum([
@@ -14856,8 +15971,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
@@ -15163,6 +16278,7 @@ const publicEventSchema = z.object({
 	timeZone: z.string(),
 	pricing: publicEventPricingSchema,
 	paymentTerms: blockBookingPaymentTermsSchema,
+	consent: blockBookingConsentSchema.nullable(),
 	accessRestriction: accessRestrictionSchema,
 	allowedCategoryIds: z.array(z.string()),
 	requireGuestDetails: z.boolean().optional(),
@@ -15170,7 +16286,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()
@@ -15681,12 +16797,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	const step = flowState.step;
 	const paymentSelection = flowState.paymentSelection;
 	const [selectedEvent, setSelectedEvent] = useState(preSelectedEvent ?? null);
-	const [formData, setFormData] = useState({
-		name: "",
-		email: "",
-		phone: "",
-		notes: ""
-	});
+	const [formData, setFormData] = useState(createInitialRegistrationFormData);
 	const [errors, setErrors] = useState({});
 	const [guests, setGuests] = useState([]);
 	const [guestErrors, setGuestErrors] = useState({});
@@ -15700,7 +16811,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);
@@ -15984,7 +17095,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		guests
 	]);
 	const validateForm = () => {
-		const newErrors = validateFormData(formData);
+		const newErrors = validateFormData(formData, Boolean(currentEvent?.consent));
 		setErrors(newErrors);
 		const newGuestErrors = {};
 		if (requireGuestDetails && guests.length > 0) {
@@ -16173,6 +17284,10 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	});
 	const handleEventSelect = (event) => {
 		setSelectedEvent(event);
+		setFormData((current) => ({
+			...current,
+			consentAccepted: false
+		}));
 		const slidingScale = getSlidingScaleForEvent(event);
 		setSelectedSlidingAmountInput(slidingScale?.suggestedAmount !== null && slidingScale?.suggestedAmount !== void 0 ? formatCentsAsCurrencyInput$1(slidingScale.suggestedAmount) : "");
 		setSelectedAttendanceMode((event.deliveryMode ?? "in_person") === "hybrid" ? null : (event.deliveryMode ?? "in_person") === "online" ? "online" : "in_person");
@@ -16253,6 +17368,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		setAltchaSolution,
 		portalAuthState,
 		portalProfile,
+		portalCreditState,
 		showMagicLinkModal,
 		setShowMagicLinkModal,
 		handleLogout,
@@ -16307,7 +17423,7 @@ function buildEventRegistrationPaymentOptionsViewModel(input) {
 	return {
 		mode: selection.mode,
 		sectionTitle: selection.sectionTitle,
-		options: selection.options.map((option) => toEventDirectPaymentOption(option, selection.mode))
+		options: selection.options.map((option, index) => toEventDirectPaymentOption(option, supportedOptions[index] ?? DEFAULT_EVENT_DIRECT_PAYMENT_OPTION, selection.mode, input.totalPriceCents))
 	};
 }
 function selectSupportedEventDirectPaymentOptions(paymentTerms) {
@@ -16317,17 +17433,24 @@ function selectSupportedEventDirectPaymentOptions(paymentTerms) {
 function isSupportedEventDirectPaymentOption(option) {
 	return option.kind === "upfront" || option.kind === "flexible_balance";
 }
-function toEventDirectPaymentOption(option, mode) {
+function toEventDirectPaymentOption(option, sourceOption, mode, totalCents) {
 	switch (option.kind) {
 		case "upfront": return {
 			...option,
 			kind: "upfront",
-			label: mode === "choice_required" ? "Pay in full now" : "Pay by card"
+			label: mode === "choice_required" ? "Pay in full now" : "Pay by card",
+			totalCents,
+			configuredPaymentDueNowCents: totalCents
 		};
 		case "flexible_balance": return {
 			...option,
 			kind: "flexible_balance",
-			label: "Pay deposit now"
+			label: "Pay deposit now",
+			totalCents,
+			configuredPaymentDueNowCents: sourceOption.kind === "flexible_balance" ? resolveFlexibleBalanceInitialPaymentCents({
+				totalAmountCents: totalCents,
+				config: sourceOption.config
+			}) : totalCents
 		};
 		case "deferred_manual":
 		case "instalment_plan": throw new Error(`Unsupported event registration payment option: ${option.kind}`);
@@ -16660,13 +17783,13 @@ function resolveHeadlessDirectPaymentOptions(wizard) {
 	}).options;
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/utils.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/utils.ts
 /**
 * Anchor ID for the registration block, used for scroll targeting.
 */
-const COURSE_REGISTRATION_ANCHOR_ID = "course-registration";
+const WHOLE_SERIES_REGISTRATION_ANCHOR_ID = "event-registration";
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/pricing.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/pricing.ts
 function parseCurrencyInputToCents(value) {
 	const trimmed = value.trim();
 	if (!trimmed) return null;
@@ -16678,31 +17801,31 @@ function formatCentsAsCurrencyInput(amount) {
 	const major = amount / 100;
 	return Number.isInteger(major) ? String(major) : major.toFixed(2);
 }
-function getMissingCoursePricingSelectionMessage(pricing) {
+function getMissingWholeSeriesPricingSelectionMessage(pricing) {
 	if (pricing?.requiresSelection && !pricing.selectedOption) return pricing.slidingScale ? "Choose an amount to continue." : "Choose a pricing option to continue.";
 	const selectedAmount = pricing?.selectedSlidingAmount;
 	const scale = pricing?.slidingScale;
 	if (scale && selectedAmount !== null && selectedAmount !== void 0 && (selectedAmount < scale.minAmount || selectedAmount > scale.maxAmount)) return "Choose an amount within the sliding scale.";
 	return null;
 }
-function buildCoursePricingOptionPayload(pricing) {
+function buildWholeSeriesPricingOptionPayload(pricing) {
 	if (pricing?.selectedOption) return { pricingOptionId: pricing.selectedOption.id };
 	if (pricing?.slidingScale && pricing.selectedSlidingAmount !== null) return { selectedSlidingAmount: pricing.selectedSlidingAmount };
 	return {};
 }
-function defaultCoursePricingSelection(pricing, previousOptionId) {
+function defaultWholeSeriesPricingSelection(pricing, previousOptionId) {
 	return {
 		pricingOptionId: previousOptionId && pricing.selectableOptions.some((option) => option.id === previousOptionId) ? previousOptionId : pricing.selectedOption?.id ?? null,
 		slidingAmountInput: pricing.slidingScale?.suggestedAmount !== null && pricing.slidingScale?.suggestedAmount !== void 0 ? formatCentsAsCurrencyInput(pricing.slidingScale.suggestedAmount) : ""
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/wizardSteps.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wizardSteps.ts
 /**
 * Step labels for the wizard indicator
 */
 const STEP_LABELS = {
-	"select-course": "Course",
+	"select-run": "Run",
 	"enter-details": "Details",
 	"booking-mode": "Method",
 	"select-payment": "Payment",
@@ -16718,36 +17841,36 @@ const STEP_LABELS = {
 /**
 * Determine which wizard steps to show based on context and eligibility.
 *
-* @param hasPreSelectedCourse - Whether course is pre-selected (skips course selection)
-* @param requiresPayment - Whether the course requires payment
+* @param hasPreSelectedRun - Whether run is pre-selected (skips run selection)
+* @param requiresPayment - Whether the run requires payment
 * @param hasEligibleMemberships - Whether user has eligible memberships
 * @param bookingMode - Current booking mode selection
 * @param isMembershipFastTrack - Whether user qualifies for single-step membership flow
 * @returns Array of wizard steps to display
 */
-function getWizardStepsForContext(hasPreSelectedCourse, requiresPayment, hasEligibleMemberships, bookingMode, isMembershipFastTrack) {
-	if (isMembershipFastTrack) return hasPreSelectedCourse ? ["enter-details"] : ["select-course", "enter-details"];
-	if (!requiresPayment) return hasPreSelectedCourse ? ["enter-details"] : ["select-course", "enter-details"];
+function getWizardStepsForContext(hasPreSelectedRun, requiresPayment, hasEligibleMemberships, bookingMode, isMembershipFastTrack) {
+	if (isMembershipFastTrack) return hasPreSelectedRun ? ["enter-details"] : ["select-run", "enter-details"];
+	if (!requiresPayment) return hasPreSelectedRun ? ["enter-details"] : ["select-run", "enter-details"];
 	if (hasEligibleMemberships) {
 		const skipPayment = bookingMode === "membership";
-		if (hasPreSelectedCourse) return skipPayment ? ["enter-details", "booking-mode"] : [
+		if (hasPreSelectedRun) return skipPayment ? ["enter-details", "booking-mode"] : [
 			"enter-details",
 			"booking-mode",
 			"select-payment"
 		];
 		return skipPayment ? [
-			"select-course",
+			"select-run",
 			"enter-details",
 			"booking-mode"
 		] : [
-			"select-course",
+			"select-run",
 			"enter-details",
 			"booking-mode",
 			"select-payment"
 		];
 	}
-	return hasPreSelectedCourse ? ["enter-details", "select-payment"] : [
-		"select-course",
+	return hasPreSelectedRun ? ["enter-details", "select-payment"] : [
+		"select-run",
 		"enter-details",
 		"select-payment"
 	];
@@ -16759,21 +17882,21 @@ function getStepLabels(steps) {
 	return steps.map((step) => STEP_LABELS[step] ?? step);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/courseRegistrationViewState.ts
-function deriveCourseRegistrationViewState(input) {
-	const hasCoursePayment = resolveCoursePaymentRequirement(input.pricing);
-	const canUseMembership = hasCoursePayment && input.selectedCourse?.acceptsMemberships === true && input.portalAuthState === "authenticated" && input.eligibleMembershipCount > 0;
-	const hasPreSelectedCourse = input.scopedCourses.length === 1;
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wholeSeriesRegistrationViewState.ts
+function deriveWholeSeriesRegistrationViewState(input) {
+	const hasRunPayment = resolveWholeSeriesPaymentRequirement(input.pricing);
+	const canUseMembership = hasRunPayment && input.selectedRun?.acceptsMemberships === true && input.portalAuthState === "authenticated" && input.eligibleMembershipCount > 0;
+	const hasPreSelectedRun = input.scopedRuns.length === 1;
 	const fastTrack = canUseMembership && input.eligibleMembershipCount === 1 && input.bookingMode === "membership";
-	const wizardSteps = getWizardStepsForContext(hasPreSelectedCourse, hasCoursePayment, canUseMembership, input.bookingMode, fastTrack);
+	const wizardSteps = getWizardStepsForContext(hasPreSelectedRun, hasRunPayment, canUseMembership, input.bookingMode, fastTrack);
 	const showPortalAuthSidebar = shouldShowPortalAuthSidebar({
 		...input,
-		hasCoursePayment
+		hasRunPayment
 	});
 	return {
-		hasCoursePayment,
+		hasRunPayment,
 		canUseMembership,
-		hasPreSelectedCourse,
+		hasPreSelectedRun,
 		wizardSteps,
 		currentStepNumber: getStepNumber(input.step, wizardSteps),
 		totalSteps: wizardSteps.length,
@@ -16781,24 +17904,24 @@ function deriveCourseRegistrationViewState(input) {
 		showPortalAuthSidebar
 	};
 }
-function resolveCoursePaymentRequirement(pricing) {
+function resolveWholeSeriesPaymentRequirement(pricing) {
 	if (!pricing) return false;
 	return pricing.selectedOption ? pricing.selectedRequiresPayment : pricing.hasPaidSelection;
 }
 function shouldShowPortalAuthSidebar(input) {
 	if (input.portalAuthState !== "unauthenticated") return false;
 	if (input.step === "success" || input.step === "waitlist" || input.step === "error") return false;
-	return input.waitlistRequiresPortalLogin || input.hasCoursePayment && input.selectedCourse?.acceptsMemberships === true && input.step !== "select-course";
+	return input.waitlistRequiresPortalLogin || input.hasRunPayment && input.selectedRun?.acceptsMemberships === true && input.step !== "select-run";
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseEligibility.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesEligibility.ts
 function shouldFetchEligibility(input) {
-	if (!input.course || input.portalAuthState === "checking" || input.hasWaitlistClaimToken) return false;
-	const membershipCheck = input.portalAuthState === "authenticated" && input.hasPaidSelection && input.course.acceptsMemberships;
-	const capacityCheck = input.course.availableSpots !== null && input.course.availableSpots <= 0;
+	if (!input.run || input.portalAuthState === "checking" || input.hasWaitlistClaimToken) return false;
+	const membershipCheck = input.portalAuthState === "authenticated" && input.hasPaidSelection && input.run.acceptsMemberships;
+	const capacityCheck = input.run.availableSpots !== null && input.run.availableSpots <= 0;
 	return membershipCheck || capacityCheck;
 }
-function useCourseEligibility(input) {
+function useWholeSeriesEligibility(input) {
 	const [loading, setLoading] = useState(false);
 	const [error, setError] = useState(null);
 	const [eligibility, setEligibility] = useState(null);
@@ -16819,15 +17942,15 @@ function useCourseEligibility(input) {
 		setError(null);
 		setPaymentChoice("checkout");
 		const eligibilityInput = {
-			course: input.selectedCourse,
+			run: input.selectedRun,
 			hasPaidSelection: input.hasPaidSelection,
 			portalAuthState: input.portalAuthState,
 			hasWaitlistClaimToken: input.waitlistClaimToken !== null
 		};
 		if (!shouldFetchEligibility(eligibilityInput)) return;
-		const course = eligibilityInput.course;
+		const run = eligibilityInput.run;
 		setLoading(true);
-		input.api.checkWholeSeriesEligibility({ eventSeriesId: course.eventSeriesId }).then((result) => {
+		input.api.checkWholeSeriesEligibility({ eventSeriesId: run.eventSeriesId }).then((result) => {
 			if (cancelled) return;
 			const eligibleMemberships = result.eligibleMemberships ?? [];
 			setEligibility(result);
@@ -16848,13 +17971,13 @@ function useCourseEligibility(input) {
 		input.api,
 		input.hasPaidSelection,
 		input.portalAuthState,
-		input.selectedCourse,
+		input.selectedRun,
 		input.waitlistClaimToken
 	]);
 	return {
 		eligibilityLoading: loading,
 		eligibilityError: error,
-		courseEligibility: eligibility,
+		runEligibility: eligibility,
 		eligibleMemberships: memberships,
 		paymentChoice,
 		choosePaymentChoice,
@@ -16863,149 +17986,12 @@ function useCourseEligibility(input) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/blocks/courses/shared/pricing.ts
-function isSaleWindowOpen(option, now) {
-	if (!option.isActive) return false;
-	if (option.saleStartsAt && new Date(option.saleStartsAt) > now) return false;
-	if (option.saleEndsAt && new Date(option.saleEndsAt) < now) return false;
-	return true;
-}
-function toExactOrFreeDisplay(amount, currency) {
-	if (amount <= 0) return {
-		kind: "free",
-		currency
-	};
-	return {
-		kind: "exact",
-		amount,
-		currency
-	};
-}
-function getSelectableCoursePricingOptionsForNow(course, now) {
-	if (course.pricing.pricingStrategy !== "tiered") return [];
-	return [...course.pricing.options].filter((option) => isSaleWindowOpen(option, now)).sort((left, right) => {
-		if (left.sortOrder !== right.sortOrder) return left.sortOrder - right.sortOrder;
-		if (left.priceAmount !== right.priceAmount) return left.priceAmount - right.priceAmount;
-		return left.name.localeCompare(right.name);
-	});
-}
-function resolveCoursePricingState(course, selectedPricingOptionId, selectedSlidingAmountOrNowInput, nowInput = {}) {
-	const selectedSlidingAmount = typeof selectedSlidingAmountOrNowInput === "number" || selectedSlidingAmountOrNowInput === null ? selectedSlidingAmountOrNowInput : null;
-	const effectiveNowInput = typeof selectedSlidingAmountOrNowInput === "object" && selectedSlidingAmountOrNowInput !== null ? selectedSlidingAmountOrNowInput : nowInput;
-	const currency = course.pricing.currency;
-	switch (course.pricing.pricingStrategy) {
-		case "free": return {
-			currency,
-			display: {
-				kind: "free",
-				currency
-			},
-			selectableOptions: [],
-			requiresSelection: false,
-			selectedOption: null,
-			slidingScale: null,
-			selectedSlidingAmount: null,
-			selectedPriceAmount: 0,
-			selectedRequiresPayment: false,
-			hasPaidSelection: false,
-			hasFreeSelection: true
-		};
-		case "single": {
-			const amount = course.pricing.singlePriceAmount ?? 0;
-			return {
-				currency,
-				display: toExactOrFreeDisplay(amount, currency),
-				selectableOptions: [],
-				requiresSelection: false,
-				selectedOption: null,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: amount,
-				selectedRequiresPayment: amount > 0,
-				hasPaidSelection: amount > 0,
-				hasFreeSelection: amount <= 0
-			};
-		}
-		case "tiered": {
-			const selectableOptions = getSelectableCoursePricingOptionsForNow(course, resolvePlanningDateInput(effectiveNowInput));
-			const selectedOption = (selectedPricingOptionId ? selectableOptions.find((option) => option.id === selectedPricingOptionId) : null) ?? (selectableOptions.length === 1 ? selectableOptions[0] ?? null : null);
-			const lowestAmount = selectableOptions.reduce((lowest, option) => {
-				if (lowest === null || option.priceAmount < lowest) return option.priceAmount;
-				return lowest;
-			}, null);
-			return {
-				currency,
-				display: lowestAmount === null ? {
-					kind: "unavailable",
-					currency
-				} : selectableOptions.length > 1 && lowestAmount > 0 ? {
-					kind: "from",
-					amount: lowestAmount,
-					currency
-				} : toExactOrFreeDisplay(lowestAmount, currency),
-				selectableOptions,
-				requiresSelection: selectableOptions.length > 1,
-				selectedOption,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: selectedOption?.priceAmount ?? null,
-				selectedRequiresPayment: (selectedOption?.priceAmount ?? 0) > 0,
-				hasPaidSelection: selectableOptions.some((option) => option.priceAmount > 0),
-				hasFreeSelection: selectableOptions.some((option) => option.priceAmount === 0)
-			};
-		}
-		case "sliding_scale": {
-			const minAmount = course.pricing.slidingMinAmount ?? null;
-			const maxAmount = course.pricing.slidingMaxAmount ?? null;
-			if (minAmount === null || maxAmount === null || minAmount < 0 || maxAmount < minAmount) return {
-				currency,
-				display: {
-					kind: "unavailable",
-					currency
-				},
-				selectableOptions: [],
-				requiresSelection: true,
-				selectedOption: null,
-				slidingScale: null,
-				selectedSlidingAmount: null,
-				selectedPriceAmount: null,
-				selectedRequiresPayment: false,
-				hasPaidSelection: false,
-				hasFreeSelection: false
-			};
-			const normalizedSelectedAmount = typeof selectedSlidingAmount === "number" && Number.isFinite(selectedSlidingAmount) ? selectedSlidingAmount : null;
-			return {
-				currency,
-				display: {
-					kind: "range",
-					minAmount,
-					maxAmount,
-					currency
-				},
-				selectableOptions: [],
-				requiresSelection: normalizedSelectedAmount === null,
-				selectedOption: null,
-				slidingScale: {
-					minAmount,
-					maxAmount,
-					suggestedAmount: course.pricing.slidingSuggestedAmount ?? null
-				},
-				selectedSlidingAmount: normalizedSelectedAmount,
-				selectedPriceAmount: normalizedSelectedAmount,
-				selectedRequiresPayment: (normalizedSelectedAmount ?? 0) > 0,
-				hasPaidSelection: maxAmount > 0,
-				hasFreeSelection: minAmount === 0
-			};
-		}
-	}
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/course-page-surface-scope.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/wholeSeriesPageSurfaceScope.ts
 /**
-* Resolves native course-page ownership without falling back to entry or slug
+* Resolves native run-page ownership without falling back to entry or slug
 * coincidence when a page-surface subject is present but invalid.
 */
-function resolveCoursePageSurfaceScope(courses, subjectValue) {
+function resolveWholeSeriesPageSurfaceScope(runs, subjectValue) {
 	if (subjectValue === null || subjectValue === void 0) return { kind: "absent" };
 	const parsed = parseEventPageSurfaceSubject(subjectValue);
 	if (!parsed.ok) return {
@@ -17017,7 +18003,7 @@ function resolveCoursePageSurfaceScope(courses, subjectValue) {
 	return {
 		kind: "scoped",
 		subject: parsed.value,
-		courses: courses.filter((course) => allowedSeriesIds.has(course.eventSeriesId))
+		runs: runs.filter((run) => allowedSeriesIds.has(run.eventSeriesId))
 	};
 }
 function eventSeriesIdsForSubject(subject) {
@@ -17028,33 +18014,43 @@ function eventSeriesIdsForSubject(subject) {
 	}
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationSelection.ts
-function selectScopedCourses(props) {
-	const surfaceScope = resolveCoursePageSurfaceScope(props.courses ?? [], props.subject);
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationSelection.ts
+function selectScopedRuns(props) {
+	const surfaceScope = resolveWholeSeriesPageSurfaceScope(props.runs ?? [], props.subject);
 	if (surfaceScope.kind === "unsupported") return [];
-	if (surfaceScope.kind === "scoped") return surfaceScope.courses;
+	if (surfaceScope.kind === "scoped") return surfaceScope.runs;
 	return [];
 }
-function getCourseCheckoutSessionId() {
-	const fromSearch = new URLSearchParams(window.location.search).get("session_id");
+function getWholeSeriesCheckoutSessionId(location = window.location) {
+	const fromSearch = new URLSearchParams(location.search).get("session_id");
 	if (fromSearch) return fromSearch;
-	return window.location.hash.match(/[?&]session_id=([^&]+)/)?.[1] ?? null;
+	return location.hash.match(/[?&]session_id=([^&]+)/)?.[1] ?? null;
 }
-function initialStep(courses) {
-	if (new URLSearchParams(window.location.search).get("enrollment") === "success" && getCourseCheckoutSessionId()) return "verifying-payment";
-	return courses.length === 1 ? "enter-details" : "select-course";
+function initialStep(runs, location) {
+	if (new URLSearchParams(location.search).get("enrollment") === "success" && getWholeSeriesCheckoutSessionId(location)) return "verifying-payment";
+	return runs.length === 1 ? "enter-details" : "select-run";
 }
-function useCourseRegistrationSelection(props) {
-	const scopedCourses = useMemo(() => selectScopedCourses(props), [props.courses, props.subject]);
-	const [step, setStep] = useState(() => initialStep(scopedCourses));
-	const [selectedCourse, setSelectedCourse] = useState(scopedCourses.length === 1 ? scopedCourses[0] ?? null : null);
+function useWholeSeriesRegistrationSelection(props, location = window.location) {
+	const scopeSnapshot = JSON.stringify({
+		runs: props.runs ?? [],
+		subject: props.subject ?? null
+	});
+	const stableScope = useRef(null);
+	if (stableScope.current?.snapshot !== scopeSnapshot) stableScope.current = {
+		snapshot: scopeSnapshot,
+		runs: selectScopedRuns(props)
+	};
+	const scopedRuns = stableScope.current.runs;
+	const [step, setStep] = useState(() => initialStep(scopedRuns, location));
+	const [selectedRunId, setSelectedRunId] = useState(scopedRuns.length === 1 ? scopedRuns[0]?.eventSeriesId ?? null : null);
+	const selectedRun = useMemo(() => scopedRuns.find((run) => run.eventSeriesId === selectedRunId) ?? (scopedRuns.length === 1 ? scopedRuns[0] ?? null : null), [scopedRuns, selectedRunId]);
 	const [selectedPricingOptionId, setSelectedPricingOptionId] = useState(null);
 	const [selectedSlidingAmountInput, setSelectedSlidingAmountInput] = useState("");
 	const goToStep = useCallback((nextStep) => {
 		setStep(nextStep);
 	}, []);
-	const chooseCourse = useCallback((course) => {
-		setSelectedCourse(course);
+	const chooseRun = useCallback((run) => {
+		setSelectedRunId(run.eventSeriesId);
 	}, []);
 	const choosePricingOption = useCallback((pricingOptionId) => {
 		setSelectedPricingOptionId(pricingOptionId);
@@ -17062,36 +18058,36 @@ function useCourseRegistrationSelection(props) {
 	const changeSlidingAmount = useCallback((amount) => {
 		setSelectedSlidingAmountInput(amount);
 	}, []);
-	const selectedCoursePricing = useMemo(() => selectedCourse ? resolveCoursePricingState(selectedCourse, selectedPricingOptionId, parseCurrencyInputToCents(selectedSlidingAmountInput)) : null, [
-		selectedCourse,
+	const selectedRunPricing = useMemo(() => selectedRun ? resolveWholeSeriesPricingState(selectedRun, selectedPricingOptionId, parseCurrencyInputToCents(selectedSlidingAmountInput)) : null, [
+		selectedRun,
 		selectedPricingOptionId,
 		selectedSlidingAmountInput
 	]);
 	useEffect(() => {
-		if (!selectedCourse) {
+		if (!selectedRun) {
 			setSelectedPricingOptionId(null);
 			setSelectedSlidingAmountInput("");
 			return;
 		}
-		const selection = defaultCoursePricingSelection(resolveCoursePricingState(selectedCourse, null), selectedPricingOptionId);
+		const selection = defaultWholeSeriesPricingSelection(resolveWholeSeriesPricingState(selectedRun, null), selectedPricingOptionId);
 		setSelectedPricingOptionId(selection.pricingOptionId);
 		setSelectedSlidingAmountInput(selection.slidingAmountInput);
-	}, [selectedCourse]);
+	}, [selectedRun?.eventSeriesId]);
 	return {
-		scopedCourses,
+		scopedRuns,
 		step,
 		goToStep,
-		selectedCourse,
-		chooseCourse,
+		selectedRun,
+		chooseRun,
 		selectedPricingOptionId,
 		choosePricingOption,
 		selectedSlidingAmountInput,
 		changeSlidingAmount,
-		selectedCoursePricing
+		selectedRunPricing
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCoursePaymentVerification.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesPaymentVerification.ts
 function applyTerminalStatus(status, setters) {
 	if (status === "enrolled" || status === "completed") {
 		setters.setEnrollmentResult({
@@ -17113,7 +18109,7 @@ function applyTerminalStatus(status, setters) {
 	setters.setStep("error");
 	return true;
 }
-async function pollCourseRegistrationStatus(api, sessionId, setters, isCancelled) {
+async function pollWholeSeriesRegistrationStatus(api, sessionId, setters, isCancelled) {
 	const startedAt = Date.now();
 	while (!isCancelled()) {
 		try {
@@ -17134,21 +18130,21 @@ async function pollCourseRegistrationStatus(api, sessionId, setters, isCancelled
 		await new Promise((resolve) => setTimeout(resolve, 1500));
 	}
 }
-function useCoursePaymentVerification(api, setters) {
+function useWholeSeriesPaymentVerification(api, setters, anchorId = WHOLE_SERIES_REGISTRATION_ANCHOR_ID, location = window.location) {
 	useEffect(() => {
 		let cancelled = false;
-		const enrollment = new URLSearchParams(window.location.search).get("enrollment");
-		const sessionId = getCourseCheckoutSessionId();
+		const enrollment = new URLSearchParams(location.search).get("enrollment");
+		const sessionId = getWholeSeriesCheckoutSessionId(location);
 		if (enrollment === "cancelled") {
-			scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
+			scrollToBlock(anchorId);
 			setters.setErrorMessage("Payment was cancelled. You can try again.");
 			setters.setStep("error");
 			return;
 		}
 		if (enrollment !== "success" || !sessionId) return;
-		scrollToBlock(COURSE_REGISTRATION_ANCHOR_ID);
+		scrollToBlock(anchorId);
 		setters.setStep("verifying-payment");
-		pollCourseRegistrationStatus(api, sessionId, setters, () => cancelled);
+		pollWholeSeriesRegistrationStatus(api, sessionId, setters, () => cancelled);
 		return () => {
 			cancelled = true;
 		};
@@ -17156,11 +18152,13 @@ function useCoursePaymentVerification(api, setters) {
 		api,
 		setters.setEnrollmentResult,
 		setters.setErrorMessage,
-		setters.setStep
+		setters.setStep,
+		anchorId,
+		location
 	]);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationActions.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationActions.ts
 function blocked(message, setters) {
 	setters.setErrorMessage(message);
 	setters.setStep("error");
@@ -17170,16 +18168,17 @@ 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);
+	if (state.selectedRun.consent && state.formData.consentAccepted !== true) errors.consentAccepted = "Please read and accept the agreement before continuing.";
 	setters.setErrors(errors);
 	if (Object.keys(errors).length > 0) return { kind: "validation-failed" };
-	const pricingMessage = getMissingCoursePricingSelectionMessage(state.pricing);
+	const pricingMessage = getMissingWholeSeriesPricingSelectionMessage(state.pricing);
 	if (pricingMessage) return blocked(pricingMessage, setters);
-	if (!state.hasClaim && state.eligibility?.isFull && !state.eligibility.canJoinWaitlist) return blocked(state.eligibility.reason ?? "This course is fully booked.", setters);
+	if (!state.hasClaim && state.eligibility?.isFull && !state.eligibility.canJoinWaitlist) return blocked(state.eligibility.reason ?? "This run is fully booked.", setters);
 	if (isSpamProtectionEnabled() && !state.altchaSolution) return blocked("Please complete the verification check.", setters);
 	return null;
 }
@@ -17192,12 +18191,13 @@ 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,
 		formData: { notes: state.formData.notes.trim() || void 0 },
+		consentAccepted: state.formData.consentAccepted,
 		altchaSolution: state.altchaSolution,
 		claimToken: state.claimToken ?? void 0
 	};
@@ -17226,7 +18226,7 @@ async function enroll(state, setters, payment) {
 async function checkout(state, setters) {
 	setters.setStep("submitting");
 	try {
-		const urls = buildCheckoutReturnUrls("enrollment", COURSE_REGISTRATION_ANCHOR_ID);
+		const urls = buildCheckoutReturnUrls("enrollment", state.options.anchorId ?? "event-registration");
 		const result = await state.api.createWholeSeriesCheckout({
 			...registrantPayload(state),
 			discountCode: state.discountCode.trim() || void 0,
@@ -17261,10 +18261,10 @@ async function checkout(state, setters) {
 }
 async function submitDetails(state, setters) {
 	const invalid = validateSubmission(state, setters);
-	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (invalid || !state.selectedRun) return invalid ?? { kind: "validation-failed" };
 	if (state.eligibility?.canJoinWaitlist) return enroll(state, setters, { method: "free" });
 	const requiresPayment = state.pricing?.selectedRequiresPayment ?? false;
-	const canUseMembership = requiresPayment && state.selectedCourse.acceptsMemberships && state.portalAuthState === "authenticated" && state.eligibleMemberships.length > 0;
+	const canUseMembership = requiresPayment && state.selectedRun.acceptsMemberships && state.portalAuthState === "authenticated" && state.eligibleMemberships.length > 0;
 	if (requiresPayment && canUseMembership) {
 		setters.setStep("select-payment");
 		return { kind: "state-updated" };
@@ -17274,7 +18274,7 @@ async function submitDetails(state, setters) {
 }
 async function continuePayment(state, setters) {
 	const invalid = validateSubmission(state, setters);
-	if (invalid || !state.selectedCourse) return invalid ?? { kind: "validation-failed" };
+	if (invalid || !state.selectedRun) return invalid ?? { kind: "validation-failed" };
 	if (!state.pricing?.selectedRequiresPayment) {
 		setters.setStep("enter-details");
 		return { kind: "state-updated" };
@@ -17289,7 +18289,7 @@ async function continuePayment(state, setters) {
 	}
 	return checkout(selectedState, setters);
 }
-function useCourseRegistrationActions(state, setStep) {
+function useWholeSeriesRegistrationActions(state, setStep) {
 	const [errors, setErrors] = useState({});
 	const [enrollmentResult, setEnrollmentResult] = useState(null);
 	const [errorMessage, setErrorMessage] = useState("");
@@ -17316,14 +18316,15 @@ 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: ""
+	notes: "",
+	consentAccepted: false
 };
-function useCourseRegistrationPortal(api) {
+function useWholeSeriesRegistrationPortal(api) {
 	const [formData, setFormData] = useState(EMPTY_FORM);
 	const [portalAuthState, setPortalAuthState] = useState("checking");
 	const updateFormData = useCallback((updater) => {
@@ -17359,19 +18360,19 @@ function useCourseRegistrationPortal(api) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseWaitlistSelection.ts
-function useCourseWaitlistSelection(input) {
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesWaitlistSelection.ts
+function useWholeSeriesWaitlistSelection(input) {
 	useEffect(() => {
 		const claim = input.waitlistClaim.claim;
 		if (!claim || claim.subject.kind !== "whole_series") return;
 		const eventSeriesId = claim.subject.eventSeriesId;
-		const course = input.scopedCourses.find((candidate) => candidate.eventSeriesId === eventSeriesId);
-		if (!course) {
-			input.reportError("This waitlist claim is for a different course.");
+		const run = input.scopedRuns.find((candidate) => candidate.eventSeriesId === eventSeriesId);
+		if (!run) {
+			input.reportError("This waitlist claim is for a different run.");
 			input.goToStep("error");
 			return;
 		}
-		input.chooseCourse(course);
+		input.chooseRun(run);
 		input.updateFormData((current) => ({
 			...current,
 			email: claim.prefill.email,
@@ -17379,12 +18380,12 @@ function useCourseWaitlistSelection(input) {
 			phone: claim.prefill.phone ?? "",
 			notes: claim.prefill.notes ?? ""
 		}));
-		if (input.step === "select-course") input.goToStep("enter-details");
+		if (input.step === "select-run") input.goToStep("enter-details");
 	}, [
-		input.chooseCourse,
+		input.chooseRun,
 		input.goToStep,
 		input.reportError,
-		input.scopedCourses,
+		input.scopedRuns,
 		input.step,
 		input.updateFormData,
 		input.waitlistClaim.claim
@@ -17401,40 +18402,48 @@ function useCourseWaitlistSelection(input) {
 	]);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.ts
-function useCourseRegistrationWizard(props, options = {}) {
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/useWholeSeriesRegistrationWizard.ts
+function useWholeSeriesRegistrationWizard(props, options = {}) {
+	return useWholeSeriesRegistrationWizardWithDeps(wholeSeriesRegistrationWizardDeps, props, options);
+}
+const wholeSeriesRegistrationWizardDeps = { readLocation: () => ({
+	search: window.location.search,
+	hash: window.location.hash
+}) };
+function useWholeSeriesRegistrationWizardWithDeps(deps, props, options = {}) {
 	const api = useBlockApi();
-	const selection = useCourseRegistrationSelection(props);
-	const portal = useCourseRegistrationPortal(api);
-	const waitlistClaim = useWaitlistClaim();
+	const [location] = useState(deps.readLocation);
+	const selection = useWholeSeriesRegistrationSelection(props, location);
+	const portal = useWholeSeriesRegistrationPortal(api);
+	const waitlistClaim = useWaitlistClaimForToken(new URLSearchParams(location.search).get("waitlist_claim")?.trim() || null);
 	const [bookingMode, setBookingMode] = useState(null);
 	const [altchaSolution, setAltchaSolution] = useState(null);
-	const eligibility = useCourseEligibility({
+	const eligibility = useWholeSeriesEligibility({
 		api,
-		selectedCourse: selection.selectedCourse,
-		hasPaidSelection: selection.selectedCoursePricing?.hasPaidSelection ?? false,
+		selectedRun: selection.selectedRun,
+		hasPaidSelection: selection.selectedRunPricing?.hasPaidSelection ?? false,
 		portalAuthState: portal.portalAuthState,
 		waitlistClaimToken: waitlistClaim.token
 	});
 	const discountUi = useDiscountCodeUi({
 		api,
-		discountContext: useMemo(() => selection.selectedCourse && selection.selectedCoursePricing?.selectedRequiresPayment && eligibility.paymentChoice === "checkout" ? {
+		discountContext: useMemo(() => selection.selectedRun && selection.selectedRunPricing?.selectedRequiresPayment && eligibility.paymentChoice === "checkout" ? {
 			type: "whole_series",
-			eventSeriesId: selection.selectedCourse.eventSeriesId
+			eventSeriesId: selection.selectedRun.eventSeriesId
 		} : null, [
 			eligibility.paymentChoice,
-			selection.selectedCourse,
-			selection.selectedCoursePricing?.selectedRequiresPayment
+			selection.selectedRun,
+			selection.selectedRunPricing?.selectedRequiresPayment
 		]),
-		subtotalCents: selection.selectedCoursePricing?.selectedPriceAmount ?? void 0
+		subtotalCents: selection.selectedRunPricing?.selectedPriceAmount ?? void 0
 	});
-	const actions = useCourseRegistrationActions({
+	const actions = useWholeSeriesRegistrationActions({
 		api,
-		selectedCourse: selection.selectedCourse,
-		pricing: selection.selectedCoursePricing,
+		selectedRun: selection.selectedRun,
+		pricing: selection.selectedRunPricing,
 		formData: portal.formData,
 		portalAuthState: portal.portalAuthState,
-		eligibility: eligibility.courseEligibility,
+		eligibility: eligibility.runEligibility,
 		eligibleMemberships: eligibility.eligibleMemberships,
 		paymentChoice: eligibility.paymentChoice,
 		selectedMembershipId: eligibility.selectedMembershipId,
@@ -17444,14 +18453,16 @@ function useCourseRegistrationWizard(props, options = {}) {
 		discountCode: discountUi.discountCode,
 		options
 	}, selection.goToStep);
-	useCourseRegistrationEffects({
+	useWholeSeriesRegistrationEffects({
 		api,
 		actions,
 		portal,
 		selection,
-		waitlistClaim
+		waitlistClaim,
+		anchorId: options.anchorId ?? "event-registration",
+		location
 	});
-	return buildCourseRegistrationWizardResult({
+	return buildWholeSeriesRegistrationWizardResult({
 		api,
 		selection,
 		portal,
@@ -17459,10 +18470,10 @@ function useCourseRegistrationWizard(props, options = {}) {
 		actions,
 		discountUi,
 		waitlistClaim,
-		view: deriveCourseRegistrationViewState({
-			scopedCourses: selection.scopedCourses,
-			selectedCourse: selection.selectedCourse,
-			pricing: selection.selectedCoursePricing,
+		view: deriveWholeSeriesRegistrationViewState({
+			scopedRuns: selection.scopedRuns,
+			selectedRun: selection.selectedRun,
+			pricing: selection.selectedRunPricing,
 			portalAuthState: portal.portalAuthState,
 			eligibleMembershipCount: eligibility.eligibleMemberships.length,
 			bookingMode,
@@ -17472,26 +18483,27 @@ function useCourseRegistrationWizard(props, options = {}) {
 		bookingMode,
 		setBookingMode,
 		altchaSolution,
-		setAltchaSolution
+		setAltchaSolution,
+		anchorId: options.anchorId ?? "event-registration"
 	});
 }
-function useCourseRegistrationEffects(input) {
-	useCoursePaymentVerification(input.api, {
+function useWholeSeriesRegistrationEffects(input) {
+	useWholeSeriesPaymentVerification(input.api, {
 		setStep: input.selection.goToStep,
 		setErrorMessage: input.actions.reportError,
 		setEnrollmentResult: input.actions.recordEnrollmentResult
-	});
-	useCourseWaitlistSelection({
+	}, input.anchorId, input.location);
+	useWholeSeriesWaitlistSelection({
 		waitlistClaim: input.waitlistClaim,
-		scopedCourses: input.selection.scopedCourses,
+		scopedRuns: input.selection.scopedRuns,
 		step: input.selection.step,
 		goToStep: input.selection.goToStep,
-		chooseCourse: input.selection.chooseCourse,
+		chooseRun: input.selection.chooseRun,
 		updateFormData: input.portal.updateFormData,
 		reportError: input.actions.reportError
 	});
 }
-function buildCourseRegistrationWizardResult(parts) {
+function buildWholeSeriesRegistrationWizardResult(parts) {
 	const handleBookingModeChange = (mode) => {
 		parts.setBookingMode(mode);
 		parts.eligibility.choosePaymentChoice(mode === "membership" ? "membership" : "checkout");
@@ -17515,30 +18527,30 @@ function buildCourseRegistrationWizardResult(parts) {
 		manualCodeEntryAllowed: parts.discountUi.manualCodeEntryAllowed,
 		discountsAvailableLoading: parts.discountUi.discountsAvailableLoading,
 		...parts.view,
-		handleCourseSelect: (course) => {
-			parts.selection.chooseCourse(course);
+		handleRunSelect: (run) => {
+			parts.selection.chooseRun(run);
 			parts.selection.goToStep("enter-details");
 		},
 		handleRetry: () => {
-			parts.selection.goToStep(parts.selection.scopedCourses.length === 1 ? "enter-details" : "select-course");
+			parts.selection.goToStep(parts.selection.scopedRuns.length === 1 ? "enter-details" : "select-run");
 			parts.actions.reportError("");
 		},
 		handleBookingModeChange,
-		handleLogout: parts.portal.portalAuthState === "authenticated" ? () => logoutPortal(COURSE_REGISTRATION_ANCHOR_ID) : void 0,
-		selectedCoursePricingPayload: buildCoursePricingOptionPayload(parts.selection.selectedCoursePricing)
+		handleLogout: parts.portal.portalAuthState === "authenticated" ? () => logoutPortal(parts.anchorId) : void 0,
+		selectedRunPricingPayload: buildWholeSeriesPricingOptionPayload(parts.selection.selectedRunPricing)
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration/whole-series-registration.headless.planning.ts
+//#region ../blocks/src/system/runtime/nodes/event-registration/whole-series/whole-series-registration.headless.planning.ts
 const STEP_IDS = {
-	"select-course": "select-run",
+	"select-run": "select-run",
 	"enter-details": "enter-details",
 	"booking-mode": "select-booking-method",
 	"select-payment": "select-payment"
 };
 function toPublicStepId(step) {
 	switch (step) {
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment": return STEP_IDS[step];
@@ -17598,7 +18610,7 @@ function resolveWholeSeriesRegistrationStatus(wizard) {
 			tag: "error",
 			message: wizard.errorMessage
 		};
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment": return { tag: "ready" };
@@ -17632,7 +18644,7 @@ function resolveWholeSeriesRegistrationView(wizard) {
 			kind: "error",
 			message: "Waitlist registration completed without a result."
 		};
-		case "select-course":
+		case "select-run":
 		case "enter-details":
 		case "booking-mode":
 		case "select-payment":
@@ -17669,7 +18681,7 @@ function resolveWholeSeriesPaymentSelection(input) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useHeadlessWholeSeriesRegistrationFlow.ts
-const wholeSeriesRegistrationControllerDeps = { useCourseRegistrationWizard };
+const wholeSeriesRegistrationControllerDeps = { useWholeSeriesRegistrationWizard };
 function createWholeSeriesRegistrationBlockApiConfig(input) {
 	return {
 		baseUrl: input.apiBaseUrl,
@@ -17695,8 +18707,8 @@ function useHeadlessWholeSeriesRegistrationFlow(options) {
 	return useWholeSeriesRegistrationControllerWithDeps(options, wholeSeriesRegistrationControllerDeps);
 }
 function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
-	const wizard = deps.useCourseRegistrationWizard({
-		courses: (options.runs ?? []).map(toPublicCourse),
+	const wizard = deps.useWholeSeriesRegistrationWizard({
+		runs: (options.runs ?? []).map(toPublicWholeSeriesOffering),
 		subject: options.subject ?? null
 	}, { onCheckoutRedirect: () => {} });
 	const steps = useMemo(() => deriveWholeSeriesRegistrationSteps({
@@ -17704,11 +18716,11 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		step: wizard.step
 	}), [wizard.step, wizard.wizardSteps]);
 	const currentStep = steps.find((step) => step.state === "active") ?? null;
-	const pricingSelection = resolveWholeSeriesPricingSelection(wizard.selectedCoursePricing);
+	const pricingSelection = resolveWholeSeriesPricingSelection(wizard.selectedRunPricing);
 	const paymentSelection = resolveWholeSeriesPaymentSelection({
 		paymentChoice: wizard.paymentChoice,
 		selectedMembershipId: wizard.selectedMembershipId,
-		required: wizard.selectedCoursePricing?.selectedRequiresPayment ?? false
+		required: wizard.selectedRunPricing?.selectedRequiresPayment ?? false
 	});
 	const updateRegistrant = useCallback((values) => wizard.updateFormData(values), [wizard]);
 	const setSlidingAmountCents = useCallback((amount) => {
@@ -17734,8 +18746,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		const blocked = resolveActionBlocker(wizard);
 		if (blocked) return blocked;
 		switch (wizard.step) {
-			case "select-course":
-				if (!wizard.selectedCourse) return {
+			case "select-run":
+				if (!wizard.selectedRun) return {
 					ok: false,
 					reason: "blocked",
 					message: "Choose an available set of dates to continue."
@@ -17765,7 +18777,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 	const back = useCallback(() => {
 		switch (wizard.step) {
 			case "enter-details":
-				if (!wizard.hasPreSelectedCourse) wizard.goToStep("select-course");
+				if (!wizard.hasPreSelectedRun) wizard.goToStep("select-run");
 				return;
 			case "booking-mode":
 				wizard.goToStep("enter-details");
@@ -17773,7 +18785,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			case "select-payment":
 				wizard.goToStep(wizard.canUseMembership ? "booking-mode" : "enter-details");
 				return;
-			case "select-course":
+			case "select-run":
 			case "submitting":
 			case "redirecting":
 			case "verifying-payment":
@@ -17785,7 +18797,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		}
 	}, [wizard]);
 	const payment = {
-		required: wizard.selectedCoursePricing?.selectedRequiresPayment ?? false,
+		required: wizard.selectedRunPricing?.selectedRequiresPayment ?? false,
 		selection: paymentSelection,
 		canUseMembership: wizard.canUseMembership,
 		eligibleMemberships: wizard.eligibleMemberships.map((membership) => ({
@@ -17795,7 +18807,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		eligibility: wizard.eligibilityLoading ? { tag: "loading" } : wizard.eligibilityError ? {
 			tag: "error",
 			message: wizard.eligibilityError
-		} : wizard.courseEligibility || wizard.portalAuthState !== "checking" ? { tag: "loaded" } : { tag: "idle" }
+		} : wizard.runEligibility || wizard.portalAuthState !== "checking" ? { tag: "loaded" } : { tag: "idle" }
 	};
 	const spamProtection = wizard.showSpamProtection ? {
 		enabled: true,
@@ -17806,13 +18818,13 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		},
 		solution: wizard.altchaSolution
 	} : { enabled: false };
-	const selectedRun = wizard.selectedCourse;
-	const isFull = wizard.courseEligibility?.isFull ?? (selectedRun?.availableSpots !== null && selectedRun?.availableSpots !== void 0 ? selectedRun.availableSpots <= 0 : false);
+	const selectedRun = wizard.selectedRun;
+	const isFull = wizard.runEligibility?.isFull ?? (selectedRun?.availableSpots !== null && selectedRun?.availableSpots !== void 0 ? selectedRun.availableSpots <= 0 : false);
 	return {
 		status: resolveWholeSeriesRegistrationStatus(wizard),
 		view: resolveWholeSeriesRegistrationView({
 			step: wizard.step,
-			scopedRunsCount: wizard.scopedCourses.length,
+			scopedRunsCount: wizard.scopedRuns.length,
 			selectedRun,
 			enrollmentResult: wizard.enrollmentResult,
 			errorMessage: wizard.errorMessage
@@ -17820,10 +18832,10 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		steps,
 		currentStep,
 		runs: {
-			items: (options.runs ?? []).map((run) => toWholeSeriesRegistrationRun(toPublicCourse(run))),
-			scoped: wizard.scopedCourses.map(toWholeSeriesRegistrationRun),
+			items: (options.runs ?? []).map((run) => toWholeSeriesRegistrationRun(toPublicWholeSeriesOffering(run))),
+			scoped: wizard.scopedRuns.map(toWholeSeriesRegistrationRun),
 			selected: selectedRun ? toWholeSeriesRegistrationRun(selectedRun) : null,
-			hasPreSelectedRun: wizard.hasPreSelectedCourse,
+			hasPreSelectedRun: wizard.hasPreSelectedRun,
 			subject: options.subject ?? null
 		},
 		registrant: {
@@ -17831,7 +18843,7 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			errors: wizard.errors
 		},
 		pricing: {
-			...toWholeSeriesRegistrationPricing(wizard.selectedCoursePricing),
+			...toWholeSeriesRegistrationPricing(wizard.selectedRunPricing),
 			selectedOptionId: wizard.selectedPricingOptionId,
 			selection: pricingSelection
 		},
@@ -17847,8 +18859,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 			enrollmentOpen: selectedRun?.enrollmentOpen ?? false,
 			availableSpots: selectedRun?.availableSpots ?? null,
 			isFull,
-			canJoinWaitlist: wizard.courseEligibility?.canJoinWaitlist ?? false,
-			message: wizard.courseEligibility?.reason ?? null
+			canJoinWaitlist: wizard.runEligibility?.canJoinWaitlist ?? false,
+			message: wizard.runEligibility?.reason ?? null
 		},
 		portalAuth: {
 			state: wizard.portalAuthState,
@@ -17862,8 +18874,8 @@ function useWholeSeriesRegistrationControllerWithDeps(options, deps) {
 		},
 		actions: {
 			selectRun: (runId) => {
-				const run = wizard.scopedCourses.find((candidate) => candidate.eventSeriesId === runId) ?? null;
-				if (run) wizard.handleCourseSelect(run);
+				const run = wizard.scopedRuns.find((candidate) => candidate.eventSeriesId === runId) ?? null;
+				if (run) wizard.handleRunSelect(run);
 			},
 			updateRegistrant,
 			selectPricingOption: wizard.choosePricingOption,
@@ -17907,8 +18919,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,
@@ -17916,6 +18928,7 @@ function toPublicCourse(run) {
 		slug: run.slug,
 		description: run.description,
 		teamMembers: run.teamMembers ? [...run.teamMembers] : void 0,
+		consent: run.consent,
 		enrollmentOpen: run.registrationOpen,
 		pricing,
 		currency: run.pricing.currency,
@@ -17933,7 +18946,7 @@ function toPublicCourse(run) {
 		venue: run.venue
 	};
 }
-function toCoursePricing(pricing) {
+function toWholeSeriesPricing(pricing) {
 	const common = {
 		bookingRequirement: pricing.bookingRequirement,
 		pricingStrategy: pricing.pricingStrategy,
@@ -18060,8 +19073,8 @@ function resolveWaitlistClaim(wizard) {
 	return { tag: "none" };
 }
 function resolveActionBlocker(wizard) {
-	if (!wizard.selectedCourse) return null;
-	if (!wizard.selectedCourse.enrollmentOpen) return {
+	if (!wizard.selectedRun) return null;
+	if (!wizard.selectedRun.enrollmentOpen) return {
 		ok: false,
 		reason: "blocked",
 		message: "Sign-up is closed."
@@ -18071,10 +19084,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;
 }