@riverbankcms/sdk 0.151.0 → 0.152.0

package/dist/server/rendering/server.mjs

@@ -23217,9 +23217,15 @@ function isRecord$20(value) {
 }
 //#endregion
 //#region ../core/src/money-input.ts
+function unsafeAsCents(value) {
+	return value;
+}
 function unsafeAsNonNegativeCents(value) {
 	return value;
 }
+function unsafeAsPositiveCents(value) {
+	return value;
+}
 /**
 * Normalizes a derived amount to non-negative whole cents. This intentionally
 * clamps negatives to zero; use parseNonNegativeCents for validation.
@@ -23227,6 +23233,23 @@ function unsafeAsNonNegativeCents(value) {
 function toNonNegativeCents(value) {
 	return unsafeAsNonNegativeCents(Math.max(0, Math.trunc(value)));
 }
+function parseCents(value) {
+	if (!Number.isFinite(value)) return err({ kind: "invalid-number" });
+	if (!Number.isInteger(value)) return err({ kind: "not-whole-cents" });
+	return ok$1(unsafeAsCents(value));
+}
+function parseNonNegativeCents(value) {
+	const parsed = parseCents(value);
+	if (!parsed.ok) return parsed;
+	if (parsed.value < 0) return err({ kind: "negative" });
+	return ok$1(unsafeAsNonNegativeCents(parsed.value));
+}
+function parsePositiveCents(value) {
+	const parsed = parseNonNegativeCents(value);
+	if (!parsed.ok) return parsed;
+	if (parsed.value === 0) return err({ kind: "zero-not-allowed" });
+	return ok$1(unsafeAsPositiveCents(parsed.value));
+}
 //#endregion
 //#region ../core/src/booking-payment-options.ts
 /** Automatic instalments and a flexible balance cannot share one booking offer. */
@@ -23790,14 +23813,15 @@ function formError(field) {
 }
 //#endregion
 //#region ../core/src/mailing-list-targeting.ts
+const DEFAULT_MAILING_LIST_TARGETING = { mode: "default" };
 function sameMailingListPlacementTargeting(left, right) {
 	if (left.mode !== right.mode) return false;
 	if (left.mode === "default" || right.mode === "default") return true;
 	if (left.provider !== right.provider || left.selection.tag !== right.selection.tag) return false;
 	if (left.provider === "mailchimp" && (right.provider !== "mailchimp" || left.audienceId !== right.audienceId)) return false;
-	return sameIds(targetingSelectionIds(left), targetingSelectionIds(right));
+	return sameIds(mailingListTargetingChoiceIds(left), mailingListTargetingChoiceIds(right));
 }
-function targetingSelectionIds(targeting) {
+function mailingListTargetingChoiceIds(targeting) {
 	switch (targeting.provider) {
 		case "native": return targeting.selection.tag === "fixed" ? targeting.selection.topicIds : targeting.selection.offeredTopicIds;
 		case "brevo": return targeting.selection.tag === "fixed" ? targeting.selection.listIds : targeting.selection.offeredListIds;
@@ -23848,6 +23872,103 @@ function planMailingListChoicePresentation(targeting) {
 	}
 }
 //#endregion
+//#region ../core/src/mailing-list-targeting-availability.ts
+function resolveMailingListDefaultDestination(provider) {
+	switch (provider.provider) {
+		case "native": return provider.topics.find((item) => item.id === provider.defaultTopicId) ?? null;
+		case "brevo": return provider.lists.find((item) => item.id === provider.defaultListId) ?? null;
+		case "mailchimp": return provider.audiences.find((item) => item.id === provider.defaultAudienceId) ?? null;
+	}
+}
+function assessMailingListTargeting(context, targeting) {
+	if (context?.tag !== "configured") return {
+		tag: "unavailable",
+		reason: "setup_missing",
+		targeting
+	};
+	const catalog = context.provider;
+	if (targeting.mode === "custom") return assessCustomTargeting(catalog, targeting);
+	const destination = resolveMailingListDefaultDestination(catalog);
+	return destination === null ? {
+		tag: "unavailable",
+		reason: "default_missing",
+		targeting
+	} : {
+		tag: "available",
+		value: {
+			mode: "default",
+			targeting,
+			provider: catalog.provider,
+			destination
+		}
+	};
+}
+function assessCustomTargeting(catalog, targeting) {
+	switch (targeting.provider) {
+		case "native": return catalog.provider === "native" ? assessMatchedChoices({
+			provider: "native",
+			catalog,
+			targeting
+		}, catalog.topics) : {
+			tag: "unavailable",
+			reason: "provider_mismatch",
+			targeting
+		};
+		case "brevo": return catalog.provider === "brevo" ? assessMatchedChoices({
+			provider: "brevo",
+			catalog,
+			targeting
+		}, catalog.lists) : {
+			tag: "unavailable",
+			reason: "provider_mismatch",
+			targeting
+		};
+		case "mailchimp": {
+			if (catalog.provider !== "mailchimp") return {
+				tag: "unavailable",
+				reason: "provider_mismatch",
+				targeting
+			};
+			const audience = catalog.audiences.find((item) => item.id === targeting.audienceId);
+			return audience === void 0 ? {
+				tag: "unavailable",
+				reason: "audience_missing",
+				value: {
+					mode: "custom",
+					provider: "mailchimp",
+					catalog,
+					targeting
+				}
+			} : assessMatchedChoices({
+				provider: "mailchimp",
+				catalog,
+				targeting,
+				audience
+			}, audience.interests);
+		}
+	}
+}
+function assessMatchedChoices(matched, choices) {
+	const selected = new Set(mailingListTargetingChoiceIds(matched.targeting));
+	const available = new Set(choices.map((item) => item.id));
+	const missingIds = [...selected].filter((id) => !available.has(id));
+	const value = {
+		mode: "custom",
+		...matched,
+		choices,
+		selectedChoices: choices.filter((item) => selected.has(item.id))
+	};
+	return missingIds.length > 0 ? {
+		tag: "unavailable",
+		reason: "choices_missing",
+		missingIds,
+		value
+	} : {
+		tag: "available",
+		value
+	};
+}
+//#endregion
 //#region ../core/src/mailing-list-runtime.ts
 function parseMailingListRuntimeContext(value) {
 	if (!isRecord$17(value)) return invalidRuntimeContext();
@@ -23912,57 +24033,47 @@ function parseBrevoRuntimeProvider(value) {
 function parseMailchimpRuntimeProvider(value) {
 	if (!Array.isArray(value.audiences)) return null;
 	const defaultAudienceId = parseMailchimpAudienceId(value.defaultAudienceId);
-	if (defaultAudienceId === null) return null;
-	const audiences = [];
-	for (const audience of value.audiences) {
-		if (!isRecord$17(audience)) return null;
-		const id = parseMailchimpAudienceId(audience.id);
-		const name = parseName(audience.name);
-		if (id === null || name === null || !Array.isArray(audience.interests)) return null;
-		const interests = parseMailchimpInterests(audience.interests);
-		if (interests === null) return null;
-		audiences.push({
-			id,
-			name,
-			interests
-		});
-	}
-	return {
+	const audiences = Array.from(value.audiences, parseMailchimpAudience);
+	return defaultAudienceId !== null && audiences.every((audience) => audience !== null) ? {
 		provider: "mailchimp",
 		defaultAudienceId,
 		audiences
-	};
+	} : null;
 }
-function parseMailchimpInterests(value) {
-	const interests = [];
-	for (const interest of value) {
-		if (!isRecord$17(interest)) return null;
-		const id = parseMailchimpInterestId(interest.id);
-		const name = parseName(interest.name);
-		const categoryName = parseName(interest.categoryName);
-		if (id === null || name === null || categoryName === null) return null;
-		interests.push({
-			id,
-			name,
-			categoryName
-		});
-	}
-	return interests;
+function parseMailchimpAudience(value) {
+	if (!isRecord$17(value) || !Array.isArray(value.interests)) return null;
+	const id = parseMailchimpAudienceId(value.id);
+	const name = parseName(value.name);
+	const interests = Array.from(value.interests, parseMailchimpInterest);
+	return id !== null && name !== null && interests.every((interest) => interest !== null) ? {
+		id,
+		name,
+		interests
+	} : null;
+}
+function parseMailchimpInterest(value) {
+	if (!isRecord$17(value)) return null;
+	const id = parseMailchimpInterestId(value.id);
+	const name = parseName(value.name);
+	const categoryName = parseName(value.categoryName);
+	return id !== null && name !== null && categoryName !== null ? {
+		id,
+		name,
+		categoryName
+	} : null;
 }
 function parseNamedItems(value, parseId) {
 	if (!Array.isArray(value)) return null;
-	const items = [];
-	for (const item of value) {
+	const items = Array.from(value, (item) => {
 		if (!isRecord$17(item)) return null;
 		const id = parseId(item.id);
 		const name = parseName(item.name);
-		if (id === null || name === null) return null;
-		items.push({
+		return id !== null && name !== null ? {
 			id,
 			name
-		});
-	}
-	return items;
+		} : null;
+	});
+	return items.every((item) => item !== null) ? items : null;
 }
 function parseName(value) {
 	if (typeof value !== "string") return null;
@@ -23978,6 +24089,7 @@ function invalidRuntimeContext() {
 //#endregion
 //#region ../core/src/mailing-list-targeting-parser.ts
 function parseMailingListPlacementTargeting(value) {
+	if (value == null) return ok$1(DEFAULT_MAILING_LIST_TARGETING);
 	if (!isRecord$16(value)) return targetingError("shape");
 	if (value.mode === "default") return ok$1({ mode: "default" });
 	if (value.mode !== "custom") return targetingError("mode");
@@ -24076,14 +24188,11 @@ function parseNonEmptyUniqueIds(value, parseId) {
 }
 function parseUniqueIds(value, parseId) {
 	if (!Array.isArray(value)) return targetingError("targets");
-	const parsed = [];
-	for (const item of value) {
+	return Array.from(value).reduce((parsed, item) => {
+		if (!parsed.ok) return parsed;
 		const id = parseId(item);
-		if (id === null) return targetingError("targets");
-		if (parsed.includes(id)) return targetingError("duplicate_target");
-		parsed.push(id);
-	}
-	return ok$1(parsed);
+		return id === null ? targetingError("targets") : parsed.value.includes(id) ? targetingError("duplicate_target") : ok$1([...parsed.value, id]);
+	}, ok$1([]));
 }
 function isRecord$16(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -24594,6 +24703,45 @@ const PORTAL_NAV_DEFAULT_LABELS = {
 	loggedIn: "My Account"
 };
 //#endregion
+//#region ../core/src/event-preset-vocabulary.ts
+const EVENT_PRESET_VOCABULARY = {
+	event: {
+		label: "Event",
+		pluralLabel: "Events",
+		description: "Any event, repeating or manually dated, that does not fit the other categories."
+	},
+	class: {
+		label: "Class",
+		pluralLabel: "Classes",
+		description: "Regular scheduled classes and group sessions."
+	},
+	course: {
+		label: "Course",
+		pluralLabel: "Courses",
+		description: "A fixed set of dates that people book together."
+	},
+	term: {
+		label: "Term",
+		pluralLabel: "Terms",
+		description: "A fixed term of sessions that people book together."
+	},
+	workshop: {
+		label: "Workshop",
+		pluralLabel: "Workshops",
+		description: "One-off workshops, day sessions, or special events."
+	},
+	retreat: {
+		label: "Retreat",
+		pluralLabel: "Retreats",
+		description: "Multi-day or residential immersive experiences."
+	},
+	performance: {
+		label: "Performance",
+		pluralLabel: "Performances",
+		description: "Audience-facing shows, concerts, recitals, or showcases."
+	}
+};
+//#endregion
 //#region ../media-core/src/fileSafety.ts
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/u;
 function containsUnsafePathSegmentCharacter(value) {
@@ -34477,17 +34625,7 @@ const linksTransforms = [{
 	id: "links.resolve",
 	kind: "formatter",
 	summary: "Resolve LinkValue objects to href strings using the route map",
-	run: (value, _options, context) => {
-		if (!value || typeof value !== "object") return null;
-		const link = value;
-		const kind = typeof link.kind === "string" ? link.kind : null;
-		if (kind === "internal") return resolveInternalLink(link, context);
-		if (kind === "page") return resolvePageLink(link, context);
-		if (kind === "entry") return resolveEntryLink(link, context);
-		if (kind === "external" || kind === "url") return resolveExternalLink(link);
-		if (!kind && typeof link.href === "string") return resolveExternalLink(link);
-		return null;
-	}
+	run: (value, _options, context) => resolveAuthoredLinkHref(value, context)
 }, {
 	id: "links.label",
 	kind: "formatter",
@@ -34514,6 +34652,21 @@ const linksTransforms = [{
 		return null;
 	}
 }];
+function resolveAuthoredLinkHref(value, context = {}) {
+	if (!value || typeof value !== "object") return null;
+	const link = value;
+	switch (link.kind) {
+		case "internal": return resolveInternalLink(link, context);
+		case "page": return resolvePageLink(link, context);
+		case "entry": return resolveEntryLink(link, context);
+		case "external":
+		case "url": return resolveExternalLink(link);
+		default: return resolvePreResolvedLink(link);
+	}
+}
+function resolvePreResolvedLink(link) {
+	return !(typeof link.kind === "string" ? link.kind : null) && typeof link.href === "string" ? resolveExternalLink(link) : null;
+}
 //#endregion
 //#region ../blocks/src/system/transforms/registry/content.ts
 const supportedRichTextTokenSchema = z.enum(["year", "site_name"]);
@@ -35586,6 +35739,14 @@ bookingPaymentOptionSchemas.flexibleBalanceConfig;
 bookingPaymentOptionSchemas.paymentCollectionOption;
 const bookingPaymentTermsSchema = bookingPaymentOptionSchemas.paymentTerms;
 bookingPaymentOptionSchemas.paymentOptionsChoice;
+z.strictObject({
+	currency: z.string().trim().length(3),
+	totalCents: nonNegativeIntegerSchema,
+	dueNowCents: nonNegativeIntegerSchema,
+	laterPaymentAmountsCents: z.array(nonNegativeIntegerSchema),
+	paymentOption: z.union([createBookingPaymentOptionSchemas("strict").paymentCollectionOption, z.strictObject({ kind: z.literal("not_required") })]),
+	promisedDiscountId: z.string().min(1).nullable().optional()
+});
 //#endregion
 //#region ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
 const blockBookingPaymentTermsSchema = bookingPaymentTermsSchema;
@@ -35827,6 +35988,10 @@ const publicEventBaseSchema = z.object({
 	eventDestinationMode: eventDestinationModeSchema.optional(),
 	scheduleScope: eventScheduleScopeSchema$2.optional(),
 	recurrence: publicEventRecurrenceSchema.optional(),
+	scheduleSummary: z.object({
+		recurrenceDescription: z.string(),
+		startTime: z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/).nullable()
+	}).nullable().optional(),
 	id: z.string(),
 	occurrenceId: z.string(),
 	seriesId: z.string(),
@@ -36435,16 +36600,19 @@ function decodeForSchemeCheck(value) {
 * - 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.
+*   backslashes, 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.includes("\\") || normalized.startsWith("//")) return null;
 	if (normalized.startsWith("/")) return normalized;
 	if (normalized.startsWith("#")) return normalized;
+	return sanitizeAbsoluteHref(normalized);
+}
+function sanitizeAbsoluteHref(normalized) {
 	const schemeMatch = normalizeInput(decodeForSchemeCheck(normalized)).match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
 	if (!schemeMatch) return null;
 	const rawScheme = schemeMatch[1];
@@ -39512,6 +39680,11 @@ function formatPlacesLeft(count, compact) {
 	if (compact) return `${count} left`;
 	return count === 1 ? "1 place left" : `${count} places left`;
 }
+function formatTicketTypeRemaining(remainingCapacity) {
+	if (remainingCapacity === null || remainingCapacity > 3) return null;
+	if (remainingCapacity <= 0) return "None left for this ticket type";
+	return `${formatPlacesLeft(remainingCapacity, false)} for this ticket type`;
+}
 /** Total capacity as copy ("12 places"), for detail surfaces that state the size of an event. */
 function formatTotalCapacity(capacity) {
 	if (capacity === null) return null;
@@ -40682,6 +40855,13 @@ function buildInteractiveIslandProps(options) {
 	};
 }
 //#endregion
+//#region ../commerce/src/purchase/settlement.ts
+function normalizeCurrencyCode(raw) {
+	const normalized = raw.trim().toUpperCase();
+	if (!/^[A-Z]{3}$/.test(normalized)) throw new Error(`Invalid currency code: ${raw}`);
+	return normalized;
+}
+//#endregion
 //#region ../commerce/src/purchase/checkoutSessionMetadata.ts
 const datedOfferingSharedEngineMetadataShape = {
 	datedOfferingEngineContractVersion: z.literal("shared_v1"),
@@ -40736,6 +40916,71 @@ const SharedDatedOfferingOrderCheckoutSessionMetadataSchema = z.object({
 });
 z.union([SharedDatedOfferingOrderCheckoutSessionMetadataSchema, LegacyOrderCheckoutSessionMetadataSchema]);
 //#endregion
+//#region ../commerce/src/purchase/confirmationPaymentSchema.ts
+const settledBalanceSchema = z.strictObject({ kind: z.literal("settled") });
+const dueBalanceSchema = z.strictObject({
+	kind: z.literal("due"),
+	amountCents: z.number().int().positive().transform((value, ctx) => {
+		const cents = parsePositiveCents(value);
+		if (cents.ok) return cents.value;
+		ctx.addIssue({
+			code: "custom",
+			message: "Expected positive whole cents"
+		});
+		return z.NEVER;
+	}),
+	dueAt: z.string().nullable()
+});
+const paymentBalanceSchema = z.discriminatedUnion("kind", [settledBalanceSchema, dueBalanceSchema]);
+const currencySchema = z.string().regex(/^[A-Z]{3}$/).transform(normalizeCurrencyCode);
+const moneyFields = {
+	amountPaidCents: z.number().int().nonnegative().transform(toNonNegativeCents),
+	currency: currencySchema
+};
+z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("free"),
+		balance: settledBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("waived"),
+		balance: settledBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("pass"),
+		passName: z.string().nullable(),
+		passCreditsUsed: z.number().int().positive().nullable(),
+		balance: settledBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("membership"),
+		membershipName: z.string().nullable(),
+		balance: settledBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("manual_due"),
+		currency: currencySchema,
+		balance: dueBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("managed_balance_due"),
+		...moneyFields,
+		balance: dueBalanceSchema
+	}),
+	z.strictObject({
+		kind: z.literal("monetary"),
+		...moneyFields,
+		paymentMethod: z.enum([
+			"stripe",
+			"store_credit",
+			"mixed",
+			"manual"
+		]),
+		balance: paymentBalanceSchema
+	})
+]);
+toNonNegativeCents(0);
+//#endregion
 //#region ../commerce/src/purchase/stripeCommissionMetadata.ts
 /** Reasons are payment evidence, not an independent pricing policy. */
 const STRIPE_COMMISSION_FREE_REASONS = [
@@ -40768,7 +41013,6 @@ z.discriminatedUnion("kind", [
 		...historicalContext
 	})
 ]);
-toNonNegativeCents(0);
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.state.ts
 function toTrimmedString(value) {
@@ -44696,6 +44940,7 @@ function buildOfferingsPreviewRenderStates(input) {
 	}
 	return states;
 }
+/** Which offerings a site preset row names; one owner for "the course preset means whole-series runs". */
 function sourceFromPresetSummary(preset) {
 	if (preset.engine === "event_series" && preset.canonicalBehaviour === "course") return { kind: "wholeSeries" };
 	if (preset.engine !== "event_series") return null;
@@ -47161,26 +47406,48 @@ const occurrenceContextSchema = z.object({
 	overrides: z.record(z.string(), z.unknown()).nullable().optional()
 }).nullable();
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
-/**
-* Determine which wizard steps to show based on context and payment requirements.
-*
-* @param hasPreSelectedContext - Whether event is pre-selected (skips event selection)
-* @param needsPaymentStep - Whether user must complete payment method selection
-* @returns Array of wizard steps to display
-*/
-function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep, paymentActive = false) {
-	const baseSteps = hasPreSelectedContext ? ["select-tickets", "enter-details"] : [
-		"select-event",
-		"select-tickets",
-		"enter-details"
-	];
-	if (!needsPaymentStep) return baseSteps;
-	return paymentActive ? [
-		...baseSteps,
-		"select-payment",
-		"payment"
-	] : [...baseSteps, "select-payment"];
+//#region ../blocks/src/system/runtime/nodes/event-registration/registrationDisplay.ts
+const registrationDisplaySchema = z.object({
+	venue: z.enum(["shown", "hidden"]),
+	placesLeft: z.enum(["shown", "hidden"])
+});
+function resolveRegistrationDisplay(source) {
+	return {
+		venue: source.showVenue === false ? "hidden" : "shown",
+		placesLeft: source.showCapacity === false ? "hidden" : "shown"
+	};
+}
+/** Venue stays in domain data; views receive only the permitted presentation. */
+function shownVenue(event, display) {
+	return display.venue === "shown" ? event.venue?.name ?? null : null;
+}
+/** Full/waitlist explanations remain visible even when optional counts are hidden. */
+function placesLeftLabel(source, display, wording = {}) {
+	if ("kind" in source) return ticketPlacesLabel(source.remaining, display);
+	if (source.deliveryMode === "hybrid" && source.attendanceModes?.length) return hybridPlacesLabel(source, display, wording);
+	return capacityPlacesLabel(source, display, wording);
+}
+function capacityPlacesLabel(source, display, wording) {
+	const remaining = getRemainingPlaces(source);
+	if (display.placesLeft === "hidden" && remaining.kind !== "full") return null;
+	switch (remaining.kind) {
+		case "full": return formatRemainingPlaces(source, wording);
+		case "low": return formatRemainingPlaces(source, wording);
+		case "unlimited": return wording.unlimited ?? null;
+		case "open": return wording.open ?? null;
+		default: return assertNever$3(remaining);
+	}
+}
+function hybridPlacesLabel(event, display, wording) {
+	if (display.placesLeft === "shown") return formatEventRemainingPlaces(event, wording);
+	return (event.attendanceModes ?? []).flatMap((mode) => {
+		const label = placesLeftLabel(mode, display, wording);
+		return label ? [`${mode.mode === "online" ? "Online" : "In person"}: ${label}`] : [];
+	}).join(" · ") || null;
+}
+function ticketPlacesLabel(remaining, display) {
+	if (remaining !== null && remaining > 0 && display.placesLeft === "hidden") return null;
+	return formatTicketTypeRemaining(remaining);
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
@@ -47206,6 +47473,369 @@ function resolveEventRequiresPayment(input) {
 	return publicEventPricingType(input.event.pricing) === "paid";
 }
 //#endregion
+//#region ../blocks/src/system/runtime/shared/components/StepIndicator.tsx
+function slotClasses(slot, classPrefix, emitSharedClasses) {
+	return [emitSharedClasses ? `rb-${slot}` : null, classPrefix ? `${classPrefix}-${slot}` : null].filter((name) => name !== null).join(" ");
+}
+function StepIndicator$1({ currentStep, totalSteps, stepLabels, classPrefix, emitSharedClasses }) {
+	const slot = (name) => slotClasses(name, classPrefix, emitSharedClasses);
+	const current = Math.min(Math.max(currentStep, 1), Math.max(totalSteps, 1));
+	const label = stepLabels?.[current - 1];
+	const percent = Math.round(current / Math.max(totalSteps, 1) * 100);
+	return /* @__PURE__ */ jsxs("nav", {
+		"aria-label": "Booking progress",
+		className: slot("progress"),
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: slot("progress__head"),
+			children: [label ? /* @__PURE__ */ jsx("span", {
+				className: slot("progress__label"),
+				"aria-current": "step",
+				children: label
+			}) : null, /* @__PURE__ */ jsxs("span", {
+				className: slot("progress__count"),
+				children: [
+					"Step ",
+					current,
+					" of ",
+					totalSteps
+				]
+			})]
+		}), /* @__PURE__ */ jsx("div", {
+			className: slot("progress__track"),
+			role: "progressbar",
+			"aria-valuemin": 1,
+			"aria-valuemax": totalSteps,
+			"aria-valuenow": current,
+			"aria-label": label ? `${label}, step ${current} of ${totalSteps}` : `Step ${current} of ${totalSteps}`,
+			children: /* @__PURE__ */ jsx("div", {
+				className: slot("progress__fill"),
+				style: { width: `${percent}%` }
+			})
+		})]
+	});
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/utils.ts
+/**
+* The locale a site's booking dates are written in: the one the site's time
+* zone places it in (`eventDateLocale`, shared with event cards), or British
+* English when the site names no zone.
+*/
+function bookingDateLocale(siteTimeZone) {
+	return siteTimeZone ? eventDateLocale(siteTimeZone) : "en-GB";
+}
+function bookingInstant(startsAt, input) {
+	return toScheduledBookingDateTime({
+		startsAt,
+		timeZone: toBookingTimeZone(input.timeZone),
+		locale: bookingDateLocale(input.siteTimeZone)
+	});
+}
+/** "7:00pm": a twelve-hour clock with a lowercase, unspaced day period. */
+function bookingClock(startsAt, input) {
+	return formatBookingTime(bookingInstant(startsAt, input), {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	}).replace(/\s*([ap])\.?\s?m\.?$/i, (_match, period) => `${period.toLowerCase()}m`);
+}
+/** "7:00pm – 8:15pm", or just the start when there's no distinct end. */
+function clockRange(input) {
+	const start = bookingClock(input.startsAt, input);
+	const end = input.endsAt ? bookingClock(input.endsAt, input) : null;
+	return end && end !== start ? `${start} – ${end}` : start;
+}
+/** A stored local clock has no date or DST offset; UTC preserves its digits. */
+function formatBookingScheduleSummary(event) {
+	const summary = event.scheduleSummary;
+	if (!summary) return null;
+	const time = summary.startTime ? formatBookingWhen({
+		startsAt: `1970-01-01T${summary.startTime}:00Z`,
+		timeZone: "UTC",
+		siteTimeZone: event.siteTimeZone
+	}, "time") : null;
+	return [summary.recurrenceDescription, time].filter(Boolean).join(" · ");
+}
+/** The one booking date formatter; every variant derives from it. */
+function formatBookingWhen(input, variant) {
+	const instant = bookingInstant(input.startsAt, input);
+	const day = formatBookingDate(instant, {
+		weekday: "short",
+		day: "numeric",
+		month: "short"
+	});
+	switch (variant) {
+		case "day": return day;
+		case "dayLong": return formatBookingDate(instant, {
+			weekday: "long",
+			day: "numeric",
+			month: "long"
+		});
+		case "month": return formatBookingDate(instant, { month: "long" });
+		case "monthYear": return formatBookingDate(instant, {
+			month: "long",
+			year: "numeric"
+		});
+		case "time": return bookingClock(input.startsAt, input);
+		case "timeRange": return clockRange(input);
+		case "short": return `${day}, ${bookingClock(input.startsAt, input)}`;
+		case "long": return `${day} · ${clockRange(input)}`;
+	}
+}
+/** A single instant in the short form, e.g. "Mon 5 Oct, 7:00pm". */
+function formatEventDateTime(isoTimestamp, options) {
+	return formatBookingWhen({
+		startsAt: isoTimestamp,
+		timeZone: options?.timeZone,
+		siteTimeZone: options?.siteTimeZone
+	}, "short");
+}
+/** The title an occurrence was given on its own, when it overrides the event's. */
+function occurrenceTitleOverride(occurrence) {
+	const title = occurrence?.overrides?.title;
+	return typeof title === "string" && title.trim() ? title.trim() : null;
+}
+/** The event as this page names it: an occurrence's own title wins. */
+function withOccurrenceTitle(event, occurrence) {
+	const title = occurrenceTitleOverride(occurrence);
+	return event && title ? {
+		...event,
+		title
+	} : event;
+}
+function courseSchedule(sessions, siteTimeZone) {
+	const first = sessions[0];
+	if (!first) return null;
+	const last = sessions[sessions.length - 1] ?? first;
+	const firstLabel = formatEventDateTime(first.startsAt, {
+		timeZone: first.timeZone,
+		siteTimeZone
+	});
+	if (last.startsAt === first.startsAt) return `${sessions.length} session${sessions.length === 1 ? "" : "s"} · ${firstLabel}`;
+	const lastLabel = formatEventDateTime(last.startsAt, {
+		timeZone: last.timeZone,
+		siteTimeZone
+	});
+	return `${sessions.length} sessions · ${firstLabel} – ${lastLabel}`;
+}
+/**
+* When a booking happens, in one line: the occurrence's date and time, or a
+* course's session count and first and last dates. `short` by default (bar,
+* confirmation); `long` adds the end time (card, panel header).
+*/
+function formatRegistrationSchedule(event, occurrence, variant = "short") {
+	if (event.registrationSubject.kind === "wholeSeries") return courseSchedule(event.registrationSubject.sessions, event.siteTimeZone);
+	const input = scheduleInput(event, occurrence ?? null);
+	return input ? formatBookingWhen(input, variant) : null;
+}
+/** The occurrence's own times when the page names one, otherwise the event's. */
+function scheduleInput(event, occurrence) {
+	const times = occurrence?.startsAt ? {
+		startsAt: occurrence.startsAt,
+		endsAt: occurrence.endsAt ?? null
+	} : {
+		startsAt: event.startsAt,
+		endsAt: event.endsAt
+	};
+	if (!times.startsAt) return null;
+	return {
+		...times,
+		timeZone: occurrence?.timeZone ?? event.timeZone ?? null,
+		siteTimeZone: event.siteTimeZone
+	};
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
+function registrationRoute(input) {
+	const base = input.chooseEvent ? [
+		"select-event",
+		"select-tickets",
+		"enter-details"
+	] : ["select-tickets", "enter-details"];
+	switch (input.payment) {
+		case "none": return base;
+		case "options": return [...base, "select-payment"];
+		case "optionsAndPayment": return [
+			...base,
+			"select-payment",
+			"payment"
+		];
+	}
+}
+const REGISTRATION_STEP_LABELS = [
+	"Event",
+	"Date",
+	"Tickets",
+	"Places",
+	"Your details",
+	"How you’ll pay",
+	"Payment"
+];
+/** Several dates of one series are a date choice; anything else is an event choice. */
+function getEventSelectionMode(events) {
+	const firstSeriesId = events[0]?.seriesId;
+	return events.length > 1 && firstSeriesId && events.every((event) => event.seriesId === firstSeriesId) ? "date" : "event";
+}
+/** The label facts for a surface: what the visitor chooses from, and what they book. */
+function registrationStepLabelContext(scopedEvents, bookedEvent) {
+	return {
+		eventSelection: getEventSelectionMode(scopedEvents),
+		booksWholeSeries: bookedEvent?.registrationSubject.kind === "wholeSeries"
+	};
+}
+/** One label owner for the live progress and the server placeholder. */
+function registrationStepLabel(step, context) {
+	switch (step) {
+		case "select-event": return context.eventSelection === "date" ? "Date" : "Event";
+		case "select-tickets": return context.booksWholeSeries ? "Places" : "Tickets";
+		case "enter-details": return "Your details";
+		case "select-payment": return "How you’ll pay";
+		case "payment": return "Payment";
+	}
+}
+function bookingButtonText(buttonText) {
+	return buttonText?.trim() || "Book your place";
+}
+function placesLabel(event, input, compact) {
+	return placesLeftLabel(selectEventCapacitySource(event, input.attendanceMode), input.display, { compact });
+}
+function isFull(event, mode) {
+	return formatRemainingPlaces(selectEventCapacitySource(event, mode), {
+		full: "full",
+		waitlist: "full"
+	}) === "full";
+}
+function priceLabel(event) {
+	return formatEventPriceDisplay(event.pricing).trim() || null;
+}
+/** The lowest price a display can mean; null when it names no paid amount. */
+function lowestPaidAmount(display) {
+	switch (display.kind) {
+		case "exact":
+		case "from": return display.amount;
+		case "range": return display.minAmount;
+		case "mixed": return display.paidFromAmount;
+		case "free":
+		case "unavailable":
+		case "external": return null;
+	}
+}
+/**
+* One price for a set of dates: the shared label when every date costs the
+* same, otherwise "From" the lowest paid amount, through the one formatter.
+*/
+function seriesPriceLabel(events) {
+	const firstEvent = events[0];
+	if (!firstEvent) return null;
+	const displays = events.map((event) => publicEventPricingDisplay(event.pricing));
+	const labels = new Set(displays.map((display) => formatBookingPriceDisplay(display, { decimals: "auto" })));
+	if (labels.size === 1) return [...labels][0] || null;
+	const lowest = displays.flatMap((display) => {
+		const amount = lowestPaidAmount(display);
+		return amount === null || !("currency" in display) ? [] : [{
+			amount,
+			currency: display.currency
+		}];
+	}).reduce((best, candidate) => best === null || candidate.amount < best.amount ? candidate : best, null);
+	return lowest ? formatBookingPriceDisplay({
+		kind: "from",
+		amount: lowest.amount,
+		currency: lowest.currency
+	}, { decimals: "auto" }) : priceLabel(firstEvent);
+}
+function dateTile(event) {
+	if (event.registrationSubject.kind === "wholeSeries" || !event.startsAt) return null;
+	const rail = formatEventCompactDateRail(event.startsAt, { timeZone: event.timeZone });
+	return {
+		month: rail.month,
+		day: rail.day
+	};
+}
+/** "Mon 5 Oct": the compact date the chips and the bar share. */
+function formatBookingShortDate(event) {
+	return formatBookingWhen(event, "day");
+}
+function byStart(left, right) {
+	return Date.parse(left.startsAt) - Date.parse(right.startsAt);
+}
+function singleEntry(event, input) {
+	const isCourse = event.registrationSubject.kind === "wholeSeries";
+	return {
+		kind: "single",
+		title: event.title,
+		when: formatRegistrationSchedule(event, null, "long"),
+		shortWhen: formatRegistrationSchedule(event),
+		venue: shownVenue(event, input.display),
+		price: priceLabel(event),
+		places: placesLabel(event, input, false),
+		tile: dateTile(event),
+		action: isCourse ? `Book the ${input.noun.label}` : bookingButtonText(input.buttonText)
+	};
+}
+function chooseDateEntry(input) {
+	const ordered = [...input.events].sort(byStart);
+	const first = ordered[0];
+	const shown = ordered.slice(0, 4);
+	return {
+		kind: "chooseDate",
+		title: first?.title ?? "",
+		schedule: (first ? formatBookingScheduleSummary(first) : null) ?? (ordered.length === 1 ? "1 date" : `${ordered.length} dates`),
+		venue: first ? shownVenue(first, input.display) : null,
+		price: seriesPriceLabel(ordered),
+		nextDate: first ? formatBookingShortDate(first) : null,
+		dateCount: ordered.length,
+		dates: shown.map((event) => ({
+			selectionId: event.selectionId,
+			label: formatBookingShortDate(event),
+			places: placesLabel(event, input, true),
+			full: isFull(event, input.attendanceMode)
+		})),
+		moreCount: Math.max(0, ordered.length - shown.length),
+		action: "Choose a date"
+	};
+}
+/** The card before a booking starts; the server renders this too. */
+function idleBookingEntry(input) {
+	if (input.event) return singleEntry(input.event, input);
+	const only = input.events.length === 1 ? input.events[0] : void 0;
+	if (only) return singleEntry(only, input);
+	if (getEventSelectionMode(input.events) === "date") return chooseDateEntry(input);
+	return {
+		kind: "chooseEvent",
+		title: input.events[0]?.title ?? "",
+		count: input.events.length,
+		noun: input.noun.pluralLabel,
+		action: "Choose an event"
+	};
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/offeringNoun.ts
+function offeringKindForEvent(event) {
+	return event.registrationSubject.kind === "wholeSeries" ? "course" : event.eventPreset ?? "event";
+}
+function presetKind(preset) {
+	const source = sourceFromPresetSummary(preset);
+	if (!source) return null;
+	return source.kind === "wholeSeries" ? "course" : source.preset;
+}
+/**
+* What the site calls this kind of offering, in lower case for use mid-sentence
+* ("Book the course", "3 workshops"). Site preset labels win; the canonical
+* name stands in when the site has none.
+*/
+function offeringNounForEvent(event, presets) {
+	if (!event) return lowerCased(EVENT_PRESET_VOCABULARY.event);
+	const kind = offeringKindForEvent(event);
+	const preset = presets?.find((candidate) => presetKind(candidate) === kind);
+	return lowerCased(preset?.label.trim() && preset.pluralLabel.trim() ? preset : EVENT_PRESET_VOCABULARY[kind]);
+}
+function lowerCased(noun) {
+	return {
+		label: noun.label.trim().toLocaleLowerCase(),
+		pluralLabel: noun.pluralLabel.trim().toLocaleLowerCase()
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
 function toRegistrationEvent(event) {
 	return {
@@ -47250,6 +47880,101 @@ function toWholeSeriesRegistrationEvents(events) {
 	return groupPublicEventsByRun(events).map(toWholeSeriesRegistrationEvent).filter((event) => event !== null);
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/bookingCardDisplay.ts
+/**
+* The booking card the server renders on CMS pages (issue 1581), and the
+* offering noun it resolves for the wizard. Kept beside the island contract
+* so the server and the client agree on one card.
+*/
+const bookingHostSchema = z.enum(["overlay", "inPlace"]);
+const tileSchema = z.object({
+	month: z.string(),
+	day: z.string()
+}).nullable();
+const idleBookingEntrySchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("single"),
+		title: z.string(),
+		when: z.string().nullable(),
+		shortWhen: z.string().nullable(),
+		venue: z.string().nullable(),
+		price: z.string().nullable(),
+		places: z.string().nullable(),
+		tile: tileSchema,
+		action: z.string()
+	}),
+	z.object({
+		kind: z.literal("chooseDate"),
+		title: z.string(),
+		schedule: z.string(),
+		venue: z.string().nullable(),
+		price: z.string().nullable(),
+		nextDate: z.string().nullable(),
+		dateCount: z.number(),
+		dates: z.array(z.object({
+			selectionId: z.string(),
+			label: z.string(),
+			places: z.string().nullable(),
+			full: z.boolean()
+		})),
+		moreCount: z.number(),
+		action: z.string()
+	}),
+	z.object({
+		kind: z.literal("chooseEvent"),
+		title: z.string(),
+		count: z.number(),
+		noun: z.string(),
+		action: z.string()
+	})
+]);
+function toScopedEventRegistrationEvents(scopedSourceEvents) {
+	return [...toRegistrationEvents(scopedSourceEvents), ...toWholeSeriesRegistrationEvents(scopedSourceEvents)];
+}
+function scopedRegistrationEvents(source, scopedSourceEvents) {
+	const scopedEvents = toScopedEventRegistrationEvents(scopedSourceEvents);
+	return {
+		scopedEvents,
+		preSelected: findPreSelectedEvent({
+			scopedEvents,
+			occurrenceContext: source.occurrenceContext
+		})
+	};
+}
+function nounFor(scoped, presets) {
+	return offeringNounForEvent(scoped.preSelected ?? scoped.scopedEvents[0] ?? null, presets);
+}
+/** What the site calls the offering this block books, from its preset rows. */
+function resolveOfferingNoun(source, scopedSourceEvents) {
+	return nounFor(scopedRegistrationEvents(source, scopedSourceEvents), source.bookingOfferingPresets);
+}
+function idleEntry(source, scopedSourceEvents, display) {
+	const scoped = scopedRegistrationEvents(source, scopedSourceEvents);
+	if (scoped.scopedEvents.length === 0) return null;
+	return idleBookingEntry({
+		events: scoped.scopedEvents,
+		event: withOccurrenceTitle(scoped.preSelected, source.occurrenceContext),
+		display,
+		buttonText: source.buttonText,
+		noun: nounFor(scoped, source.bookingOfferingPresets),
+		attendanceMode: null
+	});
+}
+/** The server's card on CMS pages, or null where the shell still applies. */
+function bookingCardDisplay(source, scopedSourceEvents, display) {
+	if ((source.host ?? "overlay") !== "overlay") return null;
+	const entry = idleEntry(source, scopedSourceEvents, display);
+	if (!entry) return null;
+	return {
+		kind: "event-registration",
+		state: "booking-card",
+		className: source.className ?? null,
+		entry,
+		buttonVariant: source.buttonVariant ?? null,
+		buttonText: source.buttonText?.trim() ?? ""
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/eventSourceRecovery.ts
 const { limit: _rawLimit, eventSurface: _rawEventSurface, scheduleScope: _rawScheduleScope, detailLevel: _rawDetailLevel, ...stringEventQueryShape } = publicEventLoaderQuerySchemaShape;
 const eventRecoveryRequestSchema = z.object({
@@ -47292,27 +48017,17 @@ function parseEventLoaderRecoveryRequest(value) {
 const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = [
 	"Date",
 	"Tickets",
-	"Details"
-];
-const EVENT_REGISTRATION_SHELL_STEP_LABELS = [
-	"Event",
-	"Date",
-	"Tickets",
-	"Details",
-	"Payment options",
-	"Payment"
+	"Your details"
 ];
 const eventRegistrationPublicEventSchema = z.preprocess(normalizeEventRegistrationEventInput, publicEventSchema);
-const eventRegistrationHydrationSchemaShape = {
+const eventRegistrationCommonSchemaShape = {
 	demoEmailSuppressed: z.boolean().optional(),
 	occurrenceContext: occurrenceContextSchema.optional(),
 	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
 	maxTickets: z.string().optional(),
-	showVenue: z.boolean().optional(),
-	showCapacity: z.boolean().optional(),
 	successMessage: z.string().optional(),
 	buttonVariant: registrationButtonVariantSchema.optional(),
-	overlayEnabled: z.boolean().optional(),
+	host: bookingHostSchema.optional(),
 	spamProtectionEnabled: z.boolean().optional(),
 	supportEmail: z.string().optional(),
 	sitePasses: publicPassProductCollectionSchema.nullable().optional(),
@@ -47337,32 +48052,51 @@ const eventRegistrationSourceSchema = z.object({
 	portalToken: z.string().nullable().optional(),
 	previewToken: z.string().nullable().optional(),
 	readAuthority: browserReadAuthoritySchema.optional(),
-	...eventRegistrationHydrationSchemaShape,
+	...eventRegistrationCommonSchemaShape,
+	showVenue: z.boolean().optional(),
+	showCapacity: z.boolean().optional(),
 	events: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
 	wholeSeriesRunEvents: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
 	eventLoaderFailures: z.record(z.string(), z.unknown()).nullable().optional(),
 	className: z.string().nullable().optional(),
 	buttonText: z.string().nullable().optional(),
 	maxTickets: z.string().nullable().optional(),
-	stage: previewStageSchema.optional()
+	stage: previewStageSchema.optional(),
+	bookingOfferingPresets: z.array(z.custom((value) => typeof value === "object" && value !== null && typeof value.label === "string")).nullable().optional()
 });
-const eventRegistrationDisplaySchema = z.discriminatedUnion("state", [z.object({
-	kind: z.literal("event-registration"),
-	state: z.literal("generic-shell"),
-	className: z.string().nullable(),
-	titleText: z.string(),
-	bodyText: z.string(),
-	stepLabels: z.array(z.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-	summaryButtonText: z.string()
-}), z.object({
-	kind: z.literal("event-registration"),
-	state: z.literal("registration-closed"),
-	className: z.string().nullable(),
-	titleText: z.string(),
-	bodyText: z.string()
-})]);
+const eventRegistrationDisplaySchema = z.discriminatedUnion("state", [
+	z.object({
+		kind: z.literal("event-registration"),
+		state: z.literal("generic-shell"),
+		className: z.string().nullable(),
+		titleText: z.string(),
+		bodyText: z.string(),
+		stepLabels: z.array(z.enum(REGISTRATION_STEP_LABELS)).min(1),
+		summaryButtonText: z.string()
+	}),
+	z.object({
+		kind: z.literal("event-registration"),
+		state: z.literal("registration-closed"),
+		className: z.string().nullable(),
+		titleText: z.string(),
+		bodyText: z.string()
+	}),
+	z.object({
+		kind: z.literal("event-registration"),
+		state: z.literal("booking-card"),
+		className: z.string().nullable(),
+		entry: idleBookingEntrySchema,
+		buttonVariant: registrationButtonVariantSchema.nullable(),
+		buttonText: z.string()
+	})
+]);
 const eventRegistrationHydrationSchema = z.object({
-	...eventRegistrationHydrationSchemaShape,
+	...eventRegistrationCommonSchemaShape,
+	display: registrationDisplaySchema,
+	offeringNoun: z.object({
+		label: z.string(),
+		pluralLabel: z.string()
+	}).optional(),
 	eventSource: eventRegistrationEventSourceSchema
 });
 const eventRegistrationRenderSchema = z.object({
@@ -47377,7 +48111,7 @@ z.object({
 	readAuthority: browserReadAuthoritySchema.optional(),
 	stage: previewStageSchema.optional()
 });
-function buildEventRegistrationDisplayFromScopedEvents(source, scopedSourceEvents) {
+function buildEventRegistrationDisplayFromScopedEvents(source, scopedSourceEvents, display) {
 	const selectedRun = resolveSelectedWholeSeriesRun(scopedSourceEvents);
 	if (selectedRun && (!selectedRun.run.enrollmentOpen || toWholeSeriesRegistrationEvent(selectedRun) === null)) return {
 		kind: "event-registration",
@@ -47386,6 +48120,8 @@ function buildEventRegistrationDisplayFromScopedEvents(source, scopedSourceEvent
 		titleText: "Registration closed",
 		bodyText: "This run is no longer open for bookings."
 	};
+	const card = bookingCardDisplay(source, scopedSourceEvents, display);
+	if (card) return card;
 	const stepLabels = buildEventRegistrationShellStepLabels(source, scopedSourceEvents);
 	return {
 		kind: "event-registration",
@@ -47402,11 +48138,14 @@ function buildEventRegistrationShellStepLabels(source, scopedSourceEvents) {
 	if (selectedRun) {
 		const selectedEvent = toWholeSeriesRegistrationEvent(selectedRun);
 		if (!selectedEvent) return EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
-		return getWizardStepsForContext(true, resolveEventRequiresPayment({
-			eligibility: null,
-			selectedTicketType: null,
-			event: selectedEvent
-		})).map((step) => shellLabelForRegistrationStep(step, [selectedEvent]));
+		return shellStepLabels(registrationRoute({
+			chooseEvent: false,
+			payment: resolveEventRequiresPayment({
+				eligibility: null,
+				selectedTicketType: null,
+				event: selectedEvent
+			}) ? "optionsAndPayment" : "none"
+		}), registrationStepLabelContext([selectedEvent], selectedEvent));
 	}
 	const scopedEvents = toScopedEventRegistrationEvents(scopedSourceEvents);
 	if (scopedEvents.length === 0) return EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
@@ -47415,14 +48154,15 @@ function buildEventRegistrationShellStepLabels(source, scopedSourceEvents) {
 		occurrenceContext: source.occurrenceContext
 	});
 	const hasPreSelectedContext = Boolean(source.occurrenceContext || preSelectedEvent);
-	return getWizardStepsForContext(hasPreSelectedContext, hasPreSelectedContext && preSelectedEvent ? resolveEventRequiresPayment({
+	const needsPaymentStep = hasPreSelectedContext && preSelectedEvent ? resolveEventRequiresPayment({
 		eligibility: null,
 		selectedTicketType: null,
 		event: preSelectedEvent
-	}) : false).map((step) => shellLabelForRegistrationStep(step, scopedEvents));
-}
-function toScopedEventRegistrationEvents(scopedSourceEvents) {
-	return [...toRegistrationEvents(scopedSourceEvents), ...toWholeSeriesRegistrationEvents(scopedSourceEvents)];
+	}) : false;
+	return shellStepLabels(registrationRoute({
+		chooseEvent: !hasPreSelectedContext,
+		payment: needsPaymentStep ? "optionsAndPayment" : "none"
+	}), registrationStepLabelContext(scopedEvents, preSelectedEvent));
 }
 function scopeEventRegistrationSourceEvents(source, eventSource) {
 	return resolveEventRegistrationScopedEvents(eventSource.kind === "loaded" ? eventSource.events : [], {
@@ -47438,29 +48178,12 @@ function resolveSelectedWholeSeriesRun(scopedSourceEvents) {
 	const runs = groupPublicEventsByRun(scopedSourceEvents);
 	return runs.length === 1 ? runs[0] : null;
 }
-function shellLabelForRegistrationStep(step, events) {
-	switch (step) {
-		case "select-event": return isDateSelection(events) ? "Date" : "Event";
-		case "select-tickets": return "Tickets";
-		case "enter-details": return "Details";
-		case "select-payment": return "Payment options";
-		case "payment": return "Payment";
-		case "error":
-		case "success":
-		case "submitting":
-		case "verifying-payment":
-		case "verifying-timeout":
-		case "payment-status":
-		case "payment-failed": return "Details";
-	}
-}
-function isDateSelection(events) {
-	const firstSeriesId = events[0]?.seriesId;
-	return Boolean(events.length > 1 && firstSeriesId && events.every((event) => event.seriesId === firstSeriesId));
+function shellStepLabels(route, context) {
+	return route.map((step) => registrationStepLabel(step, context));
 }
 function buildEventRegistrationShellBodyText(stepLabels) {
-	if (stepLabels.includes("Payment options")) return "Preparing tickets, details, and payment options.";
-	if (stepLabels[0] === "Tickets") return "Preparing tickets and booking details.";
+	if (stepLabels.includes("How you’ll pay")) return "Preparing tickets, details, and payment options.";
+	if (stepLabels[0] === "Tickets" || stepLabels[0] === "Places") return "Preparing tickets and booking details.";
 	return "Preparing dates, tickets, and booking details.";
 }
 const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
@@ -47470,6 +48193,7 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 		render: createZodCodec(eventRegistrationRenderSchema)
 	},
 	buildRender: (source) => {
+		const display = resolveRegistrationDisplay(source);
 		const eventSource = resolveEventRegistrationEventSource({
 			events: source.events,
 			wholeSeriesRunEvents: source.wholeSeriesRunEvents,
@@ -47477,7 +48201,7 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 		});
 		const scopedSourceEvents = scopeEventRegistrationSourceEvents(source, eventSource);
 		return {
-			display: buildEventRegistrationDisplayFromScopedEvents(source, scopedSourceEvents),
+			display: buildEventRegistrationDisplayFromScopedEvents(source, scopedSourceEvents, display),
 			hydration: {
 				occurrenceContext: source.occurrenceContext ?? null,
 				subject: source.subject ?? null,
@@ -47487,17 +48211,17 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 				} : eventSource,
 				demoEmailSuppressed: source.demoEmailSuppressed,
 				maxTickets: source.maxTickets ?? void 0,
-				showVenue: source.showVenue,
-				showCapacity: source.showCapacity,
+				display,
 				successMessage: source.successMessage,
 				buttonVariant: source.buttonVariant,
-				overlayEnabled: source.overlayEnabled,
+				host: source.host ?? "overlay",
 				spamProtectionEnabled: source.spamProtectionEnabled,
 				supportEmail: source.supportEmail,
 				sitePasses: source.sitePasses ?? null,
 				siteMemberships: source.siteMemberships ?? null,
 				mailingList: source.mailingList,
-				siteName: source.siteName
+				siteName: source.siteName,
+				offeringNoun: resolveOfferingNoun(source, scopedSourceEvents)
 			}
 		};
 	}
@@ -47564,7 +48288,7 @@ const eventRegistrationBlockDefinition = {
 				description: "Main heading for the registration form",
 				required: false,
 				multiline: false,
-				defaultValue: "Register for this event"
+				defaultValue: ""
 			},
 			{
 				id: "description",
@@ -47636,11 +48360,11 @@ const eventRegistrationBlockDefinition = {
 			{
 				id: "buttonText",
 				type: "text",
-				label: "Submit button text",
-				description: "Text for the registration submit button",
+				label: "Button text",
+				description: "Text on the booking button",
 				required: false,
 				multiline: false,
-				defaultValue: "Complete Registration",
+				defaultValue: "Book your place",
 				maxLength: 40
 			},
 			createButtonVariantField()
@@ -47672,21 +48396,21 @@ const eventRegistrationBlockDefinition = {
 					successMessage: { $bind: { from: "content.successMessage" } },
 					buttonText: { $bind: {
 						from: "content.buttonText",
-						fallback: "Complete Registration"
+						fallback: "Book your place"
 					} },
 					buttonVariant: { $bind: {
 						from: "content.buttonVariant",
 						fallback: "primary"
 					} },
-					overlayEnabled: { $bind: {
-						from: "$root.eventRegistrationOverlayEnabled",
-						fallback: false
-					} },
 					events: { $bind: { from: "data.events" } },
 					wholeSeriesRunEvents: { $bind: { from: "data.wholeSeriesRunEvents" } },
 					loaderFailures: { $bind: { from: "$root.loaderFailures" } },
 					mailingList: { $bind: { from: "$root.mailingList" } },
 					siteName: { $bind: { from: "$root.siteName" } },
+					bookingOfferingPresets: { $bind: {
+						from: "$root.bookingOfferingPresets",
+						fallback: []
+					} },
 					sitePasses: { $bind: { from: "data.sitePasses" } },
 					siteMemberships: { $bind: { from: "data.siteMemberships" } },
 					stage: { $bind: {
@@ -49427,7 +50151,21 @@ const eventCalendarBlockDefinition = {
 			list: { label: "List" }
 		}
 	}, eventCalendarContentShape),
-	normalizeContent: normalizeEventCalendarContent,
+	contentNormalizer: {
+		fieldIds: [
+			"variant",
+			"displayMode",
+			"listLayout",
+			"defaultCalendarView",
+			"eventSurface",
+			"filterEventPresets",
+			"scheduleScope",
+			"filterCategoryIds",
+			"filterStaffMemberId",
+			"filterVenueId"
+		],
+		normalize: normalizeEventCalendarContent
+	},
 	dataSchemas: {
 		events: publicEventsArraySchema.optional(),
 		calendarWindow: calendarWindowPageSchema.optional()
@@ -50180,11 +50918,11 @@ function buildNewsletterDisplay(source) {
 		successMessage: DEFAULT_MAILING_LIST_SUCCESS_MESSAGE,
 		privacyNote: null
 	};
-	const targeting = source.targeting ?? { mode: "default" };
-	const choices = resolveRuntimeChoices(context, targeting);
+	const assessment = assessMailingListTargeting(context, source.targeting ?? { mode: "default" });
+	const choices = resolveRuntimeChoices(assessment);
 	return {
 		kind: "newsletter-form",
-		availability: runtimeTargetingIsAvailable(context, targeting, choices) ? "ready" : "unavailable",
+		availability: assessment.tag === "available" ? "ready" : "unavailable",
 		className: source.className ?? null,
 		buttonLabel: form.buttonLabel,
 		successMessage: form.successMessage,
@@ -50241,60 +50979,12 @@ function projectNewsletterFormHydrationTarget(source) {
 		default: return assertNever$3(source);
 	}
 }
-function resolveRuntimeChoices(context, targeting) {
-	if (context?.tag !== "configured" || targeting.mode !== "custom" || targeting.selection.tag !== "visitor_choice" || context.provider.provider !== targeting.provider) return [];
-	switch (targeting.provider) {
-		case "native": {
-			const offered = new Set(targeting.selection.offeredTopicIds);
-			return context.provider.provider === "native" ? context.provider.topics.filter((item) => offered.has(item.id)).map((item) => ({
-				id: item.id,
-				label: item.name
-			})) : [];
-		}
-		case "brevo": {
-			const offered = new Set(targeting.selection.offeredListIds);
-			return context.provider.provider === "brevo" ? context.provider.lists.filter((item) => offered.has(item.id)).map((item) => ({
-				id: String(item.id),
-				label: item.name
-			})) : [];
-		}
-		case "mailchimp": {
-			const offered = new Set(targeting.selection.offeredInterestIds);
-			return (context.provider.provider === "mailchimp" ? context.provider.audiences.find((item) => item.id === targeting.audienceId) : void 0)?.interests.filter((item) => offered.has(item.id)).map((item) => ({
-				id: item.id,
-				label: item.name
-			})) ?? [];
-		}
-	}
-}
-function runtimeTargetingIsAvailable(context, targeting, choices) {
-	if (context?.tag !== "configured") return false;
-	const provider = context.provider;
-	if (targeting.mode === "default") switch (provider.provider) {
-		case "native": return provider.topics.some((item) => item.id === provider.defaultTopicId);
-		case "brevo": return provider.lists.some((item) => item.id === provider.defaultListId);
-		case "mailchimp": return provider.audiences.some((item) => item.id === provider.defaultAudienceId);
-	}
-	if (targeting.provider !== provider.provider) return false;
-	switch (targeting.provider) {
-		case "native": return provider.provider === "native" && nativeTargetIsAvailable(provider, targeting, choices);
-		case "brevo": return provider.provider === "brevo" && brevoTargetIsAvailable(provider, targeting, choices);
-		case "mailchimp": return provider.provider === "mailchimp" && mailchimpTargetIsAvailable(provider, targeting, choices);
-	}
-}
-function nativeTargetIsAvailable(provider, targeting, choices) {
-	const ids = targeting.selection.tag === "fixed" ? targeting.selection.topicIds : targeting.selection.offeredTopicIds;
-	return ids.every((id) => provider.topics.some((item) => item.id === id)) && (targeting.selection.tag !== "visitor_choice" || choices.length === ids.length);
-}
-function brevoTargetIsAvailable(provider, targeting, choices) {
-	const ids = targeting.selection.tag === "fixed" ? targeting.selection.listIds : targeting.selection.offeredListIds;
-	return ids.every((id) => provider.lists.some((item) => item.id === id)) && (targeting.selection.tag !== "visitor_choice" || choices.length === ids.length);
-}
-function mailchimpTargetIsAvailable(provider, targeting, choices) {
-	const audience = provider.audiences.find((item) => item.id === targeting.audienceId);
-	if (!audience) return false;
-	const ids = targeting.selection.tag === "fixed" ? targeting.selection.interestIds : targeting.selection.offeredInterestIds;
-	return ids.every((id) => audience.interests.some((item) => item.id === id)) && (targeting.selection.tag !== "visitor_choice" || choices.length === ids.length);
+function resolveRuntimeChoices(assessment) {
+	if (!("value" in assessment) || assessment.value.mode !== "custom" || !("selectedChoices" in assessment.value) || assessment.value.targeting.selection.tag !== "visitor_choice") return [];
+	return assessment.value.selectedChoices.map((item) => ({
+		id: String(item.id),
+		label: item.name
+	}));
 }
 function buildNewsletterFormInteractiveIslandProps(props) {
 	const decoded = newsletterFormBlockRuntime.contracts.source.decode(props);
@@ -50325,6 +51015,15 @@ function parseRequiredMailingListSignedSourceToken(value) {
 	return parsed;
 }
 //#endregion
+//#region ../blocks/src/system/helpers/normalizeMailingListBlockContent.ts
+/** Fill the declared default without admitting or rewriting invalid custom settings. */
+function normalizeMailingListBlockContent(record) {
+	return record.targeting == null ? {
+		...record,
+		targeting: DEFAULT_MAILING_LIST_TARGETING
+	} : record;
+}
+//#endregion
 //#region ../blocks/src/system/blocks/newsletter-signup.ts
 const stackedComposition = composeFragments([{ fragment: newsletterCopyFragment }, { fragment: newsletterFormFragment }]);
 const stackedLayout$1 = styledSection({
@@ -50421,6 +51120,10 @@ function sanitizeNewsletterSignupPublicContent(content) {
 }
 const newsletterSignupBlockDefinition = {
 	manifest: newsletterSignupManifest,
+	contentNormalizer: {
+		fieldIds: ["targeting"],
+		normalize: normalizeMailingListBlockContent
+	},
 	runtime: newsletterFormBlockRuntime
 };
 const productDetailBlockDefinition = {
@@ -51669,6 +52372,7 @@ function dateLabel(key, timeZone) {
 }
 function MonthDay(props) {
 	const { day, selection } = props;
+	const { controls } = selection;
 	const selected = day.dateKey === selection.selectedDay;
 	return /* @__PURE__ */ jsxs("div", {
 		"data-slot": "date",
@@ -51680,7 +52384,7 @@ function MonthDay(props) {
 			"data-slot": "control",
 			"aria-label": `Show events on ${dateLabel(day.dateKey, selection.timeZone)}`,
 			"aria-pressed": selected,
-			onClick: () => selection.onSelectDay?.(day.dateKey),
+			onClick: controls ? () => controls.selectDay(day.dateKey) : void 0,
 			children: day.date.day
 		}) : /* @__PURE__ */ jsx("span", {
 			"data-slot": "date-label",
@@ -51693,7 +52397,7 @@ function MonthDay(props) {
 			type: "button",
 			className: "event-calendar-more",
 			"data-slot": "more",
-			onClick: () => selection.onOpenDay?.(day.date, day.entries.map(({ event }) => event)),
+			onClick: controls ? () => controls.openDay(day.date, day.entries.map(({ event }) => event)) : void 0,
 			children: [
 				"+",
 				day.moreCount,
@@ -52854,10 +53558,219 @@ function RegistrationClosedState({ title, body }) {
 	});
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration.server.tsx
-function cx(...classes) {
-	return classes.filter((className) => Boolean(className)).join(" ");
+//#region ../blocks/src/system/runtime/nodes/event-registration/BookingEntryViews.tsx
+function joinFacts(facts) {
+	return facts.filter((fact) => Boolean(fact)).join(" · ");
+}
+function finishedTitle(entry) {
+	if (entry.kind === "waitlisted") return entry.when ? `You’re on the waitlist for ${entry.when}` : "You’re on the waitlist";
+	return entry.when ? `You’re booked: ${entry.when}` : "You’re booked";
+}
+function CheckBadge() {
+	return /* @__PURE__ */ jsx("span", {
+		className: "er-booking-card__badge",
+		"aria-hidden": "true",
+		children: /* @__PURE__ */ jsx("svg", {
+			width: "22",
+			height: "22",
+			viewBox: "0 0 22 22",
+			fill: "none",
+			stroke: "currentColor",
+			strokeWidth: "2.6",
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			children: /* @__PURE__ */ jsx("path", { d: "M5 11.5l4 4L17 7" })
+		})
+	});
+}
+function CardCta(props) {
+	return /* @__PURE__ */ jsx(ThemedButton, {
+		type: "button",
+		variant: props.variant,
+		size: "md",
+		extraClassName: "er-booking-card__cta",
+		label: props.label,
+		onClick: props.onClick
+	});
+}
+function SingleCard({ entry, buttonVariant, onAction }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "er-booking-card",
+		"data-entry": "single",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "er-booking-card__row",
+			children: [
+				entry.tile ? /* @__PURE__ */ jsxs("span", {
+					className: "er-booking-card__tile",
+					"aria-hidden": "true",
+					children: [/* @__PURE__ */ jsx("span", {
+						className: "er-booking-card__tile-month",
+						children: entry.tile.month
+					}), /* @__PURE__ */ jsx("span", {
+						className: "er-booking-card__tile-day",
+						children: entry.tile.day
+					})]
+				}) : null,
+				/* @__PURE__ */ jsxs("div", {
+					className: "er-booking-card__body",
+					children: [
+						entry.when ? /* @__PURE__ */ jsx("p", {
+							className: "er-booking-card__when",
+							children: entry.when
+						}) : null,
+						entry.venue ? /* @__PURE__ */ jsx("p", {
+							className: "er-booking-card__venue",
+							children: entry.venue
+						}) : null,
+						/* @__PURE__ */ jsx("p", {
+							className: "er-booking-card__facts",
+							children: joinFacts([entry.price, entry.places])
+						})
+					]
+				}),
+				/* @__PURE__ */ jsx(CardCta, {
+					label: entry.action,
+					variant: buttonVariant,
+					onClick: onAction
+				})
+			]
+		})
+	});
+}
+function ChooseDateCard({ entry, buttonVariant, onAction, onChooseDate }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "er-booking-card",
+		"data-entry": "choose-date",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "er-booking-card__row",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "er-booking-card__body",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "er-booking-card__when",
+					children: joinFacts([entry.schedule, entry.venue])
+				}), /* @__PURE__ */ jsx("p", {
+					className: "er-booking-card__facts",
+					children: joinFacts([entry.price])
+				})]
+			}), /* @__PURE__ */ jsx(CardCta, {
+				label: entry.action,
+				variant: buttonVariant,
+				onClick: onAction
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "er-booking-card__dates",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: "er-booking-card__dates-label",
+					children: "Next dates"
+				}),
+				entry.dates.map((date) => /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "er-booking-card__date",
+					"data-full": date.full ? "true" : void 0,
+					onClick: onChooseDate ? () => onChooseDate(date.selectionId) : void 0,
+					children: joinFacts([date.label, date.places])
+				}, date.selectionId)),
+				entry.moreCount > 0 ? /* @__PURE__ */ jsxs("span", {
+					className: "er-booking-card__more",
+					children: [
+						"+ ",
+						entry.moreCount,
+						" more"
+					]
+				}) : null
+			]
+		})]
+	});
+}
+function ChooseEventCard({ entry, buttonVariant, onAction }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "er-booking-card",
+		"data-entry": "choose-event",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "er-booking-card__row",
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "er-booking-card__body",
+				children: /* @__PURE__ */ jsx("p", {
+					className: "er-booking-card__when",
+					children: `${entry.count} ${entry.noun}`
+				})
+			}), /* @__PURE__ */ jsx(CardCta, {
+				label: entry.action,
+				variant: buttonVariant,
+				onClick: onAction
+			})]
+		})
+	});
+}
+function FinishedCard({ entry, onAction }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "er-booking-card",
+		"data-entry": entry.kind,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "er-booking-card__row",
+			children: [
+				/* @__PURE__ */ jsx(CheckBadge, {}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "er-booking-card__body",
+					children: [/* @__PURE__ */ jsx("p", {
+						className: "er-booking-card__when",
+						children: finishedTitle(entry)
+					}), entry.kind === "booked" && entry.places ? /* @__PURE__ */ jsx("p", {
+						className: "er-booking-card__facts",
+						children: entry.places
+					}) : null]
+				}),
+				/* @__PURE__ */ jsx(CardCta, {
+					label: entry.action,
+					variant: "outline",
+					onClick: onAction
+				})
+			]
+		})
+	});
+}
+function BookingEntryCard(props) {
+	const { entry, ...rest } = props;
+	switch (entry.kind) {
+		case "single": return /* @__PURE__ */ jsx(SingleCard, {
+			entry,
+			...rest
+		});
+		case "chooseDate": return /* @__PURE__ */ jsx(ChooseDateCard, {
+			entry,
+			...rest
+		});
+		case "chooseEvent": return /* @__PURE__ */ jsx(ChooseEventCard, {
+			entry,
+			...rest
+		});
+		case "inProgress": return null;
+		case "booked":
+		case "waitlisted": return /* @__PURE__ */ jsx(FinishedCard, {
+			entry,
+			...rest
+		});
+		default: return assertNever$3(entry);
+	}
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/StepIndicator.tsx
+/**
+* Step indicator component for the event registration wizard.
+* Thin wrapper around the shared StepIndicator: styled by the shared
+* registration-surface classes, with 'er'-prefixed classes kept in the
+* markup as the stable hook surface for per-site theme CSS.
+*/
+function StepIndicator(props) {
+	return /* @__PURE__ */ jsx(StepIndicator$1, {
+		...props,
+		classPrefix: "er",
+		emitSharedClasses: true
+	});
 }
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration.server.tsx
 /**
 * Server-safe placeholder for event registration.
 * Provides a static container for island hydration without importing client hooks.
@@ -52879,7 +53792,13 @@ function EventRegistrationSSR({ blockId, subject, loaderFailures, children, ...s
 		...getIslandRootProps("event-registration", blockId),
 		children: [
 			/* @__PURE__ */ jsx(IslandPropsScript, { value: islandProps }),
-			/* @__PURE__ */ jsx(EventRegistrationShell, { display }),
+			display.state === "booking-card" ? /* @__PURE__ */ jsx("div", {
+				id: EVENT_REGISTRATION_ANCHOR_ID,
+				children: /* @__PURE__ */ jsx(BookingEntryCard, {
+					entry: display.entry,
+					buttonVariant: display.buttonVariant ?? "primary"
+				})
+			}) : /* @__PURE__ */ jsx(EventRegistrationShell, { display }),
 			children
 		]
 	});
@@ -52899,27 +53818,12 @@ function EventRegistrationShell({ display }) {
 			children: [/* @__PURE__ */ jsxs("div", {
 				className: "er-payment-layout-main",
 				children: [/* @__PURE__ */ jsx("div", {
-					className: "rb-steps-nav er-steps-nav er-registration-shell__steps",
+					className: "er-registration-shell__steps",
 					"aria-hidden": "true",
-					children: /* @__PURE__ */ jsx("ol", {
-						className: "rb-steps er-steps",
-						children: display.stepLabels.map((label, index) => {
-							const isActive = index === 0;
-							return /* @__PURE__ */ jsxs("li", {
-								className: "rb-step er-step",
-								children: [
-									/* @__PURE__ */ jsx("span", {
-										className: cx("rb-step-circle er-step-circle", isActive && "rb-step-circle--active er-step-circle--active"),
-										children: index + 1
-									}),
-									/* @__PURE__ */ jsx("span", {
-										className: cx("rb-step-label er-step-label", isActive && "rb-step-label--active er-step-label--active"),
-										children: label
-									}),
-									index < display.stepLabels.length - 1 ? /* @__PURE__ */ jsx("span", { className: "rb-step-connector er-step-connector" }) : null
-								]
-							}, label);
-						})
+					children: /* @__PURE__ */ jsx(StepIndicator, {
+						currentStep: 1,
+						totalSteps: display.stepLabels.length,
+						stepLabels: [...display.stepLabels]
 					})
 				}), /* @__PURE__ */ jsxs("div", {
 					className: "rb-reg-stack er-stack",
@@ -54851,7 +55755,7 @@ const opaquePanels = [
 		}
 	},
 	{
-		selector: ":where([data-block='event-registration']) .er-booking-teaser",
+		selector: ":where([data-block='event-registration']) .er-booking-card",
 		paint: {
 			kind: "solid",
 			token: "surface"
@@ -54861,7 +55765,7 @@ const opaquePanels = [
 		selector: ":where([data-block='event-registration']) .er-booking-bar",
 		paint: {
 			kind: "solid",
-			token: "background"
+			token: "surface"
 		}
 	},
 	{
@@ -54875,7 +55779,7 @@ const opaquePanels = [
 		selector: ":where([data-block='event-registration']) .er-booking-overlay__panel",
 		paint: {
 			kind: "solid",
-			token: "background"
+			token: "surface"
 		}
 	},
 	{
@@ -56032,25 +56936,25 @@ ${root} .alert {
 
 ${root} .alert-error {
   border-color: rgb(var(--tb-destructive));
-  background-color: rgba(var(--tb-destructive), 0.1);
+  background-color: rgb(var(--tb-destructive) / 0.1);
   color: rgb(var(--tb-destructive));
 }
 
 ${root} .alert-success {
   border-color: rgb(var(--tb-success));
-  background-color: rgba(var(--tb-success), 0.1);
+  background-color: rgb(var(--tb-success) / 0.1);
   color: rgb(var(--tb-success));
 }
 
 ${root} .alert-warning {
   border-color: rgb(var(--tb-warning));
-  background-color: rgba(var(--tb-warning), 0.1);
+  background-color: rgb(var(--tb-warning) / 0.1);
   color: rgb(var(--tb-warning));
 }
 
 ${root} .alert-info {
   border-color: rgb(var(--tb-info));
-  background-color: rgba(var(--tb-info), 0.1);
+  background-color: rgb(var(--tb-info) / 0.1);
   color: rgb(var(--tb-info));
 }`);
 	cssBlocks.push(`/* Field-note feedback treatment */
@@ -56164,7 +57068,7 @@ ${root} .step-dot-active {
 }
 
 ${root} .step-dot-complete {
-  background-color: rgba(var(--tb-primary), 0.6);
+  background-color: rgb(var(--tb-primary) / 0.6);
 }`);
 	cssBlocks.push(`/* Step circles (numbered) */
 ${root} .step-circle {
@@ -56187,7 +57091,7 @@ ${root} .step-circle-active {
 }
 
 ${root} .step-circle-complete {
-  background-color: rgba(var(--tb-primary), 0.6);
+  background-color: rgb(var(--tb-primary) / 0.6);
   color: rgb(var(--tb-primaryForeground));
 }`);
 	cssBlocks.push(`/* Step connector */
@@ -56369,62 +57273,52 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="event-registratio
   --er-control-bg: rgb(var(--tb-background, var(--tb-surface)));
   --er-control-text: rgb(var(--tb-foreground, var(--tb-text)));
   --er-radius: var(--rb-block-radius);
-  --er-surface-muted: rgba(var(--tb-muted, 241 245 249), 0.42);
-  --er-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
+  --er-surface-muted: rgb(var(--tb-muted, 241 245 249) / 0.42);
+  --er-shell-line: rgb(var(--tb-mutedText, 100 116 139) / 0.22);
 
   /* Step indicator */
   --er-step-active: rgb(var(--tb-primary));
-  --er-step-inactive: rgb(var(--tb-mutedText));
-  --er-step-completed: rgb(var(--tb-success));
-  --er-step-text: rgb(255 255 255);
-  --er-step-text-active: rgb(var(--tb-onPrimary, 255 255 255));
-  --er-step-connector: rgba(var(--tb-border), 0.5);
 
   /* Step title */
-  --er-step-title-size: 1.5rem;
+  --er-step-title-size: 1.75rem;
 
   /* State backgrounds with alpha */
-  --er-success-bg: rgba(var(--tb-success), 0.1);
-  --er-success-text: rgb(var(--tb-success));
-  --er-info-bg: rgba(var(--tb-primary), 0.1);
+  --er-info-bg: rgb(var(--tb-primary) / 0.1);
   --er-info-text: rgb(var(--tb-primary));
-  --er-error-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --er-error-bg: rgb(var(--tb-destructive, 239 68 68) / 0.1);
   --er-error-text: rgb(var(--tb-destructive, 239 68 68));
-  --er-waitlist-bg: rgba(var(--tb-warning), 0.1);
+  --er-waitlist-bg: rgb(var(--tb-warning) / 0.1);
   --er-waitlist-text: rgb(var(--tb-warning));
 
   /* Capacity badges */
-  --er-capacity-available-bg: rgba(var(--tb-success), 0.1);
+  --er-capacity-available-bg: rgb(var(--tb-success) / 0.1);
   --er-capacity-available-text: rgb(var(--tb-success));
-  --er-capacity-low-bg: rgba(var(--tb-warning), 0.1);
+  --er-capacity-low-bg: rgb(var(--tb-warning) / 0.1);
   --er-capacity-low-text: rgb(var(--tb-warning));
-  --er-capacity-soldout-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --er-capacity-soldout-bg: rgb(var(--tb-destructive, 239 68 68) / 0.1);
   --er-capacity-soldout-text: rgb(var(--tb-destructive, 239 68 68));
 
   /* Borders */
   --er-border: rgb(var(--tb-border));
-  --er-border-hover: rgba(var(--tb-primary), 0.5);
+  --er-border-hover: rgb(var(--tb-primary) / 0.5);
   --er-border-selected: rgb(var(--tb-primary));
   --er-border-error: rgb(var(--tb-destructive, 239 68 68));
 
   /* Input focus */
-  --er-focus-ring: rgba(var(--tb-primary), 0.3);
-
-  /* Required marker */
-  --er-required: rgb(var(--tb-destructive, 239 68 68));
+  --er-focus-ring: rgb(var(--tb-primary) / 0.3);
 
   /* Payment option cards */
   --er-payment-border: rgb(var(--tb-border));
-  --er-payment-border-hover: rgba(var(--tb-primary), 0.5);
+  --er-payment-border-hover: rgb(var(--tb-primary) / 0.5);
   --er-payment-border-selected: rgb(var(--tb-primary));
-  --er-payment-bg-selected: rgba(var(--tb-primary), 0.08);
+  --er-payment-bg-selected: rgb(var(--tb-primary) / 0.08);
 
   /* Checkmark indicator */
   --er-check-bg: rgb(var(--tb-primary));
   --er-check-text: rgb(var(--tb-onPrimary, 255 255 255));
 
   /* Order summary */
-  --er-summary-bg: rgba(var(--tb-primary), 0.1);
+  --er-summary-bg: rgb(var(--tb-primary) / 0.1);
   --er-summary-border: rgb(var(--tb-border));
 
   /* Shared registration-surface mappings (issue 1174).
@@ -56436,7 +57330,7 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="event-registratio
   --rb-reg-border-selected: var(--er-border-selected);
   --rb-reg-bg-selected: var(--er-payment-bg-selected);
   --rb-reg-option-bg: var(--er-control-bg);
-  --rb-reg-option-hover-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  --rb-reg-option-hover-shadow: 0 8px 18px rgb(var(--tb-shadow, 15 23 42) / 0.08);
   --rb-reg-surface-bg: rgb(var(--tb-surface));
   --rb-reg-on-surface: var(--er-on-surface);
   --rb-reg-on-surface-muted: var(--er-on-surface-muted);
@@ -56445,11 +57339,6 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="event-registratio
   --rb-reg-check-bg: var(--er-check-bg);
   --rb-reg-check-text: var(--er-check-text);
   --rb-reg-step-active: var(--er-step-active);
-  --rb-reg-step-completed: var(--er-step-completed);
-  --rb-reg-step-inactive: var(--er-step-inactive);
-  --rb-reg-step-text: var(--er-step-text);
-  --rb-reg-step-text-active: var(--er-step-text-active);
-  --rb-reg-step-connector: var(--er-step-connector);
   --rb-reg-summary-bg: var(--er-surface-muted);
   --rb-reg-summary-border: var(--er-border);
   --rb-reg-focus-ring: var(--er-focus-ring);
@@ -56496,13 +57385,13 @@ function generateEventCalendarVars({ themeId }) {
 	return `
 ${`:where([data-theme-scope="${themeId}"]) :where([data-block="event-calendar"])`} {
   /* Day cell states */
-  --ec-today-bg: rgba(var(--tb-primary), 0.05);
+  --ec-today-bg: rgb(var(--tb-primary) / 0.05);
   --ec-today-text: rgb(var(--tb-primary));
   --ec-other-month-opacity: 0.4;
 
   /* Event items - subtle style (legacy) */
-  --ec-event-bg: rgba(var(--tb-primary), 0.1);
-  --ec-event-hover-bg: rgba(var(--tb-primary), 0.2);
+  --ec-event-bg: rgb(var(--tb-primary) / 0.1);
+  --ec-event-hover-bg: rgb(var(--tb-primary) / 0.2);
 
   /* Event items - solid style (default) */
   --ec-event-solid-bg: rgb(var(--tb-primary));
@@ -56510,15 +57399,15 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="event-calendar"])
   --ec-event-solid-text: rgb(var(--tb-neutral-50, 255 255 255));
 
   /* Navigation */
-  --ec-nav-hover-bg: rgba(var(--tb-text), 0.1);
+  --ec-nav-hover-bg: rgb(var(--tb-text) / 0.1);
 
   /* Day headers */
-  --ec-header-bg: rgba(var(--tb-text), 0.05);
+  --ec-header-bg: rgb(var(--tb-text) / 0.05);
   --ec-header-opacity: 0.7;
 
   /* Borders */
   --ec-border: rgb(var(--tb-border));
-  --ec-border-subtle: rgba(var(--tb-border), 0.5);
+  --ec-border-subtle: rgb(var(--tb-border) / 0.5);
 
   /* Surface and text (for inputs/dropdowns) */
   --ec-surface: rgb(var(--tb-surface));
@@ -56587,29 +57476,27 @@ function generateAppointmentBookingVars({ themeId }) {
 ${`:where([data-theme-scope="${themeId}"]) :where([data-block="appointment-booking"])`} {
   /* Selection cards (service/resource/time) */
   --ab-card-border: rgb(var(--tb-border));
-  --ab-card-border-hover: rgba(var(--tb-primary), 0.5);
+  --ab-card-border-hover: rgb(var(--tb-primary) / 0.5);
   --ab-card-border-selected: rgb(var(--tb-primary));
-  --ab-card-bg-selected: rgba(var(--tb-primary), 0.05);
+  --ab-card-bg-selected: rgb(var(--tb-primary) / 0.05);
 
   /* Checkmark indicator */
   --ab-check-bg: rgb(var(--tb-primary));
   --ab-check-text: rgb(var(--tb-background));
 
   /* State backgrounds */
-  --ab-success-bg: rgba(var(--tb-success), 0.1);
-  --ab-success-text: rgb(var(--tb-success));
-  --ab-error-bg: rgba(var(--tb-destructive), 0.1);
+  --ab-error-bg: rgb(var(--tb-destructive) / 0.1);
   --ab-error-text: rgb(var(--tb-destructive));
-  --ab-warning-bg: rgba(var(--tb-warning), 0.1);
+  --ab-warning-bg: rgb(var(--tb-warning) / 0.1);
   --ab-warning-text: rgb(var(--tb-warning));
-  --ab-info-bg: rgba(var(--tb-info), 0.1);
+  --ab-info-bg: rgb(var(--tb-info) / 0.1);
   --ab-info-text: rgb(var(--tb-info));
 
   /* Muted summary state */
-  --ab-muted-bg: rgba(var(--tb-text), 0.05);
+  --ab-muted-bg: rgb(var(--tb-text) / 0.05);
 
   /* Focus ring used by shared registration-surface controls */
-  --ab-input-focus-ring: rgba(var(--tb-primary), 0.3);
+  --ab-input-focus-ring: rgb(var(--tb-primary) / 0.3);
 
   /* Shared registration-surface mappings (issue 1174).
      Route the shared --rb-reg-* contract through this block's Tier 3 vars
@@ -56621,24 +57508,19 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="appointment-booki
   --rb-reg-border-selected: var(--ab-card-border-selected);
   --rb-reg-bg-selected: var(--ab-card-bg-selected);
   --rb-reg-option-bg: transparent;
-  --rb-reg-option-hover-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  --rb-reg-option-hover-shadow: 0 8px 18px rgb(var(--tb-shadow, 15 23 42) / 0.08);
   --rb-reg-surface-bg: rgb(var(--tb-surface));
   --rb-reg-on-surface: rgb(var(--tb-onSurface, var(--tb-text)));
-  --rb-reg-on-surface-muted: rgba(var(--tb-onSurface, var(--tb-text)), 0.7);
-  --rb-reg-on-surface-subtle: rgba(var(--tb-onSurface, var(--tb-text)), 0.6);
-  --rb-reg-on-surface-faint: rgba(var(--tb-onSurface, var(--tb-text)), 0.5);
+  --rb-reg-on-surface-muted: rgb(var(--tb-onSurface, var(--tb-text)) / 0.7);
+  --rb-reg-on-surface-subtle: rgb(var(--tb-onSurface, var(--tb-text)) / 0.6);
+  --rb-reg-on-surface-faint: rgb(var(--tb-onSurface, var(--tb-text)) / 0.5);
   --rb-reg-check-bg: var(--ab-check-bg);
   --rb-reg-check-text: var(--ab-check-text);
   --rb-reg-step-active: rgb(var(--tb-primary));
-  --rb-reg-step-completed: rgb(var(--tb-success));
-  --rb-reg-step-inactive: rgb(var(--tb-mutedText));
-  --rb-reg-step-text: rgb(255 255 255);
-  --rb-reg-step-text-active: rgb(var(--tb-onPrimary, 255 255 255));
-  --rb-reg-step-connector: rgba(var(--tb-border), 0.5);
   --rb-reg-summary-bg: var(--ab-muted-bg);
   --rb-reg-summary-border: var(--ab-card-border);
   --rb-reg-focus-ring: var(--ab-input-focus-ring);
-  --rb-reg-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
+  --rb-reg-shell-line: rgb(var(--tb-mutedText, 100 116 139) / 0.22);
 }
 `;
 }
@@ -56657,14 +57539,14 @@ function generateFormBlockVars({ themeId }) {
 	return `
 ${`:where([data-theme-scope="${themeId}"]) :where([data-block="form"])`} {
   /* Success state */
-  --fb-success-bg: rgba(var(--tb-success), 0.1);
+  --fb-success-bg: rgb(var(--tb-success) / 0.1);
   --fb-success-text: rgb(var(--tb-success));
-  --fb-success-border: rgba(var(--tb-success), 0.3);
+  --fb-success-border: rgb(var(--tb-success) / 0.3);
 
   /* Error state */
-  --fb-error-bg: rgba(var(--tb-destructive), 0.1);
+  --fb-error-bg: rgb(var(--tb-destructive) / 0.1);
   --fb-error-text: rgb(var(--tb-destructive));
-  --fb-error-border: rgba(var(--tb-destructive), 0.3);
+  --fb-error-border: rgb(var(--tb-destructive) / 0.3);
 
   /* Empty state */
   --fb-empty-bg: rgb(var(--tb-surface));
@@ -56725,23 +57607,23 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="customer-portal"]
   --rb-tab-opacity: 0.7;
 
   /* Badge - Success (active, confirmed) */
-  --cp-badge-success-bg: rgba(var(--tb-success), 0.1);
+  --cp-badge-success-bg: rgb(var(--tb-success) / 0.1);
   --cp-badge-success-text: rgb(var(--tb-success));
 
   /* Badge - Warning (paused, low credits, waitlist) */
-  --cp-badge-warning-bg: rgba(var(--tb-warning), 0.1);
+  --cp-badge-warning-bg: rgb(var(--tb-warning) / 0.1);
   --cp-badge-warning-text: rgb(var(--tb-warning));
 
   /* Badge - Error (canceled, expired, past_due) */
-  --cp-badge-error-bg: rgba(var(--tb-destructive), 0.1);
+  --cp-badge-error-bg: rgb(var(--tb-destructive) / 0.1);
   --cp-badge-error-text: rgb(var(--tb-destructive));
 
   /* Badge - Info (trialing, scheduled) */
-  --cp-badge-info-bg: rgba(var(--tb-primary), 0.1);
+  --cp-badge-info-bg: rgb(var(--tb-primary) / 0.1);
   --cp-badge-info-text: rgb(var(--tb-primary));
 
   /* Badge - Default (neutral states) */
-  --cp-badge-default-bg: rgba(var(--tb-mutedText), 0.1);
+  --cp-badge-default-bg: rgb(var(--tb-mutedText) / 0.1);
   --cp-badge-default-text: rgb(var(--tb-mutedText));
 
   /* Progress bar (for credit display) */
@@ -56753,10 +57635,10 @@ ${`:where([data-theme-scope="${themeId}"]) :where([data-block="customer-portal"]
   --cp-card-border: rgb(var(--tb-border));
 
   /* Alert/notification */
-  --cp-alert-success-bg: rgba(var(--tb-success), 0.1);
+  --cp-alert-success-bg: rgb(var(--tb-success) / 0.1);
   --cp-alert-success-text: rgb(var(--tb-success));
   --cp-alert-success-border: rgb(var(--tb-success));
-  --cp-alert-error-bg: rgba(var(--tb-destructive), 0.1);
+  --cp-alert-error-bg: rgb(var(--tb-destructive) / 0.1);
   --cp-alert-error-text: rgb(var(--tb-destructive));
   --cp-alert-error-border: rgb(var(--tb-destructive));
 
@@ -56853,7 +57735,7 @@ ${root} {
   --rb-testimonial-carousel-arrow-bg: rgb(var(--tb-secondary));
   --rb-testimonial-carousel-arrow-bg-hover: color-mix(in oklab, rgb(var(--tb-secondary)), rgb(var(--tb-text)) 14%);
   --rb-testimonial-carousel-arrow-color: rgb(var(--tb-onSecondary));
-  --rb-testimonial-carousel-arrow-border-color: rgba(var(--tb-onSecondary), 0.22);
+  --rb-testimonial-carousel-arrow-border-color: rgb(var(--tb-onSecondary) / 0.22);
   --rb-testimonial-carousel-arrow-size: 2.75rem;
   --rb-testimonial-carousel-arrow-icon-size: 1.25rem;
   --rb-testimonial-carousel-arrow-icon-stroke-width: 2.5;
@@ -58110,7 +58992,7 @@ function pageBlockPosition(index, blockCount) {
 //#endregion
 //#region ../blocks/src/pageRendererContracts.ts
 function buildPageRendererRootRuntime(dataContext) {
-	const { siteId = null, siteName, pageId = null, pathname = null, bookingTimeZone, previewStage = "published", apiBaseUrl = null, portalToken = null, readAuthority, bookingOfferingPresets = [], appointmentServicePathPrefix = null, mailingList = { tag: "not_configured" }, eventRegistrationOverlayEnabled = false, loaderFailures = {} } = dataContext ?? {};
+	const { siteId = null, siteName, pageId = null, pathname = null, bookingTimeZone, previewStage = "published", apiBaseUrl = null, portalToken = null, readAuthority, bookingOfferingPresets = [], appointmentServicePathPrefix = null, mailingList = { tag: "not_configured" }, loaderFailures = {} } = dataContext ?? {};
 	return {
 		siteId,
 		demoEmailSuppressed: resolveDemoEmailSuppression(dataContext),
@@ -58125,7 +59007,6 @@ function buildPageRendererRootRuntime(dataContext) {
 		bookingOfferingPresets,
 		appointmentServicePathPrefix,
 		mailingList,
-		eventRegistrationOverlayEnabled,
 		loaderFailures
 	};
 }
@@ -60966,6 +61847,10 @@ const contactNewsletterBlockDefinition = {
 		],
 		icon: "MailPlus"
 	}),
+	contentNormalizer: {
+		fieldIds: ["targeting"],
+		normalize: normalizeMailingListBlockContent
+	},
 	dataSchemas: { form: formDataSchema.optional() },
 	dataLoaders: { form: {
 		endpoint: "getPublicFormById",
@@ -64890,7 +65775,22 @@ const offeringsPreviewEventDataSchemas = Object.fromEntries(OFFERINGS_PREVIEW_EV
 const offeringsPreviewEventDataLoaders = Object.fromEntries(OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => [definition.dataKey, eventPresetLoader(definition.preset)]));
 const offeringsPreviewBlockDefinition = {
 	manifest: offeringsPreviewManifest,
-	normalizeContent: normalizeOfferingsPreviewBlockContent,
+	contentNormalizer: {
+		fieldIds: [
+			"displayMode",
+			"heading",
+			"description",
+			"itemLimit",
+			"groupOrder",
+			"groupOverrides",
+			"_cardStyles",
+			"buttonVariant",
+			"buttonText",
+			"emptyMessage",
+			"_sectionStyles"
+		],
+		normalize: normalizeOfferingsPreviewBlockContent
+	},
 	dataSchemas: {
 		...offeringsPreviewEventDataSchemas,
 		routeCandidates: publicRouteCandidatesSchema.optional(),
@@ -67128,7 +68028,20 @@ const locationMapBlockDefinition = {
 			})], { gap: "md" })
 		})
 	}),
-	normalizeContent: normalizeLocationMapContent
+	contentNormalizer: {
+		fieldIds: [
+			"heading",
+			"locationSource",
+			"venueId",
+			"location",
+			"showAddressText",
+			"showDirections",
+			"directionsLabel",
+			"zoom",
+			"heightPx"
+		],
+		normalize: normalizeLocationMapContent
+	}
 };
 //#endregion
 //#region ../blocks/src/system/blocks/index.ts
@@ -67920,6 +68833,16 @@ function ensureSystemBlockDefinitionsRegistered() {
 }
 //#endregion
 //#region ../blocks/src/system/registry.ts
+function normalizeBlockContent(definition, content) {
+	const normalizer = definition?.contentNormalizer;
+	if (!normalizer || !isRecord$13(content)) return content;
+	const normalized = normalizer.normalize(content);
+	const owned = new Set(normalizer.fieldIds);
+	return {
+		...Object.fromEntries(Object.entries(content).filter(([key]) => !owned.has(key))),
+		...Object.fromEntries(Object.entries(normalized).filter(([key]) => owned.has(key)))
+	};
+}
 const REGISTRY_SYMBOL = Symbol.for("@riverbankcms/blocks/system/definitions");
 const isBlocksTestRuntime = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.RIVERBANK_BLOCKS_TEST === "1";
 const globalScope = globalThis;
@@ -68893,7 +69816,7 @@ function planNewsletterBlockSubmission(placement) {
 function planNewsletterPreviewSubmission(placement) {
 	if (!placement.publishedContentId) return { tag: "unpublished-form" };
 	if (!placement.publishedContent) return { tag: "unpublished-settings" };
-	const draft = parseMailingListPlacementTargeting(placement.renderedContent.targeting ?? { mode: "default" });
+	const draft = parseMailingListPlacementTargeting(placement.renderedContent.targeting);
 	const published = parseMailingListPlacementTargeting(placement.publishedContent.targeting);
 	if (!draft.ok || !published.ok || !sameMailingListPlacementTargeting(draft.value, published.value)) return { tag: "unpublished-settings" };
 	const sourceRef = buildMailingListSignupBlockSourceRef(placement.blockId, placement.publishedContentId);
@@ -69013,7 +69936,8 @@ function preparedBlockProps(entry, content, data, input) {
 			block: entry.block,
 			themeResources: input.themeResources,
 			dataContext: input.dataContext,
-			imageResolveContext: input.imageResolveContext
+			imageResolveContext: input.imageResolveContext,
+			routeMap: input.routeMap
 		}),
 		bookingTimeZone: input.dataContext?.bookingTimeZone
 	};
@@ -69033,6 +69957,12 @@ function buildBlockOverrideProps(input) {
 		...blockSessionProps(dataContext),
 		...blockSubjectProps(dataContext),
 		imageResolveContext: input.imageResolveContext,
+		linkResolveContext: {
+			routes: input.routeMap ?? dataContext?.routes,
+			pagesByIdentifier: dataContext?.pagesByIdentifier,
+			entriesByIdentifier: dataContext?.entriesByIdentifier,
+			stage: dataContext?.previewStage
+		},
 		blockId: block.id ?? null,
 		contentVersionId: block.contentVersionId ?? null,
 		...newsletterBlockProps(block, input.content, dataContext?.previewStage),
@@ -69089,7 +70019,7 @@ function arrangementResolvedData(kind, content, data) {
 function arrangementResolvedContent(kind, content, data, context) {
 	if (content._effectiveLook === void 0 || !data || kind !== "block.offerings-preview" && kind !== "block.appointment-services") return content;
 	if (kind === "block.appointment-services") return appointmentArrangementContent(content, data, context);
-	const normalized = offeringsPreviewBlockDefinition.normalizeContent?.(content);
+	const normalized = normalizeBlockContent(offeringsPreviewBlockDefinition, content);
 	return withCardListPhotoCount(content, content.showPhotos === false ? 0 : offeringsPreviewPhotoCount({
 		...normalized,
 		presets: context?.bookingOfferingPresets,
@@ -69506,13 +70436,11 @@ function renderSystemBlockElement(input) {
 * referential equality of all props that affect rendering. Standard React.memo
 * wouldn't catch all the render triggers from the editor store.
 */
-const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources, entry: preparedEntry, audience, dataContext, registry, wrapBlock, imageResolveContext, previewAuthoring }) {
-	const entry = preparedEntry.entry;
-	const prepared = preparedEntry.prepared;
+const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources, entry: preparedEntry, routeMap, audience, dataContext, registry, wrapBlock, imageResolveContext, previewAuthoring }) {
+	const { entry, prepared } = preparedEntry;
 	const block = entry.block;
 	const perfStart = globalThis.process?.env?.DEBUG_PERF === "1" && typeof window === "undefined" ? Date.now() : 0;
-	const fallbackImageResolveContext = getCurrentResolveImageUrlContext();
-	const resolvedImageResolveContext = imageResolveContext ?? fallbackImageResolveContext;
+	const resolvedImageResolveContext = imageResolveContext ?? getCurrentResolveImageUrlContext();
 	function finish(node, meta) {
 		if (!perfStart) return node;
 		const durationMs = Date.now() - perfStart;
@@ -69552,7 +70480,8 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 			block,
 			themeResources,
 			dataContext,
-			imageResolveContext: resolvedImageResolveContext
+			imageResolveContext: resolvedImageResolveContext,
+			routeMap
 		}) })), {
 			outcome: "overrideWithoutDefinition",
 			override: true,
@@ -70443,6 +71372,13 @@ const containerResponsiveThemeCss = `/*
         var(--site-overlay-opening-content-extra-pad, clamp(1rem, 2vw, 1.75rem))
     );
   }
+  /* Floating site overlays (a booking bar, a cookie banner, a sticky promo)
+     mark themselves [data-rb-site-overlay]. While a preview is in edit mode
+     (the preview shell sets the root attribute) they step aside, out of the
+     focus order too; switching back to viewing restores them as they were. */
+  :root[data-rb-preview-mode="edit"] [data-rb-site-overlay] {
+    display: none;
+  }
   .rb-preview-editor-offset {
     padding-bottom: calc(
       var(--builder-editor-chrome-offset, 0px) +
@@ -71028,7 +71964,7 @@ const containerResponsiveThemeCss = `/*
   .rb-spinner {
     --rb-spinner-size: 2rem;
     --rb-spinner-duration: 0.9s;
-    --rb-spinner-track-color: rgba(var(--tb-foreground), 0.15);
+    --rb-spinner-track-color: rgb(var(--tb-foreground) / 0.15);
 
     display: inline-flex;
     align-items: center;
@@ -71531,12 +72467,12 @@ const containerResponsiveThemeCss = `/*
 
   :where(.theme-scope) .rb-modal__close:hover {
     color: var(--rb-surface-text-color, rgb(var(--tb-text, 17 24 39)));
-    background: rgba(var(--tb-border), 0.2);
+    background: rgb(var(--tb-border) / 0.2);
   }
 
   :where(.theme-scope) .rb-modal__close:focus-visible {
     outline: none;
-    box-shadow: 0 0 0 3px rgba(var(--tb-primary), 0.15);
+    box-shadow: 0 0 0 3px rgb(var(--tb-primary) / 0.15);
   }
 
   :where(.theme-scope) .rb-modal__body {
@@ -72021,7 +72957,7 @@ const containerResponsiveThemeCss = `/*
   :where(.theme-scope) .rb-prose code {
     /* Inline code uses text color with surface background */
     color: inherit;
-    background-color: rgba(var(--tb-surface), 0.5);
+    background-color: rgb(var(--tb-surface) / 0.5);
     padding: 0.125rem 0.25rem;
     border-radius: 0.25rem;
     font-size: 0.875em;
@@ -73013,17 +73949,17 @@ const containerResponsiveThemeCss = `/*
 
   /* All badges use a subtle theme-aware style by default */
   :where(.theme-scope) .badge-status-available {
-    background-color: rgba(var(--tb-secondary), 0.15);
+    background-color: rgb(var(--tb-secondary) / 0.15);
     color: rgb(var(--tb-secondary-700, var(--tb-secondary)));
   }
 
   :where(.theme-scope) .badge-status-low {
-    background-color: rgba(var(--tb-accent), 0.15);
+    background-color: rgb(var(--tb-accent) / 0.15);
     color: rgb(var(--tb-accent-700, var(--tb-accent)));
   }
 
   :where(.theme-scope) .badge-status-sold-out {
-    background-color: rgba(var(--tb-text), 0.1);
+    background-color: rgb(var(--tb-text) / 0.1);
     color: rgb(var(--tb-mutedText));
   }
 
@@ -73092,7 +74028,7 @@ const containerResponsiveThemeCss = `/*
  * here too; block CSS provides the \`.rb-state-icon--{variant}\` colors.
  *
  * Naming: component-like primitives follow the existing bare \`rb-\` shared
- * precedent (\`.rb-state-icon\`, \`.rb-tile\`): \`.rb-option-card\`, \`.rb-step-*\`,
+ * precedent (\`.rb-state-icon\`, \`.rb-tile\`): \`.rb-option-card\`, \`.rb-progress*\`,
  * \`.rb-wizard-actions\`, \`.rb-on-surface\`, \`.rb-shell-*\`. Container/layout
  * pieces that would otherwise collide with the global \`.rb-*\` utility layer
  * are namespaced \`rb-reg-*\` (\`.rb-reg-surface\`, \`.rb-reg-stack\`, ...). All of
@@ -73115,6 +74051,13 @@ const containerResponsiveThemeCss = `/*
   height: 2rem;
 }
 
+/* The success tick reads as a mark inside its disc, not a line drawing */
+:where(.theme-scope) .rb-state-icon--success svg {
+  width: 1.75rem;
+  height: 1.75rem;
+  stroke-width: 3;
+}
+
 /* Surface container */
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-reg-surface {
   border-radius: var(--rb-reg-radius, var(--rb-block-radius, 1rem));
@@ -73151,18 +74094,18 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-option-card:hover:not(:disabled):not([aria-disabled="true"]) {
-  border-color: var(--rb-reg-border-hover, rgba(var(--tb-primary, 17 24 39), 0.5));
-  box-shadow: var(--rb-reg-option-hover-shadow, 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08));
+  border-color: var(--rb-reg-border-hover, rgb(var(--tb-primary, 17 24 39) / 0.5));
+  box-shadow: var(--rb-reg-option-hover-shadow, 0 8px 18px rgb(var(--tb-shadow, 15 23 42) / 0.08));
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-option-card:focus-visible {
-  outline: 2px solid var(--rb-reg-focus-ring, rgba(var(--tb-primary, 17 24 39), 0.3));
+  outline: 2px solid var(--rb-reg-focus-ring, rgb(var(--tb-primary, 17 24 39) / 0.3));
   outline-offset: 2px;
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-option-card--selected {
   border-color: var(--rb-reg-border-selected, rgb(var(--tb-primary, 17 24 39)));
-  background-color: var(--rb-reg-bg-selected, rgba(var(--tb-primary, 17 24 39), 0.08));
+  background-color: var(--rb-reg-bg-selected, rgb(var(--tb-primary, 17 24 39) / 0.08));
   box-shadow: 0 0 0 1px var(--rb-reg-border-selected, rgb(var(--tb-primary, 17 24 39)));
 }
 
@@ -73194,78 +74137,45 @@ const containerResponsiveThemeCss = `/*
   color: var(--rb-reg-check-text, rgb(var(--tb-onPrimary, var(--tb-primaryForeground, 255 255 255))));
 }
 
-/* Step indicator */
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-steps-nav {
-  margin-bottom: 1.5rem;
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-steps {
+/* Progress: the current step's label, "Step N of M" and a thin bar (issue 1581) */
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.5rem;
-  list-style: none;
-  padding: 0;
-  margin: 0;
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step {
-  display: flex;
-  align-items: center;
+  flex-direction: column;
   gap: 0.5rem;
+  margin-bottom: 1.5rem;
 }
 
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-circle {
-  width: 1.75rem;
-  height: 1.75rem;
-  border-radius: 50%;
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress__head {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 0.75rem;
-  font-weight: 600;
-  background: var(--rb-reg-step-inactive, rgb(var(--tb-mutedText, 100 116 139)));
-  color: var(--rb-reg-step-text, rgb(var(--tb-primaryForeground, 255 255 255)));
-  transition: background-color var(--rb-block-transition, 150ms) ease;
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-circle--active {
-  background: var(--rb-reg-step-active, rgb(var(--tb-primary, 17 24 39)));
-  color: var(--rb-reg-step-text-active, rgb(var(--tb-onPrimary, var(--tb-primaryForeground, 255 255 255))));
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-circle--completed {
-  background: var(--rb-reg-step-completed, rgb(var(--tb-success, 22 163 74)));
-  color: var(--rb-reg-step-text-active, rgb(var(--tb-onPrimary, var(--tb-primaryForeground, 255 255 255))));
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-check {
-  width: 0.75rem;
-  height: 0.75rem;
-}
-
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-connector {
-  width: 2rem;
-  height: 2px;
-  background: var(--rb-reg-step-connector, rgba(var(--tb-border, 226 232 240), 0.5));
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+  font-size: 0.8125rem;
+  line-height: 1.3;
 }
 
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-label {
-  font-size: 0.75rem;
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress__label {
+  font-weight: 700;
   color: var(--rb-reg-on-surface, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42))));
-  display: none;
 }
 
-:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-label--active {
-  font-weight: 500;
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress__count {
+  margin-inline-start: auto;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.7));
 }
 
-@container rb-site (min-width: 640px) {
-@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
-:where(.theme-scope:is(*, :scope)) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-step-label {
-    display: inline;
-  }
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress__track {
+  height: 4px;
+  border-radius: 4px;
+  background: rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.12);
+  overflow: hidden;
 }
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-progress__fill {
+  height: 100%;
+  border-radius: 4px;
+  background: var(--rb-reg-step-active, rgb(var(--tb-primary, 17 24 39)));
+  transition: width var(--rb-block-transition, 150ms) ease;
 }
 
 /* Wizard actions row */
@@ -73282,21 +74192,26 @@ const containerResponsiveThemeCss = `/*
   margin-inline-start: auto;
 }
 
+/* A footer with only Back keeps it bottom-left, like every other step */
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-wizard-actions--back-only > :only-child {
+  margin-inline-start: 0;
+}
+
 /* On-surface text ramp */
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-on-surface {
   color: var(--rb-reg-on-surface, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42))));
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-on-surface--muted {
-  color: var(--rb-reg-on-surface-muted, rgba(var(--tb-onSurface, var(--tb-text, 15 23 42)), 0.7));
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.7));
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-on-surface--subtle {
-  color: var(--rb-reg-on-surface-subtle, rgba(var(--tb-onSurface, var(--tb-text, 15 23 42)), 0.6));
+  color: var(--rb-reg-on-surface-subtle, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.6));
 }
 
 :where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-on-surface--faint {
-  color: var(--rb-reg-on-surface-faint, rgba(var(--tb-onSurface, var(--tb-text, 15 23 42)), 0.5));
+  color: var(--rb-reg-on-surface-faint, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.5));
 }
 
 /* Layout stacks */
@@ -73331,7 +74246,7 @@ const containerResponsiveThemeCss = `/*
   padding: 1rem;
   border-radius: calc(var(--rb-reg-radius, var(--rb-block-radius, 1rem)) * 0.75);
   border: 1px solid var(--rb-reg-summary-border, rgb(var(--tb-border, 226 232 240)));
-  background: var(--rb-reg-summary-bg, rgba(var(--tb-muted, 241 245 249), 0.42));
+  background: var(--rb-reg-summary-bg, rgb(var(--tb-muted, 241 245 249) / 0.42));
 }
 
 /* Skeleton shell lines */
@@ -73340,9 +74255,9 @@ const containerResponsiveThemeCss = `/*
   border-radius: 9999px;
   background: linear-gradient(
     90deg,
-    var(--rb-reg-shell-line, rgba(var(--tb-mutedText, 100 116 139), 0.22)),
-    rgba(var(--tb-primary, 17 24 39), 0.12),
-    var(--rb-reg-shell-line, rgba(var(--tb-mutedText, 100 116 139), 0.22))
+    var(--rb-reg-shell-line, rgb(var(--tb-mutedText, 100 116 139) / 0.22)),
+    rgb(var(--tb-primary, 17 24 39) / 0.12),
+    var(--rb-reg-shell-line, rgb(var(--tb-mutedText, 100 116 139) / 0.22))
   );
 }
 
@@ -73367,7 +74282,7 @@ const containerResponsiveThemeCss = `/*
   height: 2.5rem;
   width: 100%;
   border-radius: var(--rb-reg-radius, var(--rb-block-radius, 1rem));
-  background: var(--rb-reg-shell-line, rgba(var(--tb-mutedText, 100 116 139), 0.22));
+  background: var(--rb-reg-shell-line, rgb(var(--tb-mutedText, 100 116 139) / 0.22));
   animation: rb-reg-pulse 1.5s ease-in-out infinite;
 }
 
@@ -73386,6 +74301,101 @@ const containerResponsiveThemeCss = `/*
   }
 }
 
+/* Payment choices (issue 1581): one full-width radio row per way to pay, the
+ * label and detail on the left, the price on the right. Shared by event and
+ * appointment booking (PaymentChoiceRows). */
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choices {
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.875rem;
+  padding: 1rem 1.125rem;
+  border: 1px solid var(--rb-reg-border, rgb(var(--tb-border)));
+  border-radius: var(--rb-reg-radius, var(--rb-block-radius, 1rem));
+  background: var(--rb-reg-option-bg, transparent);
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+  cursor: pointer;
+  transition:
+    border-color var(--rb-block-transition, 150ms) ease,
+    background-color var(--rb-block-transition, 150ms) ease;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice:hover:not(.rb-pay-choice--disabled) {
+  border-color: var(--rb-reg-border-hover, rgb(var(--tb-primary) / 0.5));
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice:focus-within {
+  box-shadow: 0 0 0 3px rgb(var(--tb-primary) / 0.25);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice--selected {
+  border-color: rgb(var(--tb-primary));
+  box-shadow: inset 0 0 0 1px rgb(var(--tb-primary));
+  background: rgb(var(--tb-primary) / 0.06);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice--selected:focus-within {
+  box-shadow:
+    inset 0 0 0 1px rgb(var(--tb-primary)),
+    0 0 0 3px rgb(var(--tb-primary) / 0.25);
+}
+
+/* Disabled stays readable: a dashed edge and quieter text, with its reason */
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice--disabled {
+  border-style: dashed;
+  cursor: not-allowed;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice--disabled :is(.rb-pay-choice__label, .rb-pay-choice__detail, .rb-pay-choice__price) {
+  opacity: 0.65;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__radio {
+  flex: 0 0 auto;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin: 0.125rem 0 0;
+  accent-color: rgb(var(--tb-primary));
+  cursor: inherit;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__body {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__label {
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__detail {
+  font-size: 0.875rem;
+  line-height: 1.4;
+  color: var(--rb-surface-supporting-color, rgb(var(--tb-text) / 0.7));
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__reason {
+  font-size: 0.8125rem;
+  line-height: 1.4;
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+}
+
+:where(.theme-scope) :where([data-block="event-registration"], [data-block="appointment-booking"]) .rb-pay-choice__price {
+  flex: 0 0 auto;
+  font-weight: 700;
+  text-align: end;
+  white-space: nowrap;
+}
+
 /* =============================================================================
  * Block: Event Registration (pilot #76)
  * Uses CSS vars: --er-* (Tier 3) and --rb-block-* (Tier 2)
@@ -73400,17 +74410,14 @@ const containerResponsiveThemeCss = `/*
   --rb-event-tile-border-hover: var(--er-border-hover);
   --rb-event-tile-border-selected: var(--er-border-selected);
   --rb-event-tile-hover-opacity: var(--er-event-card-hover-opacity);
-  --rb-event-tile-bg-selected: rgba(var(--tb-primary), 0.1);
+  --rb-event-tile-bg-selected: rgb(var(--tb-primary) / 0.1);
   --er-on-surface: rgb(var(--tb-onSurface, var(--tb-text)));
-  --er-on-surface-muted: rgba(var(--tb-onSurface, var(--tb-text)), 0.7);
-  --er-on-surface-subtle: rgba(var(--tb-onSurface, var(--tb-text)), 0.6);
-  --er-on-surface-faint: rgba(var(--tb-onSurface, var(--tb-text)), 0.5);
-  --er-on-surface-hover-bg: rgba(var(--tb-onSurface, var(--tb-text)), 0.05);
-  --er-on-surface-disabled: rgba(var(--tb-onSurface, var(--tb-text)), 0.78);
-  --er-on-surface-disabled-detail: rgba(
-    var(--tb-onSurface, var(--tb-text)),
-    0.68
-  );
+  --er-on-surface-muted: rgb(var(--tb-onSurface, var(--tb-text)) / 0.7);
+  --er-on-surface-subtle: rgb(var(--tb-onSurface, var(--tb-text)) / 0.6);
+  --er-on-surface-faint: rgb(var(--tb-onSurface, var(--tb-text)) / 0.5);
+  --er-on-surface-hover-bg: rgb(var(--tb-onSurface, var(--tb-text)) / 0.05);
+  --er-on-surface-disabled: rgb(var(--tb-onSurface, var(--tb-text)) / 0.78);
+  --er-on-surface-disabled-detail: rgb(var(--tb-onSurface, var(--tb-text)) / 0.68);
 }
 
 /* Container: styled by the shared .rb-reg-surface (registration-surface.css);
@@ -73538,6 +74545,109 @@ const containerResponsiveThemeCss = `/*
   opacity: 0.6;
 }
 
+/* Date step (issue 1581): one radio row per date, on the shared event tile */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.625rem;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-list__month {
+  margin: 0.5rem 0 0;
+  font-size: 0.75rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--rb-surface-supporting-color, var(--er-on-surface-muted));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-list__month:first-child {
+  margin-top: 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-event-card.er-date-option {
+  display: flex;
+  align-items: center;
+  gap: 0.875rem;
+  padding: 0.875rem 1rem;
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option:focus-within {
+  box-shadow: 0 0 0 3px rgb(var(--tb-primary) / 0.25);
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option__radio {
+  flex: 0 0 auto;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin: 0;
+  accent-color: rgb(var(--tb-primary));
+  cursor: pointer;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option__main {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option__date {
+  font-weight: 700;
+  line-height: 1.3;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option__time {
+  font-size: 0.875rem;
+  color: var(--rb-surface-supporting-color, var(--er-on-surface-muted));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option__places {
+  flex: 0 0 auto;
+  padding: 0.125rem 0.5rem;
+  border: 1px solid var(--er-border);
+  border-radius: 999px;
+  font-size: 0.75rem;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+/* Full dates stay selectable (a guest can still reach recovery) but read as quiet */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option--full {
+  border-style: dashed;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-date-option--full
+  :is(.er-date-option__main, .er-date-option__places) {
+  opacity: 0.6;
+}
+
 /* Capacity badges */
 :where(.theme-scope)
   :where([data-block='event-registration'])
@@ -73743,63 +74853,31 @@ const containerResponsiveThemeCss = `/*
 }
 }
 
-/* Form inputs */
-:where(.theme-scope) :where([data-block='event-registration']) .er-input {
-  width: 100%;
-  min-height: 2.75rem;
-  padding: 0.625rem 0.75rem;
-  border-radius: calc(var(--rb-block-radius) * 0.5);
-  border: 1px solid var(--er-border);
-  background: var(--er-control-bg);
-  color: var(--er-control-text);
-  font: inherit;
-  line-height: 1.4;
-  transition:
-    border-color var(--rb-block-transition) ease,
-    background-color var(--rb-block-transition) ease,
-    box-shadow var(--rb-block-transition) ease;
-}
+/* Fields use the theme's own form-label / form-input / form-textarea
+   (theme-core/src/inputs/generateInputCss.ts), like the site's form block. */
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-input::placeholder {
-  color: var(--er-on-surface-faint);
-}
-
-:where(.theme-scope) :where([data-block='event-registration']) .er-input:focus {
-  outline: none;
-  border-color: var(--er-border-selected);
-  box-shadow: 0 0 0 3px var(--er-focus-ring);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-input--error {
-  border-color: var(--er-border-error);
+  .er-label-optional {
+  font-weight: 400;
+  text-transform: none;
+  letter-spacing: normal;
+  color: var(--rb-surface-supporting-color, var(--er-on-surface-muted));
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-input--error:focus {
-  box-shadow: 0 0 0 3px rgba(var(--tb-destructive), 0.2);
-}
-
-/* Form labels and errors */
-:where(.theme-scope) :where([data-block='event-registration']) .er-label {
-  display: block;
-  font-size: 0.875rem;
-  font-weight: 500;
-  margin-bottom: 0.25rem;
+  .er-field-hint {
+  margin: 0.375rem 0 0;
+  font-size: 0.8125rem;
+  line-height: 1.4;
+  color: var(--rb-surface-supporting-color, var(--er-on-surface-muted));
 }
 
 :where(.theme-scope) :where([data-block='event-registration']) .er-consent-check {
   margin-top: 0.75rem;
 }
 
-:where(.theme-scope) :where([data-block='event-registration']) .er-required {
-  color: var(--er-required);
-}
-
 :where(.theme-scope) :where([data-block='event-registration']) .er-error {
   font-size: 0.875rem;
   color: var(--er-error-text);
@@ -73808,12 +74886,14 @@ const containerResponsiveThemeCss = `/*
 
 /* Back button */
 :where(.theme-scope) :where([data-block='event-registration']) .er-back-btn {
-  font-size: 0.875rem;
-  opacity: 0.7;
+  font-size: 0.9375rem;
+  font-weight: 700;
+  opacity: 0.8;
   background: none;
   border: none;
   cursor: pointer;
-  padding: 0;
+  padding: 0 0.25rem;
+  min-height: 2.75rem;
   transition: opacity var(--rb-block-transition) ease;
 }
 
@@ -73824,11 +74904,12 @@ const containerResponsiveThemeCss = `/*
 }
 
 /* State icon color variants (layout from registration-surface.css) */
+/* Success: a solid primary disc with an on-primary tick (issue 1581) */
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .rb-state-icon--success {
-  background: var(--er-success-bg);
-  color: var(--er-success-text);
+  background: rgb(var(--tb-primary));
+  color: rgb(var(--tb-onPrimary));
 }
 
 :where(.theme-scope)
@@ -73877,14 +74958,15 @@ const containerResponsiveThemeCss = `/*
 
 /* Typography */
 :where(.theme-scope) :where([data-block='event-registration']) .er-title {
-  font-size: var(--er-step-title-size, 1.5rem);
-  font-weight: 600;
-  line-height: 1.3;
+  font-family: var(--font-heading, inherit);
+  font-size: var(--er-step-title-size, 1.75rem);
+  line-height: 1.15;
 }
 
+/* Confirmation and error titles: never smaller than a step's heading */
 :where(.theme-scope) :where([data-block='event-registration']) .er-title--lg {
-  font-size: 1.25rem;
-  line-height: 1.75rem;
+  font-size: calc(var(--er-step-title-size, 1.75rem) * 1.15);
+  line-height: 1.1;
 }
 
 :where(.theme-scope) :where([data-block='event-registration']) .er-text {
@@ -74110,7 +75192,7 @@ const containerResponsiveThemeCss = `/*
   padding: 1.25rem;
   border: 1px solid var(--er-border);
   border-radius: var(--rb-block-radius);
-  background: rgba(var(--tb-surface), 0.5);
+  background: rgb(var(--tb-surface) / 0.5);
   text-align: center;
 }
 
@@ -74215,7 +75297,7 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-registration'])
   .er-payment-option:hover {
   border-color: var(--er-payment-border-hover);
-  box-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  box-shadow: 0 8px 18px rgb(var(--tb-shadow, 15 23 42) / 0.08);
 }
 
 :where(.theme-scope)
@@ -74415,103 +75497,6 @@ const containerResponsiveThemeCss = `/*
   color: var(--er-on-surface);
 }
 
-/* Two-column layout (Desktop: sidebar, Mobile: stacked) */
-:where(.theme-scope) :where([data-block='event-registration']) .er-layout {
-  display: grid;
-  gap: 1.5rem;
-  /* Mobile: single column, summary at top */
-  grid-template-columns: 1fr;
-  grid-template-areas:
-    'summary'
-    'main';
-}
-
-@container rb-site (min-width: 768px) {
-@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
-:where(.theme-scope:is(*, :scope)) :where([data-block='event-registration']) .er-layout {
-    /* Desktop: main + sidebar */
-    grid-template-columns: 1fr 300px;
-    grid-template-areas: 'main summary';
-  }
-}
-}
-
-:where(.theme-scope) :where([data-block='event-registration']) .er-layout-main {
-  grid-area: main;
-}
-
-/* OrderSummary positions via grid area */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-layout
-  > .er-summary {
-  grid-area: summary;
-}
-
-/* Step indicator */
-:where(.theme-scope) :where([data-block='event-registration']) .er-steps-nav {
-  margin-bottom: 1.5rem;
-}
-
-/* Step indicator internals: styled by the shared .rb-steps / .rb-step-*
-   family (registration-surface.css) via the --rb-reg-step-* mappings in the
-   event-registration var generator; er-* classes remain in markup as hooks.
-   Note: .er-steps-nav above is intentionally retained — its source position
-   keeps the wizard's 1.5rem step margin winning over the SSR shell's
-   1.25rem .er-registration-shell__steps override. */
-
-/* Sticky order summary */
-:where(.theme-scope) :where([data-block='event-registration']) .er-summary {
-  padding: 1.25rem;
-  background: var(--er-summary-bg);
-  border: 1px solid var(--er-summary-border);
-  border-radius: var(--rb-block-radius);
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-  align-items: center;
-  text-align: center;
-  min-height: 140px;
-}
-
-@container rb-site (min-width: 768px) {
-@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
-:where(.theme-scope:is(*, :scope)) :where([data-block='event-registration']) .er-summary {
-    position: sticky;
-    top: 1rem;
-  }
-}
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-summary-event {
-  font-weight: 600;
-  margin-bottom: 0.25rem;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-summary-date {
-  font-size: 0.875rem;
-  color: rgba(var(--tb-text), 0.7);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-summary-tickets {
-  font-size: 0.875rem;
-  margin-top: 0.75rem;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-summary-price {
-  font-size: 1.25rem;
-  font-weight: 700;
-  margin-top: 0.5rem;
-}
-
 /* Guest details section */
 :where(.theme-scope)
   :where([data-block='event-registration'])
@@ -74572,17 +75557,6 @@ const containerResponsiveThemeCss = `/*
   border-top: 1px solid var(--er-border);
 }
 
-@container rb-site (min-width: 768px) {
-@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
-:where(.theme-scope:is(*, :scope))
-    :where([data-block='event-registration'])
-    .er-guest-card {
-    grid-template-columns: minmax(0, 2fr) minmax(0, 1fr);
-    column-gap: 1rem;
-    align-items: start;
-  }
-}
-}
 
 /* Shake animation for validation errors */
 @keyframes er-shake {
@@ -74906,8 +75880,8 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-notice--info {
-  background-color: rgba(var(--tb-primary-100), 0.5);
-  border: 1px solid rgba(var(--tb-primary-300), 0.5);
+  background-color: rgb(var(--tb-primary-100) / 0.5);
+  border: 1px solid rgb(var(--tb-primary-300) / 0.5);
   color: rgb(var(--tb-primary-800));
 }
 
@@ -74993,12 +75967,40 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-registration'])
   .er-payment-layout-main {
   grid-area: main;
+  /* A column, so an optional sign-in line can settle at the foot of the step. */
+  display: flex;
+  flex-direction: column;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-payment-layout-main
+  > * {
+  flex-shrink: 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-payment-layout-main
+  > .er-portal-auth[data-placement='before'] {
+  margin-bottom: 1.5rem;
 }
 
+/* The optional sign-in line: pinned to the foot of the step behind a hairline,
+   and never closer than 1.5rem to the step's content. */
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-payment-layout-main
-  > .er-portal-auth {
+  > .er-portal-auth[data-placement='after'] {
+  margin-top: auto;
+  padding-top: 1rem;
+  border-top: 1px solid var(--er-border);
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-payment-layout-main
+  > :has(+ .er-portal-auth[data-placement='after']) {
   margin-bottom: 1.5rem;
 }
 
@@ -75018,7 +76020,7 @@ const containerResponsiveThemeCss = `/*
 }
 
 /* =============================================================================
- * Payment Tiles Grid
+ * Attendance mode tiles (in person / online)
  * =============================================================================
  */
 
@@ -75063,9 +76065,9 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-payment-tile:hover:not([aria-disabled='true']) {
+  .er-payment-tile:hover {
   border-color: var(--er-payment-border-hover);
-  box-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  box-shadow: 0 8px 18px rgb(var(--tb-shadow, 15 23 42) / 0.08);
 }
 
 :where(.theme-scope)
@@ -75076,89 +76078,6 @@ const containerResponsiveThemeCss = `/*
   box-shadow: 0 0 0 1px var(--er-payment-border-selected);
 }
 
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--disabled {
-  cursor: not-allowed;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--disabled
-  > :not(.er-payment-tooltip) {
-  opacity: 0.5;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--disabled.er-payment-tile--selected {
-  border-color: var(--er-payment-border);
-  background-color: transparent;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--disabled:hover {
-  border-color: var(--er-payment-border);
-}
-
-/* Tooltip styling for disabled payment tiles */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile[aria-disabled='true'] {
-  position: relative;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tooltip {
-  display: none;
-  position: absolute;
-  bottom: 100%;
-  left: 50%;
-  transform: translateX(-50%);
-  margin-bottom: 0.5rem;
-  padding: 0.5rem 0.75rem;
-  background: rgb(var(--tb-text));
-  color: rgb(var(--tb-background));
-  font-size: 0.8125rem;
-  font-weight: 500;
-  border-radius: calc(var(--rb-block-radius) * 0.5);
-  white-space: normal;
-  max-width: 16rem;
-  line-height: 1.35;
-  text-align: center;
-  box-shadow: 0 8px 20px rgba(var(--tb-shadow), 0.28);
-  z-index: 10;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--disabled:hover
-  .er-payment-tooltip {
-  display: block;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile-icon {
-  font-size: 1.5rem;
-  line-height: 1;
-  /* SVG icon sizing */
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile-icon
-  svg {
-  width: 24px;
-  height: 24px;
-  color: currentColor;
-}
-
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-payment-tile-label {
@@ -75175,27 +76094,6 @@ const containerResponsiveThemeCss = `/*
   line-height: 1.25;
 }
 
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile-check {
-  position: absolute;
-  top: 0.5rem;
-  right: 0.5rem;
-}
-
-/* Upsell tiles have a subtle indicator */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--upsell {
-  border-style: dashed;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-payment-tile--upsell.er-payment-tile--selected {
-  border-style: solid;
-}
-
 /* =============================================================================
  * Order Summary Bar (horizontal, in footer)
  * Layout: [Title + meta on left] [Price on right]
@@ -75203,14 +76101,12 @@ const containerResponsiveThemeCss = `/*
  */
 
 :where(.theme-scope) :where([data-block='event-registration']) .er-summary-bar {
+  /* One row under the footer's hairline: what's booked, then the total
+     (issue 1581). */
   display: flex;
   justify-content: space-between;
-  align-items: flex-start;
+  align-items: baseline;
   gap: 1rem;
-  padding: 0.875rem 1rem;
-  background: var(--er-surface-muted);
-  border: 1px solid var(--er-summary-border);
-  border-radius: calc(var(--rb-block-radius) * 0.75);
 }
 
 :where(.theme-scope)
@@ -75233,18 +76129,30 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-summary-bar-meta {
-  font-size: 0.8125rem;
-  color: rgba(var(--tb-text), 0.7);
+  font-size: 0.9375rem;
   line-height: 1.35;
 }
 
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-summary-bar-meta
+  > span
+  + span::before {
+  content: ' · ';
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-summary-bar-schedule {
+  color: var(--rb-surface-supporting-color, rgb(var(--tb-text) / 0.7));
+}
+
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-summary-bar-price {
-  font-size: 1rem;
+  font-size: 1.125rem;
   font-weight: 700;
   flex-shrink: 0;
-  display: block;
   text-align: right;
 }
 
@@ -75252,12 +76160,22 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-registration'])
   .er-summary-bar-pricing {
   display: flex;
-  flex-direction: column;
-  align-items: flex-end;
-  gap: 0.125rem;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  align-items: baseline;
+  column-gap: 0.5rem;
+  row-gap: 0.125rem;
   text-align: right;
 }
 
+/* Notes under the total take their own line */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-summary-bar-pricing
+  > div {
+  flex-basis: 100%;
+}
+
 /* Product section in summary bar (for pass/membership selection) */
 :where(.theme-scope)
   :where([data-block='event-registration'])
@@ -75303,7 +76221,7 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-registration'])
   .er-summary-bar-product-detail {
   font-size: 0.8125rem;
-  color: rgba(var(--tb-text), 0.6);
+  color: rgb(var(--tb-text) / 0.6);
   margin-top: 0.125rem;
 }
 
@@ -75320,9 +76238,8 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-summary-bar-price--struck {
-  display: block;
   text-decoration: line-through;
-  color: rgba(var(--tb-text), 0.5);
+  color: rgb(var(--tb-text) / 0.5);
   font-size: 0.9375rem;
   font-weight: 500;
   text-align: right;
@@ -75344,19 +76261,25 @@ const containerResponsiveThemeCss = `/*
  */
 
 :where(.theme-scope) :where([data-block='event-registration']) .er-portal-auth {
-  padding: 1.25rem;
-  background: rgba(var(--tb-surface), 0.5);
-  border: 1px solid var(--er-border);
-  border-radius: var(--rb-block-radius);
-  color: var(--er-on-surface);
+  /* The surface the panel paints publishes its own foreground; --tb-onSurface
+     can be a different (near-black) colour from the site's text. */
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+  font-size: 0.9375rem;
+  line-height: 1.5;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-portal-auth-title {
   font-weight: 600;
-  font-size: 1rem;
-  margin: 0 0 0.5rem 0;
+  margin: 0 0 0.25rem 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-portal-auth[data-placement='after']
+  .er-portal-auth-title {
+  margin: 0;
 }
 
 :where(.theme-scope)
@@ -75368,6 +76291,15 @@ const containerResponsiveThemeCss = `/*
   line-height: 1.4;
 }
 
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-portal-auth
+  .er-portal-auth-text {
+  color: inherit;
+  margin: 0;
+  line-height: inherit;
+}
+
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-portal-auth-link {
@@ -75417,7 +76349,7 @@ const containerResponsiveThemeCss = `/*
   left: 0;
   right: 0;
   bottom: 0;
-  background: rgba(var(--tb-scrim), 0.5);
+  background: var(--rb-modal-overlay-bg);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -75432,7 +76364,7 @@ const containerResponsiveThemeCss = `/*
   max-width: 400px;
   width: 100%;
   position: relative;
-  box-shadow: 0 10px 25px rgba(var(--tb-shadow), 0.2);
+  box-shadow: 0 10px 25px rgb(var(--tb-shadow) / 0.2);
 }
 
 :where(.theme-scope) :where([data-block='event-registration']) .er-modal-close {
@@ -75444,7 +76376,7 @@ const containerResponsiveThemeCss = `/*
   font-size: 1.5rem;
   line-height: 1;
   cursor: pointer;
-  color: rgba(var(--tb-text), 0.5);
+  color: rgb(var(--tb-text) / 0.5);
   padding: 0.25rem;
 }
 
@@ -75510,97 +76442,246 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-modal-btn--secondary:hover {
-  background: rgba(var(--tb-text), 0.05);
+  background: rgb(var(--tb-text) / 0.05);
 }
 
-/* In-flow booking teaser (sits at the block's position in the page) */
+/* Booking card: in the page where the editor placed the block (issue 1581) */
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser {
+  .er-booking-card {
   display: flex;
+  flex-direction: column;
+  gap: 1.125rem;
+  padding: 1.5rem 1.75rem;
+  border: 1px solid var(--er-border);
+  border-radius: calc(var(--rb-block-radius) * 1.25);
+  background: rgb(var(--tb-surface));
+  /* Foreground and button context: theme-core/src/blocks/opaquePanels.ts. */
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__row {
+  display: flex;
+  align-items: center;
+  gap: 1.25rem 1.75rem;
   flex-wrap: wrap;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__tile {
+  flex: 0 0 auto;
+  display: flex;
+  flex-direction: column;
   align-items: center;
-  justify-content: space-between;
-  gap: 1rem 1.5rem;
-  padding: 1.25rem 1.5rem;
-  border: 1px solid var(--er-border);
+  justify-content: center;
+  gap: 0.125rem;
+  width: 4.25rem;
+  height: 4.75rem;
   border-radius: var(--rb-block-radius);
-  background: var(--er-event-card-bg);
-  /* Foreground and button context: theme-core/src/blocks/opaquePanels.ts. */
+  background: rgb(var(--tb-primary));
+  color: rgb(var(--tb-onPrimary, var(--tb-primaryForeground)));
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__info {
+  .er-booking-card__tile-month {
+  font-size: 0.75rem;
+  font-weight: 800;
+  letter-spacing: 0.1em;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__tile-day {
+  font-family: var(--font-heading, inherit);
+  font-size: 2rem;
+  line-height: 1;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__badge {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 3rem;
+  height: 3rem;
+  border-radius: 999px;
+  background: rgb(var(--tb-primary));
+  color: rgb(var(--tb-onPrimary, var(--tb-primaryForeground)));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__body {
+  flex: 1 1 16rem;
+  min-width: 0;
   display: flex;
   flex-direction: column;
   gap: 0.25rem;
-  min-width: 0;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__title {
-  font-size: 1.0625rem;
+  .er-booking-card__when {
+  margin: 0;
+  font-size: 1.125rem;
   font-weight: 700;
-  line-height: 1.2;
+  line-height: 1.3;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__meta {
+  .er-booking-card__venue,
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__facts {
+  margin: 0;
   font-size: 0.9375rem;
-  line-height: 1.3;
-  opacity: 0.75;
+  line-height: 1.45;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__tickets {
+  .er-booking-card__facts {
+  margin-top: 0.25rem;
+  font-weight: 600;
+  color: inherit;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__cta {
+  flex: 0 0 auto;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__dates {
   display: flex;
-  flex-direction: column;
-  gap: 0.375rem;
-  margin-top: 0.5rem;
-  padding-top: 0.625rem;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.625rem;
+  padding-top: 1.125rem;
   border-top: 1px solid var(--er-border);
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__ticket {
-  display: flex;
-  align-items: baseline;
-  justify-content: space-between;
-  gap: 1rem;
-  font-size: 0.9375rem;
-  line-height: 1.35;
+  .er-booking-card__dates-label {
+  margin-right: 0.375rem;
+  font-size: 0.8125rem;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__ticket-name {
-  min-width: 0;
+  .er-booking-card__date {
+  min-height: 2.75rem;
+  padding: 0 1rem;
+  border: 1px solid var(--er-border);
+  border-radius: 999px;
+  background: var(--er-control-bg);
+  color: inherit;
+  font: inherit;
+  font-size: 0.875rem;
+  font-weight: 700;
+  cursor: pointer;
+  transition: border-color var(--rb-block-transition) ease;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
-  .er-booking-teaser__cta {
-  flex: 0 0 auto;
+  .er-booking-card__date:hover {
+  border-color: rgb(var(--tb-primary));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__date[data-full] {
+  border-style: dashed;
+  background: transparent;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
 }
 
-/* Fixed, full-width sticky booking bar (content-agnostic; sits above page flow) */
-:where(.theme-scope) :where([data-block='event-registration']) .er-booking-bar {
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-card__more {
+  font-size: 0.875rem;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
+}
+
+/* Booking bar: fixed to the bottom once the visitor is past the first screen.
+   It stays mounted and slides: the card pushes it down in step as it rises
+   from the bottom of the screen (--er-bar-push, set per frame), and it slides
+   back up when the visitor scrolls past the card (issue 1581). */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar {
   position: fixed;
   left: 0;
   right: 0;
   bottom: 0;
   z-index: 12000;
-  padding: 0.75rem max(1rem, env(safe-area-inset-right))
-    max(0.75rem, env(safe-area-inset-bottom))
+  padding: 0.625rem max(1rem, env(safe-area-inset-right))
+    max(0.625rem, env(safe-area-inset-bottom))
     max(1rem, env(safe-area-inset-left));
-  background: rgb(var(--tb-background));
+  background: rgb(var(--tb-surface));
   border-top: 1px solid var(--er-border);
-  box-shadow: 0 -10px 30px rgba(var(--tb-shadow), 0.16);
+  box-shadow: 0 -8px 28px rgb(var(--tb-shadow) / 0.14);
+  /* Set per frame on the element while the card pushes the bar off. */
+  --er-bar-push: 0px;
+  transform: translateY(var(--er-bar-push));
+  transition:
+    transform 220ms ease,
+    visibility 0s linear 0s;
+  /* Foreground and button context: theme-core/src/blocks/opaquePanels.ts. */
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar[data-state='hidden'] {
+  transform: translateY(calc(100% + 1.75rem));
+  visibility: hidden;
+  transition:
+    transform 220ms ease,
+    visibility 0s linear 220ms;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar[data-pushing='true'] {
+  /* Following the card frame by frame: no easing to lag behind. */
+  transition: none;
+}
+
+@media (prefers-reduced-motion: reduce) {
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+    .er-booking-bar {
+    transform: none;
+    transition:
+      opacity 150ms ease,
+      visibility 0s linear 0s;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+    .er-booking-bar[data-state='hidden'] {
+    transform: none;
+    opacity: 0;
+    transition:
+      opacity 150ms ease,
+      visibility 0s linear 150ms;
+}
+
 }
 
 :where(.theme-scope)
@@ -75608,27 +76689,28 @@ const containerResponsiveThemeCss = `/*
   .er-booking-bar__inner {
   display: flex;
   align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
+  gap: 0.75rem 1.5rem;
   width: 100%;
-  max-width: 72rem;
+  max-width: 77rem;
+  min-height: 2.75rem;
   margin-inline: auto;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-bar__info {
+  flex: 1 1 auto;
   display: flex;
-  flex-direction: column;
-  gap: 0.125rem;
+  align-items: center;
+  gap: 0.25rem 0.875rem;
   min-width: 0;
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-bar__title {
-  font-size: 0.95rem;
-  font-weight: 700;
+  font-family: var(--font-heading, inherit);
+  font-size: 1.25rem;
   line-height: 1.2;
   white-space: nowrap;
   overflow: hidden;
@@ -75638,18 +76720,202 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-bar__meta {
-  font-size: 0.8125rem;
-  line-height: 1.25;
-  opacity: 0.75;
+  display: block;
+  min-width: 0;
+  font-size: 0.9375rem;
+  line-height: 1.3;
+  color: var(--rb-surface-supporting-color, rgb(var(--tb-text) / 0.75));
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
 }
 
+/* Facts are set apart by a thin muted rule rather than a dot (issue 1581) */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__divider {
+  display: inline-block;
+  width: 0;
+  height: 0.875em;
+  margin-inline: 0.75rem;
+  border-left: 1px solid var(--er-border);
+  vertical-align: -0.0625em;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__fact--price {
+  font-weight: 600;
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar[data-entry='inProgress'] .er-booking-bar__meta {
+  font-weight: 600;
+  color: rgb(var(--tb-primary));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__progress {
+  flex: 0 0 7.5rem;
+  height: 4px;
+  border-radius: 4px;
+  background: rgb(var(--tb-text) / 0.12);
+  overflow: hidden;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__progress-fill {
+  display: block;
+  height: 100%;
+  border-radius: 4px;
+  background: rgb(var(--tb-primary));
+}
+
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-bar__cta {
   flex: 0 0 auto;
+  white-space: nowrap;
+}
+
+/* Booked or waitlisted: one quiet status line; the whole bar leads back to the card */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__status {
+  display: flex;
+  align-items: center;
+  gap: 0.625rem;
+  width: 100%;
+  min-width: 0;
+  min-height: 2.75rem;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-size: 0.9375rem;
+  line-height: 1.3;
+  text-align: start;
+  cursor: pointer;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__status:focus-visible {
+  outline: 2px solid rgb(var(--tb-primary));
+  outline-offset: 4px;
+  border-radius: 4px;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__check {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.375rem;
+  height: 1.375rem;
+  border-radius: 999px;
+  background: rgb(var(--tb-primary));
+  color: rgb(var(--tb-onPrimary));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__status-text {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  white-space: nowrap;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-bar__status-title {
+  flex: 0 0 auto;
+  font-weight: 700;
+  color: var(--rb-surface-text-color, rgb(var(--tb-text)));
+}
+
+@container rb-site (max-width: 639px) {
+@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
+/* Phones: the title or status on the first line, the facts smaller and
+   quieter below it, beside a compact button (issue 1581). */
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__info {
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.125rem;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__title {
+  max-width: 100%;
+  font-family: inherit;
+  font-size: 0.9375rem;
+  font-weight: 700;
+  line-height: 1.25;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__meta {
+  max-width: 100%;
+  font-size: 0.8125rem;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__divider {
+  margin-inline: 0.5rem;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__progress {
+  flex-basis: auto;
+  width: 6rem;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__status-text {
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.125rem;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-overlay__header {
+  row-gap: 0.625rem;
+  padding: 0.875rem 1rem 0.75rem;
+}
+
+/* The status and its facts are on separate lines: no rule between them */
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar__status-text > .er-booking-bar__divider {
+  display: none;
+}
+
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'])
+    .er-booking-bar
+    .er-booking-bar__inner
+    > .er-booking-bar__cta {
+  min-height: 2.5rem;
+  padding: 0.5rem 1rem;
+  font-size: 0.875rem;
+}
+}
 }
 
 :where(.theme-scope)
@@ -75676,7 +76942,9 @@ const containerResponsiveThemeCss = `/*
   height: 100dvh;
   min-height: 0;
   overflow: hidden;
-  background: rgb(var(--tb-background));
+  /* Surface, like the card, the bar and the system page's column, and what
+     the embedded Stripe checkout is branded with (checkoutBranding.ts). */
+  background: rgb(var(--tb-surface));
   /* Foreground and button context: theme-core/src/blocks/opaquePanels.ts. */
 }
 
@@ -75686,36 +76954,70 @@ const containerResponsiveThemeCss = `/*
   flex: 0 0 auto;
   z-index: 2;
   display: flex;
-  align-items: center;
+  flex-wrap: wrap;
+  align-items: flex-start;
   justify-content: space-between;
-  gap: 1rem;
-  padding: 1rem;
-  background: rgb(var(--tb-background));
+  gap: 0.875rem 1rem;
+  padding: 1.125rem 1.25rem 1rem;
+  background: rgb(var(--tb-surface));
   border-bottom: 1px solid var(--er-border);
 }
 
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-overlay__progress {
+  /* Pinned under the title, so the step stays in view while the step scrolls
+     (issue 1581). It takes the header's full width, on its own row. */
+  flex: 1 0 100%;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-overlay__progress
+  .rb-progress {
+  margin-bottom: 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-overlay__heading {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  min-width: 0;
+}
+
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-overlay__title {
   margin: 0;
-  font-size: 1rem;
-  line-height: 1.25;
-  font-weight: 700;
+  font-family: var(--font-heading, inherit);
+  font-size: 1.5rem;
+  line-height: 1.15;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-booking-overlay__subtitle {
+  margin: 0;
+  font-size: 0.875rem;
+  line-height: 1.4;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
 }
 
 :where(.theme-scope)
   :where([data-block='event-registration'])
   .er-booking-overlay__close {
-  width: 2rem;
-  height: 2rem;
+  flex: 0 0 auto;
+  width: 2.75rem;
+  height: 2.75rem;
   display: inline-flex;
   align-items: center;
   justify-content: center;
   border: 1px solid var(--er-border);
   border-radius: 999px;
   background: transparent;
-  color: rgb(var(--tb-text));
-  font-size: 1.25rem;
+  color: inherit;
   line-height: 1;
   cursor: pointer;
 }
@@ -75754,7 +77056,71 @@ const containerResponsiveThemeCss = `/*
   .er-payment-layout-main {
   min-height: 0;
   overflow: auto;
-  padding: 1rem;
+  padding: 1.25rem;
+}
+
+/* Processing, confirmation and error take the whole panel (issue 1581) */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  .er-whole-screen {
+  flex: 1 1 auto;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  .er-whole-screen__body {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow: auto;
+  padding: 1.5rem 1.25rem;
+}
+
+/* The confirmation's one action sits where the steps' Continue does: pinned
+   and full width in the panel, flowing under the content in the aside. */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-whole-screen__footer {
+  margin-top: 1.5rem;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  .er-whole-screen__footer {
+  margin-top: 0;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  .er-whole-screen__footer
+  .er-whole-screen__action {
+  width: 100%;
+  justify-content: center;
+}
+
+/* The header already names the event and its date, so the footer summary
+   drops its title and schedule; the discount keeps just its name. */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  :is(.er-summary-bar-event, .er-summary-bar-schedule, .er-summary-bar-discount-detail) {
+  display: none;
+}
+
+/* On the date step the chosen date is the news, so it stays. */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-container--overlay
+  .er-summary-bar[data-step='select-event']
+  .er-summary-bar-schedule {
+  display: inline;
+  color: inherit;
 }
 
 :where(.theme-scope)
@@ -75764,9 +77130,9 @@ const containerResponsiveThemeCss = `/*
   position: relative;
   z-index: 3;
   padding: 0.875rem 1rem max(0.875rem, env(safe-area-inset-bottom));
-  background: rgb(var(--tb-background));
+  background: rgb(var(--tb-surface));
   border-top: 1px solid var(--er-border);
-  box-shadow: 0 -12px 26px rgba(var(--tb-shadow), 0.12);
+  box-shadow: 0 -12px 26px rgb(var(--tb-shadow) / 0.12);
 }
 
 :where(.theme-scope)
@@ -75789,14 +77155,14 @@ const containerResponsiveThemeCss = `/*
     .er-booking-overlay__panel {
     width: min(32rem, 100vw);
     min-height: 100%;
-    box-shadow: -16px 0 40px rgba(var(--tb-shadow), 0.22);
+    box-shadow: -16px 0 40px rgb(var(--tb-shadow) / 0.22);
   }
 
   :where(.theme-scope:is(*, :scope))
     :where([data-block='event-registration'])
     .er-container--overlay
     .er-payment-layout-main {
-    padding: 1.25rem;
+    padding: 1.5rem;
   }
 
   :where(.theme-scope:is(*, :scope))
@@ -75808,6 +77174,125 @@ const containerResponsiveThemeCss = `/*
 }
 }
 
+/* The system event page hosts the same panel in its sticky column (issue 1581):
+   from 1024px the steps scroll inside it and the footer stays pinned. */
+@container rb-site (min-width: 1024px) {
+@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
+:where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-container {
+    display: flex;
+    max-height: calc(100dvh - 9rem);
+    min-height: 0;
+  }
+
+  :where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-payment-layout {
+    flex: 1 1 auto;
+    min-height: 0;
+    gap: 0;
+    grid-template-rows: minmax(0, 1fr) auto;
+    grid-template-areas:
+      'main'
+      'footer';
+  }
+
+  :where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-payment-layout-main {
+    min-height: 0;
+    overflow: auto;
+    padding-bottom: 1rem;
+  }
+
+  :where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-payment-layout-footer {
+    padding-top: 0.875rem;
+    border-top: 1px solid var(--er-border);
+  }
+
+  :where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-whole-screen {
+    flex: 1 1 auto;
+    display: flex;
+    flex-direction: column;
+    min-height: 0;
+  }
+
+  :where(.theme-scope:is(*, :scope))
+    :where([data-block='event-registration'].event-registration--embedded)
+    .er-whole-screen__body {
+    flex: 1 1 auto;
+    min-height: 0;
+    overflow: auto;
+  }
+}
+}
+
+/* Confirmation summary: only the facts known for certain */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-confirmation-summary {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  margin: 1.5rem 0 0;
+  padding: 1.125rem 1.25rem;
+  border: 1px solid var(--er-border);
+  border-radius: var(--rb-block-radius);
+  font-size: 0.9375rem;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-confirmation-summary__row {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-confirmation-summary__row dt {
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-confirmation-summary__row dd {
+  margin: 0;
+  font-weight: 700;
+  text-align: end;
+}
+
+/* Why passes and memberships are greyed out for more than one place */
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-entitlement-note {
+  margin: 0;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--er-border);
+  font-size: 0.875rem;
+  color: var(--rb-reg-on-surface-muted, rgb(var(--tb-text) / 0.75));
+}
+
+:where(.theme-scope)
+  :where([data-block='event-registration'])
+  .er-entitlement-note__action {
+  padding: 0;
+  border: 0;
+  background: none;
+  color: rgb(var(--tb-primary));
+  font: inherit;
+  font-weight: 700;
+  text-decoration: underline;
+  text-underline-offset: 3px;
+  cursor: pointer;
+}
+
 /* Magic Link Form */
 :where(.theme-scope)
   :where([data-block='event-registration'])
@@ -75883,8 +77368,8 @@ const containerResponsiveThemeCss = `/*
   align-items: flex-start;
   gap: 0.75rem;
   padding: 1rem 1.25rem;
-  background: rgba(var(--tb-primary-100), 0.4);
-  border: 1px solid rgba(var(--tb-primary-300), 0.4);
+  background: rgb(var(--tb-primary-100) / 0.4);
+  border: 1px solid rgb(var(--tb-primary-300) / 0.4);
   border-radius: var(--rb-block-radius);
 }
 
@@ -75932,201 +77417,6 @@ const containerResponsiveThemeCss = `/*
 }
 
 /* Selection cards for pass holders */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-cards {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-  gap: 1rem;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.5rem;
-  padding: 1.25rem 1rem;
-  border: 2px solid var(--er-payment-border);
-  border-radius: var(--rb-block-radius);
-  background: transparent;
-  cursor: pointer;
-  text-align: center;
-  position: relative;
-  transition:
-    border-color var(--rb-block-transition) ease,
-    background-color var(--rb-block-transition) ease;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card:hover:not([aria-disabled='true']) {
-  border-color: var(--er-payment-border-hover);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--selected {
-  border-color: var(--er-payment-border-selected);
-  background-color: var(--er-payment-bg-selected);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled {
-  opacity: 1;
-  cursor: not-allowed;
-  border-color: var(--er-payment-border);
-  background: transparent;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled.er-booking-mode-card--selected {
-  border-color: var(--er-payment-border);
-  background: transparent;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled
-  > :not(.er-booking-mode-tooltip) {
-  opacity: 0.55;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled:hover {
-  border-color: var(--er-payment-border);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled
-  .er-booking-mode-card-icon,
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled
-  .er-booking-mode-card-label {
-  color: var(--er-on-surface-disabled);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled
-  .er-booking-mode-card-detail {
-  color: var(--er-on-surface-disabled-detail);
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card-icon {
-  font-size: 1.75rem;
-  line-height: 1;
-  /* SVG icon sizing */
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card-icon
-  svg {
-  width: 24px;
-  height: 24px;
-  color: currentColor;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card-label {
-  font-weight: 600;
-  font-size: 1rem;
-  line-height: 1.3;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card-detail {
-  font-size: 0.875rem;
-  color: var(--er-on-surface-subtle);
-  line-height: 1.3;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card-check {
-  position: absolute;
-  top: 0.5rem;
-  right: 0.5rem;
-}
-
-/* Alternative link in booking mode */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-alt {
-  margin-top: 1rem;
-  text-align: center;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-alt-link {
-  background: none;
-  border: none;
-  padding: 0;
-  font-size: 0.9375rem;
-  color: rgb(var(--tb-primary));
-  cursor: pointer;
-  text-decoration: underline;
-  text-underline-offset: 2px;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-alt-link:hover {
-  text-decoration: none;
-}
-
-/* Tooltip styling for disabled options */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card[aria-disabled='true'] {
-  position: relative;
-}
-
-/* Tooltip appears on hover for disabled cards */
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-tooltip {
-  display: none;
-  position: absolute;
-  bottom: 100%;
-  left: 50%;
-  transform: translateX(-50%);
-  margin-bottom: 0.5rem;
-  padding: 0.5rem 0.75rem;
-  background: rgb(var(--tb-text));
-  color: rgb(var(--tb-background));
-  font-size: 0.8125rem;
-  font-weight: 500;
-  border-radius: calc(var(--rb-block-radius) * 0.5);
-  white-space: normal;
-  max-width: 16rem;
-  line-height: 1.35;
-  text-align: center;
-  box-shadow: 0 8px 20px rgba(var(--tb-shadow), 0.28);
-  z-index: 10;
-}
-
-:where(.theme-scope)
-  :where([data-block='event-registration'])
-  .er-booking-mode-card--disabled:hover
-  .er-booking-mode-tooltip {
-  display: block;
-}
 
 /* =============================================================================
  * Block: Event Calendar
@@ -76355,7 +77645,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-calendar-more:hover {
-  background-color: rgba(var(--tb-primary), 0.1);
+  background-color: rgb(var(--tb-primary) / 0.1);
 }
 
 :where(.theme-scope)
@@ -76429,7 +77719,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-category-btn:hover:not(:disabled) {
-  border-color: rgba(var(--tb-primary), 0.5);
+  border-color: rgb(var(--tb-primary) / 0.5);
 }
 
 :where(.theme-scope)
@@ -76502,7 +77792,7 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-calendar'])
   .event-calendar-view-btn:hover {
   opacity: 1;
-  border-color: rgba(var(--tb-primary), 0.5);
+  border-color: rgb(var(--tb-primary) / 0.5);
 }
 
 :where(.theme-scope)
@@ -76619,7 +77909,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-agenda-card:hover {
-  border-color: rgba(var(--tb-primary), 0.5);
+  border-color: rgb(var(--tb-primary) / 0.5);
   background-color: var(--ec-event-bg);
 }
 
@@ -77068,7 +78358,7 @@ const containerResponsiveThemeCss = `/*
   border-left-width: 4px;
   border-radius: calc(var(--rb-block-radius) / 1.5);
   background-color: var(--ec-surface);
-  box-shadow: 0 1px 2px rgba(var(--tb-text), 0.08);
+  box-shadow: 0 1px 2px rgb(var(--tb-text) / 0.08);
   cursor: pointer;
   font: inherit;
   text-align: left;
@@ -77082,7 +78372,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-timetable-event:hover {
-  box-shadow: 0 4px 12px rgba(var(--tb-text), 0.12);
+  box-shadow: 0 4px 12px rgb(var(--tb-text) / 0.12);
   transform: translateY(-1px);
 }
 
@@ -77234,7 +78524,7 @@ const containerResponsiveThemeCss = `/*
    * available -> secondary, filling -> accent, waitlist -> muted text. */
   --ec-status-available: rgb(var(--tb-secondary));
   --ec-status-filling: rgb(var(--tb-accent));
-  --ec-status-waitlist: rgba(var(--tb-text), 0.4);
+  --ec-status-waitlist: rgb(var(--tb-text) / 0.4);
   --event-week-board-cols: 7;
 
   border: 1px solid var(--ec-border);
@@ -77248,7 +78538,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-week-board[data-elevated] {
-  box-shadow: 0 14px 34px -24px rgba(var(--tb-text), 0.35);
+  box-shadow: 0 14px 34px -24px rgb(var(--tb-text) / 0.35);
 }
 
 /* Top bar: authored title + week navigation + legend */
@@ -77521,8 +78811,8 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-calendar'])
   .event-week-board-card:hover {
   transform: translateY(-2px);
-  box-shadow: 0 6px 16px -8px rgba(var(--tb-text), 0.28);
-  border-color: rgba(var(--tb-primary), 0.4);
+  box-shadow: 0 6px 16px -8px rgb(var(--tb-text) / 0.28);
+  border-color: rgb(var(--tb-primary) / 0.4);
 }
 
 :where(.theme-scope)
@@ -77565,24 +78855,24 @@ const containerResponsiveThemeCss = `/*
    * Filling -> amber and waitlist -> muted outline are handled by the
    * data-status overrides below. */
   border: 1px solid var(--ec-border);
-  background-color: rgba(var(--tb-text), 0.06);
-  color: rgba(var(--tb-text), 0.62);
+  background-color: rgb(var(--tb-text) / 0.06);
+  color: rgb(var(--tb-text) / 0.62);
   border-color: var(--ec-border);
 }
 
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-week-board-card-pill[data-status='filling'] {
-  background-color: rgba(var(--tb-accent), 0.14);
+  background-color: rgb(var(--tb-accent) / 0.14);
   color: var(--ec-status-filling);
-  border-color: rgba(var(--tb-accent), 0.32);
+  border-color: rgb(var(--tb-accent) / 0.32);
 }
 
 :where(.theme-scope)
   :where([data-block='event-calendar'])
   .event-week-board-card-pill[data-status='waitlist'] {
   background-color: transparent;
-  color: rgba(var(--tb-text), 0.6);
+  color: rgb(var(--tb-text) / 0.6);
   border-color: var(--ec-border);
 }
 
@@ -77867,7 +79157,7 @@ const containerResponsiveThemeCss = `/*
   :where([data-block='event-calendar'])
   .ec-modal-close:hover {
   opacity: 1;
-  background-color: rgba(var(--tb-text), 0.1);
+  background-color: rgb(var(--tb-text) / 0.1);
 }
 
 :where(.theme-scope)
@@ -78110,23 +79400,24 @@ const containerResponsiveThemeCss = `/*
 }
 
 /* State icon color variants (layout from registration-surface.css) */
+/* Success: a solid primary disc with an on-primary tick (issue 1581) */
 :where(.theme-scope) :where([data-block="appointment-booking"]) .rb-state-icon--success {
-  background: var(--ab-success-bg, rgba(var(--tb-success, 22 163 74), 0.1));
-  color: var(--ab-success-text, rgb(var(--tb-success, 22 163 74)));
+  background: rgb(var(--tb-primary, 37 99 235));
+  color: rgb(var(--tb-onPrimary, 255 255 255));
 }
 
 :where(.theme-scope) :where([data-block="appointment-booking"]) .rb-state-icon--error {
-  background: var(--ab-error-bg, rgba(var(--tb-destructive, 220 38 38), 0.1));
+  background: var(--ab-error-bg, rgb(var(--tb-destructive, 220 38 38) / 0.1));
   color: var(--ab-error-text, rgb(var(--tb-destructive, 220 38 38)));
 }
 
 :where(.theme-scope) :where([data-block="appointment-booking"]) .rb-state-icon--info {
-  background: var(--ab-info-bg, rgba(var(--tb-info, 14 165 233), 0.1));
+  background: var(--ab-info-bg, rgb(var(--tb-info, 14 165 233) / 0.1));
   color: var(--ab-info-text, rgb(var(--tb-info, 14 165 233)));
 }
 
 :where(.theme-scope) :where([data-block="appointment-booking"]) .rb-state-icon--warning {
-  background: var(--ab-warning-bg, rgba(var(--tb-warning, 245 158 11), 0.1));
+  background: var(--ab-warning-bg, rgb(var(--tb-warning, 245 158 11) / 0.1));
   color: var(--ab-warning-text, rgb(var(--tb-warning, 245 158 11)));
 }
 
@@ -78168,7 +79459,7 @@ const containerResponsiveThemeCss = `/*
   letter-spacing: 0;
   line-height: 1.2;
   text-transform: uppercase;
-  color: var(--rb-reg-on-surface-subtle, rgba(var(--tb-onSurface, var(--tb-text, 15 23 42)), 0.6));
+  color: var(--rb-reg-on-surface-subtle, rgb(var(--tb-onSurface, var(--tb-text, 15 23 42)) / 0.6));
 }
 
 :where(.theme-scope) :where([data-block="appointment-booking"]) .ab-pill-value {
@@ -78785,11 +80076,11 @@ const containerResponsiveThemeCss = `/*
   height: 2.5rem;
   width: 2.5rem;
   border-radius: 9999px;
-  border: 1px solid rgba(var(--tb-border, 229 231 235), 0.35);
-  background-color: rgba(var(--tb-surface, 248 250 252), 0.9);
+  border: 1px solid rgb(var(--tb-border, 229 231 235) / 0.35);
+  background-color: rgb(var(--tb-surface, 248 250 252) / 0.9);
   color: rgb(var(--tb-text, 17 24 39));
-  box-shadow: 0 4px 6px -1px rgba(var(--tb-shadow), 0.1),
-    0 2px 4px -2px rgba(var(--tb-shadow), 0.1);
+  box-shadow: 0 4px 6px -1px rgb(var(--tb-shadow) / 0.1),
+    0 2px 4px -2px rgb(var(--tb-shadow) / 0.1);
   cursor: pointer;
   transform: translateY(-50%);
   transition: background-color 0.2s ease, box-shadow 0.2s ease,
@@ -78806,8 +80097,8 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope) .carousel-root .carousel-nav-btn:hover {
   background-color: rgb(var(--tb-surface, 248 250 252));
-  box-shadow: 0 10px 15px -3px rgba(var(--tb-shadow), 0.1),
-    0 4px 6px -4px rgba(var(--tb-shadow), 0.1);
+  box-shadow: 0 10px 15px -3px rgb(var(--tb-shadow) / 0.1),
+    0 4px 6px -4px rgb(var(--tb-shadow) / 0.1);
 }
 
 :where(.theme-scope) .carousel-root .carousel-nav-btn:disabled {
@@ -78856,10 +80147,10 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) .carousel-root.rb-carousel-dots-overlay .carousel-dot {
-  background-color: rgba(var(--tb-surface, 248 250 252), 0.55);
+  background-color: rgb(var(--tb-surface, 248 250 252) / 0.55);
 }
 :where(.theme-scope) .carousel-root.rb-carousel-dots-overlay .carousel-dot:hover {
-  background-color: rgba(var(--tb-surface, 248 250 252), 0.75);
+  background-color: rgb(var(--tb-surface, 248 250 252) / 0.75);
 }
 :where(.theme-scope) .carousel-root.rb-carousel-dots-overlay .carousel-dot[data-active="true"] {
   background-color: rgb(var(--tb-text, 17 24 39));
@@ -78875,7 +80166,7 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) .carousel-root .carousel-dot:hover {
-  background-color: rgba(var(--tb-text, 17 24 39), 0.3);
+  background-color: rgb(var(--tb-text, 17 24 39) / 0.3);
 }
 
 :where(.theme-scope) .carousel-root .carousel-dot[data-active="true"] {
@@ -78884,7 +80175,7 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope) .carousel-root .carousel-dot:focus-visible {
   outline: none;
-  box-shadow: 0 0 0 3px rgba(var(--tb-primary, 59 130 246), 0.35);
+  box-shadow: 0 0 0 3px rgb(var(--tb-primary, 59 130 246) / 0.35);
 }
 
 /* =============================================================================
@@ -78921,7 +80212,7 @@ const containerResponsiveThemeCss = `/*
 
 /* Error display */
 :where(.theme-scope) .shop__error {
-  background-color: rgba(var(--tb-destructive), 0.1);
+  background-color: rgb(var(--tb-destructive) / 0.1);
   color: rgb(var(--tb-destructive));
   padding: 0.75rem 1rem;
   border-radius: var(--shop-control-radius);
@@ -79193,7 +80484,7 @@ const containerResponsiveThemeCss = `/*
 
 /* Modal error */
 :where(.theme-scope) .shop__modal-error {
-  background-color: rgba(var(--tb-destructive), 0.1);
+  background-color: rgb(var(--tb-destructive) / 0.1);
   color: rgb(var(--tb-destructive));
   padding: 0.625rem 0.75rem;
   border-radius: var(--shop-control-radius);
@@ -79245,12 +80536,12 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) :where([data-block="shop"]) .rb-state-icon--success {
-  background: rgba(var(--tb-success), 0.12);
+  background: rgb(var(--tb-success) / 0.12);
   color: rgb(var(--tb-success));
 }
 
 :where(.theme-scope) :where([data-block="shop"]) .rb-state-icon--warning {
-  background: rgba(var(--tb-warning), 0.12);
+  background: rgb(var(--tb-warning) / 0.12);
   color: rgb(var(--tb-warning));
 }
 
@@ -79752,7 +81043,7 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope) :where([data-block="customer-portal"]) .cp-table thead th {
   text-align: left;
-  background: rgba(var(--tb-border), 0.2);
+  background: rgb(var(--tb-border) / 0.2);
 }
 
 :where(.theme-scope)
@@ -80593,17 +81884,17 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope) :where(.rb-tile--interactive, .er-event-card):focus-visible {
   outline: none;
-  box-shadow: 0 0 0 3px rgba(var(--tb-primary), 0.25);
+  box-shadow: 0 0 0 3px rgb(var(--tb-primary) / 0.25);
 }
 
 :where(.theme-scope) :where(.rb-tile--interactive, .er-event-card):hover:not(:disabled) {
-  border-color: var(--rb-tile-border-hover, var(--rb-event-tile-border-hover, rgba(var(--tb-primary), 0.5)));
+  border-color: var(--rb-tile-border-hover, var(--rb-event-tile-border-hover, rgb(var(--tb-primary) / 0.5)));
   opacity: var(--rb-tile-hover-opacity, var(--rb-event-tile-hover-opacity, var(--rb-tile-opacity, var(--rb-event-tile-opacity, 1))));
 }
 
 :where(.theme-scope) :where(.rb-tile--selected, .er-event-card--selected) {
   border-color: var(--rb-tile-border-selected, var(--rb-event-tile-border-selected, rgb(var(--tb-primary))));
-  background: var(--rb-tile-bg-selected, var(--rb-event-tile-bg-selected, rgba(var(--tb-primary), 0.1)));
+  background: var(--rb-tile-bg-selected, var(--rb-event-tile-bg-selected, rgb(var(--tb-primary) / 0.1)));
 }
 
 :where(.theme-scope) :where(.rb-tile--disabled, .er-event-card--disabled) {
@@ -80917,7 +82208,7 @@ const containerResponsiveThemeCss = `/*
 
 :where(.theme-scope) .newsletter-success .fb-success {
   padding: 1rem 1.5rem;
-  background-color: rgba(var(--tb-success, 34 197 94), 0.1);
+  background-color: rgb(var(--tb-success, 34 197 94) / 0.1);
   border-radius: var(--radius-md, 0.5rem);
   color: rgb(var(--tb-text));
 }
@@ -81189,7 +82480,7 @@ const containerResponsiveThemeCss = `/*
  * context (theme-core/src/blocks/opaquePanels.ts) hold on any section. */
 :where(.theme-scope) .feedback-callout {
   background: rgb(var(--tb-surface, 248 250 252));
-  border-color: rgba(var(--tb-border, 226 232 240), 0.72);
+  border-color: rgb(var(--tb-border, 226 232 240) / 0.72);
   --rb-feedback-callout-bg-opacity: 0.1;
   --rb-feedback-callout-border-opacity: 0.24;
 }
@@ -81197,33 +82488,33 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope) .feedback-callout[data-feedback-tone="info"] {
   --rb-feedback-callout-bg-opacity: 0.08;
   background:
-    linear-gradient(rgba(var(--tb-primary, 37 99 235), var(--rb-feedback-callout-bg-opacity)), rgba(var(--tb-primary, 37 99 235), var(--rb-feedback-callout-bg-opacity))),
+    linear-gradient(rgb(var(--tb-primary, 37 99 235) / var(--rb-feedback-callout-bg-opacity)), rgb(var(--tb-primary, 37 99 235) / var(--rb-feedback-callout-bg-opacity))),
     rgb(var(--tb-surface, 248 250 252));
-  border-color: rgba(var(--tb-primary, 37 99 235), var(--rb-feedback-callout-border-opacity));
+  border-color: rgb(var(--tb-primary, 37 99 235) / var(--rb-feedback-callout-border-opacity));
 }
 
 :where(.theme-scope) .feedback-callout[data-feedback-tone="success"] {
   background:
-    linear-gradient(rgba(var(--tb-success, 34 197 94), var(--rb-feedback-callout-bg-opacity)), rgba(var(--tb-success, 34 197 94), var(--rb-feedback-callout-bg-opacity))),
+    linear-gradient(rgb(var(--tb-success, 34 197 94) / var(--rb-feedback-callout-bg-opacity)), rgb(var(--tb-success, 34 197 94) / var(--rb-feedback-callout-bg-opacity))),
     rgb(var(--tb-surface, 248 250 252));
-  border-color: rgba(var(--tb-success, 34 197 94), var(--rb-feedback-callout-border-opacity));
+  border-color: rgb(var(--tb-success, 34 197 94) / var(--rb-feedback-callout-border-opacity));
 }
 
 :where(.theme-scope) .feedback-callout[data-feedback-tone="warning"] {
   --rb-feedback-callout-bg-opacity: 0.12;
   --rb-feedback-callout-border-opacity: 0.28;
   background:
-    linear-gradient(rgba(var(--tb-warning, 245 158 11), var(--rb-feedback-callout-bg-opacity)), rgba(var(--tb-warning, 245 158 11), var(--rb-feedback-callout-bg-opacity))),
+    linear-gradient(rgb(var(--tb-warning, 245 158 11) / var(--rb-feedback-callout-bg-opacity)), rgb(var(--tb-warning, 245 158 11) / var(--rb-feedback-callout-bg-opacity))),
     rgb(var(--tb-surface, 248 250 252));
-  border-color: rgba(var(--tb-warning, 245 158 11), var(--rb-feedback-callout-border-opacity));
+  border-color: rgb(var(--tb-warning, 245 158 11) / var(--rb-feedback-callout-border-opacity));
 }
 
 :where(.theme-scope) .feedback-callout[data-feedback-tone="error"] {
   --rb-feedback-callout-border-opacity: 0.26;
   background:
-    linear-gradient(rgba(var(--tb-destructive, 239 68 68), var(--rb-feedback-callout-bg-opacity)), rgba(var(--tb-destructive, 239 68 68), var(--rb-feedback-callout-bg-opacity))),
+    linear-gradient(rgb(var(--tb-destructive, 239 68 68) / var(--rb-feedback-callout-bg-opacity)), rgb(var(--tb-destructive, 239 68 68) / var(--rb-feedback-callout-bg-opacity))),
     rgb(var(--tb-surface, 248 250 252));
-  border-color: rgba(var(--tb-destructive, 239 68 68), var(--rb-feedback-callout-border-opacity));
+  border-color: rgb(var(--tb-destructive, 239 68 68) / var(--rb-feedback-callout-border-opacity));
 }
 
 :where(.theme-scope) .feedback-callout__title {
@@ -81294,7 +82585,7 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) .event-compact-row:hover {
-  background-color: rgba(var(--tb-primary, 0 0 0), 0.035);
+  background-color: rgb(var(--tb-primary, 0 0 0) / 0.035);
 }
 
 :where(.theme-scope) .event-compact-row-date {
@@ -81702,23 +82993,23 @@ const containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="success"] {
-  border-color: rgba(var(--tb-success, 34 197 94), 0.3);
+  border-color: rgb(var(--tb-success, 34 197 94) / 0.3);
   background:
-    linear-gradient(rgba(var(--tb-success, 34 197 94), 0.1), rgba(var(--tb-success, 34 197 94), 0.1)),
+    linear-gradient(rgb(var(--tb-success, 34 197 94) / 0.1), rgb(var(--tb-success, 34 197 94) / 0.1)),
     rgb(var(--tb-surface, 255 255 255));
 }
 
 :where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="warning"] {
-  border-color: rgba(var(--tb-warning, 245 158 11), 0.35);
+  border-color: rgb(var(--tb-warning, 245 158 11) / 0.35);
   background:
-    linear-gradient(rgba(var(--tb-warning, 245 158 11), 0.12), rgba(var(--tb-warning, 245 158 11), 0.12)),
+    linear-gradient(rgb(var(--tb-warning, 245 158 11) / 0.12), rgb(var(--tb-warning, 245 158 11) / 0.12)),
     rgb(var(--tb-surface, 255 255 255));
 }
 
 :where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="error"] {
-  border-color: rgba(var(--tb-destructive, 239 68 68), 0.3);
+  border-color: rgb(var(--tb-destructive, 239 68 68) / 0.3);
   background:
-    linear-gradient(rgba(var(--tb-destructive, 239 68 68), 0.1), rgba(var(--tb-destructive, 239 68 68), 0.1)),
+    linear-gradient(rgb(var(--tb-destructive, 239 68 68) / 0.1), rgb(var(--tb-destructive, 239 68 68) / 0.1)),
     rgb(var(--tb-surface, 255 255 255));
 }
 
@@ -81832,7 +83123,7 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope) .rb-feature-card-icon-zone--utility-badge {
   background-color: rgb(var(--tb-surface));
   border: 1px solid rgb(var(--tb-border));
-  box-shadow: 0 1px 2px rgba(var(--tb-shadow), 0.08);
+  box-shadow: 0 1px 2px rgb(var(--tb-shadow) / 0.08);
 }
 
 :where(.theme-scope) .rb-feature-card-icon {
@@ -82621,7 +83912,7 @@ const containerResponsiveThemeCss = `/*
   grid-template-columns: minmax(5.5rem, 0.65fr) minmax(0, 1.35fr);
   gap: 1rem;
   padding-block: 0.6rem;
-  border-top: 1px solid rgba(var(--tb-border), 0.72);
+  border-top: 1px solid rgb(var(--tb-border) / 0.72);
 }
 
 :where(.theme-scope)
@@ -82861,13 +84152,13 @@ const containerResponsiveThemeCss = `/*
 :where(.theme-scope) [data-block="testimonials"][data-block-composition="open-editorial"] .rb-testimonial-attribution {
   margin-top: 1.25rem;
   padding-top: 1.25rem;
-  border-top: 1px solid rgba(var(--tb-border), 0.75);
+  border-top: 1px solid rgb(var(--tb-border) / 0.75);
 }
 
 :where(.theme-scope) [data-block="testimonials"][data-block-composition="open-editorial"] .rb-testimonial-avatar {
   box-shadow:
     0 0 0 2px rgb(var(--tb-surface)),
-    0 0 0 4px rgba(var(--tb-primary), 0.3);
+    0 0 0 4px rgb(var(--tb-primary) / 0.3);
 }
 
 /* =============================================================================