@riverbankcms/sdk 0.151.0 → 0.153.0

package/dist/server/server.mjs

@@ -1765,12 +1765,14 @@ const unsafeAsSiteId = (id) => id;
 const unsafeAsApiKeyId = (id) => id;
 const unsafeAsEventOfferingId = (id) => id;
 const unsafeAsEventSeriesId = (id) => id;
+const unsafeAsMediaAssetId = (id) => id;
 const unsafeAsUserId = (id) => id;
 const unsafeAsContentVersionId = (id) => id;
 const parseSiteId = (value) => parseUuidBrand(value, unsafeAsSiteId);
 const parseApiKeyId = (value) => parseUuidBrand(value, unsafeAsApiKeyId);
 const parseEventOfferingId = (value) => parseUuidBrand(value, unsafeAsEventOfferingId);
 const parseUserId = (value) => parseUuidBrand(value, unsafeAsUserId);
+const parseMediaAssetId = (value) => parseUuidBrand(value, unsafeAsMediaAssetId);
 const parseContentVersionId = (value) => parseUuidBrand(value, unsafeAsContentVersionId);
 const parseEventSeriesId = (value) => parseUuidBrand(value, unsafeAsEventSeriesId);
 //#endregion
@@ -1975,6 +1977,29 @@ function canonicalEventPricingDisplay(pricing) {
 		default: return assertNever$6(pricing);
 	}
 }
+/**
+* The single renderer for a precomputed booking price `display` ADT. This is
+* the one place booking price variants map to user-facing strings — every call
+* site (booking entry, events calendar, event/course details, listings, portal)
+* should route through here so labels never drift. Adding a variant to the ADT
+* breaks compilation here (via `assertNever`) until it is handled.
+*/
+function formatBookingPriceDisplay(display, options = {}) {
+	switch (display.kind) {
+		case "free": return "Free";
+		case "exact": return formatCurrencyAmount(display.amount, display.currency, options);
+		case "from": return `From ${formatCurrencyAmount(display.amount, display.currency, options)}`;
+		case "range": return `${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)}`;
+		case "mixed": return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
+		case "unavailable": return "Pricing unavailable";
+		case "external": return display.label;
+		default: return assertNever$6(display);
+	}
+}
+/** Render an event's price directly from its pricing value. */
+function formatEventPricing(pricing, options = {}) {
+	return formatBookingPriceDisplay(publicEventPricingDisplay(pricing), options);
+}
 //#endregion
 //#region ../core/src/event-page-surface-subject.ts
 function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope, eventDestinationMode) {
@@ -2118,6 +2143,7 @@ function parseBookingTimeZone(timeZone) {
 }
 //#endregion
 //#region ../core/src/booking-date-time.ts
+const DEFAULT_LOCALE = "en-US";
 const FALLBACK_TIMEZONE = "UTC";
 const START_OF_DAY = {
 	hour: 0,
@@ -2240,6 +2266,34 @@ function toScheduledBookingDateTime(input) {
 	if (result.ok) return result.value;
 	throw new Error(formatParseError(result));
 }
+function formatBookingInstant(isoString, options) {
+	const date = new Date(isoString);
+	if (Number.isNaN(date.getTime())) return isoString;
+	return getCachedDateTimeFormatter(options.locale ?? DEFAULT_LOCALE, getSafeTimeZone(options.timeZone), options.format).format(date);
+}
+function formatBookingDate(input, format = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+}) {
+	return formatBookingInstant(input.startsAt, {
+		locale: input.locale,
+		timeZone: input.timeZone,
+		format
+	});
+}
+function formatBookingTime(input, format = {
+	hour: "numeric",
+	minute: "2-digit",
+	hour12: true
+}) {
+	return formatBookingInstant(input.startsAt, {
+		locale: input.locale,
+		timeZone: input.timeZone,
+		format
+	});
+}
 function getBookingLocalDateKey(input) {
 	return formatDateKey$1(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
 }
@@ -2389,7 +2443,7 @@ function parsePositiveInteger(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
 }
 function parseNewsletterListId(value) {
-	return parseTrimmedMatchingString(value, UUID_PATTERN);
+	return parseTrimmedMatchingString(typeof value === "string" ? value.toLowerCase() : value, UUID_PATTERN);
 }
 function parseMailchimpAccountId(value) {
 	return parseTrimmedMatchingString(value, OPAQUE_ID_PATTERN);
@@ -2431,8 +2485,15 @@ function parseMailingListProviderScope(value) {
 	}
 	return err$1("invalid_mailing_list_provider_scope");
 }
-//#endregion
-//#region ../core/src/mailing-list-setup-parser.ts
+z.unknown().transform((value, ctx) => {
+	const parsed = parseNewsletterAudience(value);
+	if (parsed.ok) return parsed.value;
+	ctx.addIssue({
+		code: "custom",
+		message: "Choose a valid newsletter audience."
+	});
+	return z.NEVER;
+});
 function parseMailingListGlobalForm(value) {
 	if (!isRecord$16(value)) return formError("shape");
 	const fields = parseGlobalFields(value.fields);
@@ -2452,6 +2513,16 @@ function parseMailingListGlobalForm(value) {
 		privacyNote
 	});
 }
+function parseNewsletterAudience(value) {
+	if (!isRecord$16(value)) return err$1("invalid_newsletter_audience");
+	if (value.kind === "general" && Object.keys(value).length === 1) return ok$1({ kind: "general" });
+	if (value.kind !== "topic" || Object.keys(value).some((key) => key !== "kind" && key !== "topicId")) return err$1("invalid_newsletter_audience");
+	const topicId = parseNewsletterListId(value.topicId);
+	return topicId === null ? err$1("invalid_newsletter_audience") : ok$1({
+		kind: "topic",
+		topicId
+	});
+}
 function parseGlobalFields(value) {
 	if (!isRecord$16(value) || typeof value.preset !== "string") return null;
 	switch (value.preset) {
@@ -2501,44 +2572,144 @@ function formError(field) {
 }
 //#endregion
 //#region ../core/src/mailing-list-targeting.ts
+const DEFAULT_MAILING_LIST_TARGETING = { mode: "default" };
+function mailingListTargetingChoiceIds(targeting) {
+	switch (targeting.provider) {
+		case "native": return targeting.selection.tag === "general" ? [] : targeting.selection.tag === "fixed" ? targeting.selection.topicIds : targeting.selection.offeredTopicIds;
+		case "brevo": return targeting.selection.tag === "fixed" ? targeting.selection.listIds : targeting.selection.offeredListIds;
+		case "mailchimp": return targeting.selection.tag === "fixed" ? targeting.selection.interestIds : targeting.selection.offeredInterestIds;
+	}
+}
 function planMailingListChoicePresentation(targeting) {
-	if (targeting.mode === "default" || targeting.selection.tag === "fixed") return { tag: "hidden" };
+	if (targeting.mode === "default" || targeting.selection.tag === "fixed" || targeting.selection.tag === "general") return { tag: "hidden" };
 	switch (targeting.provider) {
-		case "native": return targeting.selection.offeredTopicIds.length === 1 ? {
-			tag: "automatic",
-			selection: {
-				provider: "native",
-				topicIds: targeting.selection.offeredTopicIds
-			}
-		} : {
-			tag: "visitor_choice",
+		case "native": return presentVisitorSelection({
 			provider: "native",
-			optionCount: targeting.selection.offeredTopicIds.length
+			topicIds: targeting.selection.offeredTopicIds
+		}, targeting.selection.offeredTopicIds.length);
+		case "brevo": return presentVisitorSelection({
+			provider: "brevo",
+			listIds: targeting.selection.offeredListIds
+		}, targeting.selection.offeredListIds.length);
+		case "mailchimp": return presentVisitorSelection({
+			provider: "mailchimp",
+			interestIds: targeting.selection.offeredInterestIds
+		}, targeting.selection.offeredInterestIds.length);
+	}
+}
+function presentVisitorSelection(selection, optionCount) {
+	return optionCount === 1 ? {
+		tag: "automatic",
+		selection
+	} : {
+		tag: "visitor_choice",
+		provider: selection.provider,
+		optionCount
+	};
+}
+//#endregion
+//#region ../core/src/mailing-list-targeting-availability.ts
+function resolveMailingListDefaultDestination(provider) {
+	switch (provider.provider) {
+		case "native": {
+			const audience = provider.defaultAudience;
+			return audience.kind === "general" ? {
+				id: "general",
+				name: "General mailing list"
+			} : provider.topics.find((item) => item.id === audience.topicId) ?? 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 targeting.selection.offeredListIds.length === 1 ? {
-			tag: "automatic",
-			selection: {
-				provider: "brevo",
-				listIds: targeting.selection.offeredListIds
-			}
-		} : {
-			tag: "visitor_choice",
+		case "brevo": return catalog.provider === "brevo" ? assessMatchedChoices({
 			provider: "brevo",
-			optionCount: targeting.selection.offeredListIds.length
+			catalog,
+			targeting
+		}, catalog.lists) : {
+			tag: "unavailable",
+			reason: "provider_mismatch",
+			targeting
 		};
-		case "mailchimp": return targeting.selection.offeredInterestIds.length === 1 ? {
-			tag: "automatic",
-			selection: {
+		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",
-				interestIds: targeting.selection.offeredInterestIds
-			}
-		} : {
-			tag: "visitor_choice",
-			provider: "mailchimp",
-			optionCount: targeting.selection.offeredInterestIds.length
-		};
+				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) {
@@ -2584,11 +2755,12 @@ function parseRuntimeProvider(value) {
 	}
 }
 function parseNativeRuntimeProvider(value) {
-	const defaultTopicId = parseNewsletterListId(value.defaultTopicId);
+	if ("defaultTopicId" in value) return null;
+	const defaultAudience = parseNewsletterAudience(value.defaultAudience);
 	const topics = parseNamedItems(value.topics, parseNewsletterListId);
-	return defaultTopicId !== null && topics !== null ? {
+	return defaultAudience.ok && topics !== null ? {
 		provider: "native",
-		defaultTopicId,
+		defaultAudience: defaultAudience.value,
 		topics
 	} : null;
 }
@@ -2604,57 +2776,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$15(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$15(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$15(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$15(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$15(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;
@@ -2670,6 +2832,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$14(value)) return targetingError("shape");
 	if (value.mode === "default") return ok$1({ mode: "default" });
 	if (value.mode !== "custom") return targetingError("mode");
@@ -2682,6 +2845,11 @@ function parseMailingListPlacementTargeting(value) {
 	}
 }
 function parseNativeTargeting(selection) {
+	if (selection.tag === "general") return Object.keys(selection).length === 1 ? ok$1({
+		mode: "custom",
+		provider: "native",
+		selection: { tag: "general" }
+	}) : targetingError("selection");
 	if (selection.tag === "fixed") {
 		const topicIds = parseNonEmptyUniqueIds(selection.topicIds, parseNewsletterListId);
 		return topicIds.ok ? ok$1({
@@ -2768,14 +2936,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$14(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3207,6 +3372,45 @@ function resolveSiteVerticalBookingConfig(rawConfig) {
 	};
 }
 //#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 ../api/src/publicEventEndpointDefinitions.ts
 const PUBLIC_EVENT_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 	checkPublicEventRegistrationNextStep: {
@@ -9457,6 +9661,13 @@ const API_ENDPOINTS$1 = {
 		auth: "public",
 		responseKind: "json"
 	},
+	demoClaimReadiness: {
+		path: "/demo/claims/{claimId}/readiness",
+		method: "GET",
+		auth: "user",
+		responseKind: "json",
+		errors: []
+	},
 	demoClaimMagicLink: {
 		path: "/demo/auth/send-magic-link",
 		method: "POST",
@@ -10362,7 +10573,7 @@ var SimpleCache = class {
 * 1. This constant
 * 2. The "version" field in package.json
 */
-const SDK_VERSION = "0.151.0";
+const SDK_VERSION = "0.153.0";
 //#endregion
 //#region src/client/error.ts
 let _Symbol$for;
@@ -15667,7 +15878,96 @@ Object.keys(legacyItemSurfaceCardRoles);
 */
 const cardRoleWithLegacyAliasSchema = z.preprocess((value) => normalizeCardRole(value) ?? (typeof value === "string" && Object.prototype.hasOwnProperty.call(legacyItemSurfaceCardRoles, value) ? legacyItemSurfaceCardRoles[value] : value), cardRoleSchema);
 //#endregion
-//#region ../theme-core/src/lib/media.ts
+//#region ../media-core/src/identifiers.ts
+function slugifyMediaIdentifier(value) {
+	return value.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function parseMediaIdentifier(value) {
+	if (typeof value !== "string") return err$1({ kind: "not_string" });
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return err$1({ kind: "empty_identifier" });
+	const normalized = slugifyMediaIdentifier(trimmed);
+	if (normalized.length === 0) return err$1({
+		kind: "empty_after_normalization",
+		value
+	});
+	return ok$1(normalized);
+}
+/**
+* Admits identifiers read from trusted persistence without repairing dirty data in memory.
+* User input should use parseMediaIdentifier, which intentionally canonicalizes it.
+*/
+function parseCanonicalMediaIdentifier(value) {
+	if (typeof value !== "string") return err$1({ kind: "not_string" });
+	const parsed = parseMediaIdentifier(value);
+	if (!parsed.ok) return parsed;
+	if (value !== parsed.value) return err$1({
+		kind: "non_canonical_identifier",
+		value,
+		canonical: parsed.value
+	});
+	return parsed;
+}
+//#endregion
+//#region ../media-core/src/mediaIdentifierSchema.ts
+/** Strict stored-reference admission delegates the canonical identifier decision. */
+const mediaIdentifierSchema = z.string().transform((value, context) => {
+	const parsed = parseCanonicalMediaIdentifier(value);
+	if (parsed.ok) return parsed.value;
+	context.addIssue({
+		code: "custom",
+		message: "Expected a canonical media identifier"
+	});
+	return z.NEVER;
+});
+//#endregion
+//#region ../media-core/src/mediaKinds.ts
+const mediaTypeDiscriminants = [
+	"image",
+	"video",
+	"audio",
+	"document",
+	"spreadsheet",
+	"archive"
+];
+//#endregion
+//#region ../media-core/src/renderableMediaAsset.ts
+/** A portable reference never uses an incidental UUID, URL or storage snapshot for identity. */
+function resolveManagedMediaReference(reference, index) {
+	const asset = index?.byIdentifier.get(reference.identifier);
+	return asset ? {
+		kind: "resolved",
+		reference,
+		asset
+	} : {
+		kind: "missing",
+		reference
+	};
+}
+//#endregion
+//#region ../media-core/src/renderableMediaAssetAdmission.ts
+const mediaAssetIdSchema = z.string().transform((value, context) => {
+	const parsed = parseMediaAssetId(value);
+	if (parsed.ok) return parsed.value;
+	context.addIssue({
+		code: "custom",
+		message: "Expected a media asset ID"
+	});
+	return z.NEVER;
+});
+const nonemptyStorageValue = z.string().refine((value) => value.trim().length > 0);
+const renderableMediaAssetSchema = z.object({
+	id: mediaAssetIdSchema,
+	identifier: mediaIdentifierSchema,
+	storageBucket: nonemptyStorageValue,
+	storagePath: nonemptyStorageValue,
+	mimeType: nonemptyStorageValue,
+	filename: z.string().optional(),
+	width: z.number().positive().nullable(),
+	height: z.number().positive().nullable()
+});
+//#endregion
+//#region ../media-core/src/media.ts
 const hotspotSchema = z.object({
 	x: z.number().min(0).max(1),
 	y: z.number().min(0).max(1),
@@ -15701,56 +16001,185 @@ const transformSchema = z.object({
 	rotation: rotationSchema.optional()
 });
 const mediaPosterSchema = z.discriminatedUnion("tag", [z.object({
-	tag: z.literal("storage"),
-	assetId: z.string().optional(),
-	storageBucket: z.string().min(1),
-	storagePath: z.string().min(1)
-}), z.object({
+	tag: z.literal("media"),
+	identifier: mediaIdentifierSchema
+}).strict(), z.object({
 	tag: z.literal("external-src"),
-	assetId: z.string().optional(),
 	src: z.string().url()
-})]);
-const mediaBaseSchema = z.object({
+}).strict()]);
+const mediaUsageShape = {
 	purpose: z.string().optional(),
 	placeholder: z.boolean().default(true).optional(),
-	assetId: z.string().optional(),
-	identifier: z.string().optional(),
-	src: z.string().optional(),
 	alt: z.string().optional(),
 	filename: z.string().optional(),
-	mimeType: z.string().optional(),
 	width: z.number().optional(),
 	height: z.number().optional(),
-	storageBucket: z.string().optional(),
-	storagePath: z.string().optional(),
 	poster: mediaPosterSchema.optional(),
 	transform: transformSchema.optional()
-});
-const mediaIdentifierSchema = z.string().trim().min(1).brand();
+};
+const environmentExclusions = {
+	assetId: z.never().optional(),
+	id: z.never().optional(),
+	src: z.never().optional(),
+	storageBucket: z.never().optional(),
+	storagePath: z.never().optional(),
+	mimeType: z.never().optional()
+};
+const mediaBaseSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	identifier: mediaIdentifierSchema
+}).strict();
 const imageMediaSchema = mediaBaseSchema.extend({ type: z.literal("image") });
 const videoMediaSchema = mediaBaseSchema.extend({ type: z.literal("video") });
-const audioMediaSchema = mediaBaseSchema.extend({ type: z.literal("audio") });
-const documentMediaSchema = mediaBaseSchema.extend({ type: z.literal("document") });
-const spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z.literal("spreadsheet") });
-const archiveMediaSchema = mediaBaseSchema.extend({ type: z.literal("archive") });
-const mediaSchema = z.discriminatedUnion("type", [
-	imageMediaSchema,
-	videoMediaSchema,
-	audioMediaSchema,
-	documentMediaSchema,
-	spreadsheetMediaSchema,
-	archiveMediaSchema
-]);
-const persistableMediaBaseSchema = mediaBaseSchema.extend({ identifier: mediaIdentifierSchema });
-z.discriminatedUnion("type", [
-	persistableMediaBaseSchema.extend({ type: z.literal("image") }),
-	persistableMediaBaseSchema.extend({ type: z.literal("video") }),
-	persistableMediaBaseSchema.extend({ type: z.literal("audio") }),
-	persistableMediaBaseSchema.extend({ type: z.literal("document") }),
-	persistableMediaBaseSchema.extend({ type: z.literal("spreadsheet") }),
-	persistableMediaBaseSchema.extend({ type: z.literal("archive") })
+const mediaSchema = mediaBaseSchema.extend({ type: z.enum(mediaTypeDiscriminants) });
+const externalMediaSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	type: z.enum(mediaTypeDiscriminants),
+	src: z.string().min(1),
+	identifier: z.never().optional()
+}).strict();
+const assetMediaSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	type: z.enum(mediaTypeDiscriminants),
+	asset: renderableMediaAssetSchema,
+	identifier: z.never().optional()
+}).strict();
+const runtimeMediaSchema = z.union([
+	mediaSchema,
+	externalMediaSchema,
+	assetMediaSchema
 ]);
 //#endregion
+//#region ../media-core/src/typeGuards.ts
+function isRecord$12(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region ../media-core/src/transformRect.ts
+function isValidTransformRectStructure(rect) {
+	if (!Array.isArray(rect) || rect.length !== 4) return false;
+	const [left, top, width, height] = rect;
+	return Number.isFinite(left) && Number.isFinite(top) && Number.isFinite(width) && Number.isFinite(height) && left >= 0 && top >= 0 && width > 0 && height > 0;
+}
+//#endregion
+//#region ../media-core/src/aspectTransforms.ts
+const DEFAULT_RECT_EPSILON = .5;
+function parseAspectRatioValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized) return void 0;
+	if (normalized === "auto") return void 0;
+	if (normalized.includes(":") || normalized.includes("/")) {
+		const delimiter = normalized.includes(":") ? ":" : "/";
+		const [wRaw, hRaw] = normalized.split(delimiter);
+		const width = Number(wRaw?.trim());
+		const height = Number(hRaw?.trim());
+		if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return;
+		return width / height;
+	}
+	const numeric = Number(normalized);
+	if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
+	return numeric;
+}
+const MAX_ASPECT_DISTANCE = .25;
+function resolveMediaTransformForAspect(transform, targetAspect) {
+	if (!transform) return {};
+	const base = {
+		rect: transform.rect,
+		hotspot: transform.hotspot,
+		rotation: transform.rotation
+	};
+	const target = parseAspectRatioValue(targetAspect);
+	const crops = transform.aspectCrops;
+	if (!target || !crops || Object.keys(crops).length === 0) return base;
+	let best = null;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (const [key, candidate] of Object.entries(crops)) {
+		const candidateAspect = parseAspectRatioValue(candidate.aspect ?? key);
+		if (!candidateAspect) continue;
+		const distance = Math.abs(Math.log(candidateAspect / target));
+		if (distance < bestDistance) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	if (!best) return base;
+	if (bestDistance > MAX_ASPECT_DISTANCE) return base;
+	return {
+		rect: best.rect ?? base.rect,
+		hotspot: best.hotspot ?? base.hotspot,
+		rotation: best.rotation ?? base.rotation
+	};
+}
+function isValidTransformRect(rect) {
+	return isValidTransformRectStructure(rect);
+}
+function isExplicitRectCrop(rect, sourceWidth, sourceHeight, epsilon = DEFAULT_RECT_EPSILON) {
+	if (!isValidTransformRect(rect)) return false;
+	if (!(typeof sourceWidth === "number" && Number.isFinite(sourceWidth) && sourceWidth > 0 && typeof sourceHeight === "number" && Number.isFinite(sourceHeight) && sourceHeight > 0)) return true;
+	const [x, y, width, height] = rect;
+	return !(Math.abs(x) <= epsilon && Math.abs(y) <= epsilon && Math.abs(width - sourceWidth) <= epsilon && Math.abs(height - sourceHeight) <= epsilon);
+}
+//#endregion
+//#region ../media-core/src/rotation.ts
+function rotateNormalizedPoint(point, rotation) {
+	const x = point.x;
+	const y = point.y;
+	switch (rotation) {
+		case 0: return {
+			x,
+			y
+		};
+		case 90: return {
+			x: 1 - y,
+			y: x
+		};
+		case 180: return {
+			x: 1 - x,
+			y: 1 - y
+		};
+		case 270: return {
+			x: y,
+			y: 1 - x
+		};
+	}
+}
+//#endregion
+//#region ../media-core/src/mediaRefNormalizer.ts
+function looksLikeUuid(value) {
+	return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+/**
+* Strip environment-specific keys from a CMS media object.
+* @mutates Mutates the passed object in-place.
+*/
+function deleteEnvSpecificKeys(obj) {
+	delete obj.assetId;
+	delete obj.storageBucket;
+	delete obj.storagePath;
+	delete obj.src;
+	delete obj.mimeType;
+	delete obj.id;
+}
+//#endregion
+//#region ../media-core/src/richTextImageCollector.ts
+function walkAndCollectImageAttrs(value, out, location = "") {
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => walkAndCollectImageAttrs(item, out, `${location}[${index}]`));
+		return;
+	}
+	if (!isRecord$12(value)) return;
+	if (value.type === "image" && isRecord$12(value.attrs)) out.push({
+		attrs: value.attrs,
+		location: location ? `${location}.attrs` : "attrs"
+	});
+	for (const [key, child] of Object.entries(value)) walkAndCollectImageAttrs(child, out, location ? `${location}.${key}` : key);
+}
+//#endregion
 //#region ../theme-core/src/site-styles/rawStyleFields.ts
 const themeV2RuntimeStyleFieldNames = [
 	"_frameStyles",
@@ -15838,8 +16267,23 @@ const boxBackgroundSchema = z.discriminatedUnion("type", [
 		showVideoOnMobile: z.boolean().nullable().optional()
 	})
 ]);
+/** Application rendering sources are admitted separately from saved references. */
+const runtimeBoxBackgroundSchema = z.discriminatedUnion("type", [
+	boxBackgroundSchema.options[0],
+	boxBackgroundSchema.options[1],
+	boxBackgroundSchema.options[2].extend({ image: z.union([
+		imageMediaSchema,
+		externalMediaSchema.extend({ type: z.literal("image") }),
+		assetMediaSchema.extend({ type: z.literal("image") })
+	]).nullable().optional() }),
+	boxBackgroundSchema.options[3].extend({ image: z.union([
+		videoMediaSchema,
+		externalMediaSchema.extend({ type: z.literal("video") }),
+		assetMediaSchema.extend({ type: z.literal("video") })
+	]).nullable().optional() })
+]);
 function normalizeAuthoringOpacity(value) {
-	if (!isRecord$12(value)) return value;
+	if (!isRecord$11(value)) return value;
 	return {
 		...value,
 		opacity: normalizeOpacity(value.opacity)
@@ -15848,7 +16292,7 @@ function normalizeAuthoringOpacity(value) {
 function normalizeOpacity(value) {
 	return typeof value === "number" && value > 1 && value <= 100 ? value / 100 : value;
 }
-function isRecord$12(value) {
+function isRecord$11(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -30428,133 +30872,6 @@ const linkSchema = z.union([
 	entryLinkSchema$1
 ]);
 //#endregion
-//#region ../media-core/src/typeGuards.ts
-function isRecord$11(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-//#endregion
-//#region ../media-core/src/transformRect.ts
-function isValidTransformRectStructure(rect) {
-	if (!Array.isArray(rect) || rect.length !== 4) return false;
-	const [left, top, width, height] = rect;
-	return Number.isFinite(left) && Number.isFinite(top) && Number.isFinite(width) && Number.isFinite(height) && left >= 0 && top >= 0 && width > 0 && height > 0;
-}
-//#endregion
-//#region ../media-core/src/aspectTransforms.ts
-const DEFAULT_RECT_EPSILON = .5;
-function parseAspectRatioValue(value) {
-	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
-	if (typeof value !== "string") return void 0;
-	const normalized = value.trim();
-	if (!normalized) return void 0;
-	if (normalized === "auto") return void 0;
-	if (normalized.includes(":") || normalized.includes("/")) {
-		const delimiter = normalized.includes(":") ? ":" : "/";
-		const [wRaw, hRaw] = normalized.split(delimiter);
-		const width = Number(wRaw?.trim());
-		const height = Number(hRaw?.trim());
-		if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return;
-		return width / height;
-	}
-	const numeric = Number(normalized);
-	if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
-	return numeric;
-}
-const MAX_ASPECT_DISTANCE = .25;
-function resolveMediaTransformForAspect(transform, targetAspect) {
-	if (!transform) return {};
-	const base = {
-		rect: transform.rect,
-		hotspot: transform.hotspot,
-		rotation: transform.rotation
-	};
-	const target = parseAspectRatioValue(targetAspect);
-	const crops = transform.aspectCrops;
-	if (!target || !crops || Object.keys(crops).length === 0) return base;
-	let best = null;
-	let bestDistance = Number.POSITIVE_INFINITY;
-	for (const [key, candidate] of Object.entries(crops)) {
-		const candidateAspect = parseAspectRatioValue(candidate.aspect ?? key);
-		if (!candidateAspect) continue;
-		const distance = Math.abs(Math.log(candidateAspect / target));
-		if (distance < bestDistance) {
-			best = candidate;
-			bestDistance = distance;
-		}
-	}
-	if (!best) return base;
-	if (bestDistance > MAX_ASPECT_DISTANCE) return base;
-	return {
-		rect: best.rect ?? base.rect,
-		hotspot: best.hotspot ?? base.hotspot,
-		rotation: best.rotation ?? base.rotation
-	};
-}
-function isValidTransformRect(rect) {
-	return isValidTransformRectStructure(rect);
-}
-function isExplicitRectCrop(rect, sourceWidth, sourceHeight, epsilon = DEFAULT_RECT_EPSILON) {
-	if (!isValidTransformRect(rect)) return false;
-	if (!(typeof sourceWidth === "number" && Number.isFinite(sourceWidth) && sourceWidth > 0 && typeof sourceHeight === "number" && Number.isFinite(sourceHeight) && sourceHeight > 0)) return true;
-	const [x, y, width, height] = rect;
-	return !(Math.abs(x) <= epsilon && Math.abs(y) <= epsilon && Math.abs(width - sourceWidth) <= epsilon && Math.abs(height - sourceHeight) <= epsilon);
-}
-//#endregion
-//#region ../media-core/src/rotation.ts
-function rotateNormalizedPoint(point, rotation) {
-	const x = point.x;
-	const y = point.y;
-	switch (rotation) {
-		case 0: return {
-			x,
-			y
-		};
-		case 90: return {
-			x: 1 - y,
-			y: x
-		};
-		case 180: return {
-			x: 1 - x,
-			y: 1 - y
-		};
-		case 270: return {
-			x: y,
-			y: 1 - x
-		};
-	}
-}
-//#endregion
-//#region ../media-core/src/mediaRefNormalizer.ts
-function looksLikeUuid(value) {
-	return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-/**
-* Strip environment-specific keys from a CMS media object.
-* @mutates Mutates the passed object in-place.
-*/
-function deleteEnvSpecificKeys(obj) {
-	delete obj.assetId;
-	delete obj.storageBucket;
-	delete obj.storagePath;
-	delete obj.src;
-	delete obj.mimeType;
-	if (looksLikeUuid(obj.id)) delete obj.id;
-}
-//#endregion
-//#region ../media-core/src/richTextImageCollector.ts
-function walkAndCollectImageAttrs(value, out, location = "") {
-	if (Array.isArray(value)) {
-		value.forEach((item, index) => walkAndCollectImageAttrs(item, out, `${location}[${index}]`));
-		return;
-	}
-	if (!isRecord$11(value)) return;
-	if (value.type === "image" && isRecord$11(value.attrs)) out.push({
-		attrs: value.attrs,
-		location: location ? `${location}.attrs` : "attrs"
-	});
-	for (const [key, child] of Object.entries(value)) walkAndCollectImageAttrs(child, out, location ? `${location}.${key}` : key);
-}
-//#endregion
 //#region ../blocks/src/system/node/schema.ts
 const transformStepSchema = z.object({
 	id: z.string().min(1, "Transform requires an identifier"),
@@ -32252,7 +32569,8 @@ function validationContext(options = {}) {
 	const isDraft = options.mode === "draft";
 	return {
 		allowNull: options.allowNull ?? true,
-		allowIncomplete: isDraft || (options.allowIncomplete ?? false)
+		allowIncomplete: isDraft || (options.allowIncomplete ?? false),
+		mode: options.mode ?? "strict"
 	};
 }
 function strictValidationContext(options = {}) {
@@ -32626,7 +32944,7 @@ function validateNormalizedFieldValue(plan, value, ctx) {
 		case "select": return validateSelectPlan(plan, value);
 		case "richText": return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
 		case "inlineText": return validateInlineTextPlan(plan, value);
-		case "media": return isPlainObject$2(value) && mediaIdentifierSchema.safeParse(value.identifier).success && (value.type === void 0 || typeof value.type === "string" && plan.allowedMediaTypes.includes(value.type)) ? [] : [issue(plan, "invalidMedia")];
+		case "media": return validateMediaPlan(plan, value, ctx);
 		case "link": return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
 		case "repeater": return validateRepeaterPlan(plan, value, ctx);
 		case "group": return validateGroupPlan(plan, value, ctx);
@@ -32634,6 +32952,15 @@ function validateNormalizedFieldValue(plan, value, ctx) {
 		default: return assertNever$4(plan);
 	}
 }
+function validateMediaPlan(plan, value, ctx) {
+	if (!isPlainObject$2(value)) return [issue(plan, "invalidMedia")];
+	const allowedKind = value.type === void 0 || typeof value.type === "string" && plan.allowedMediaTypes.includes(value.type);
+	const admitted = ctx.mode === "render" ? runtimeMediaSchema.safeParse({
+		...value,
+		type: value.type ?? plan.allowedMediaTypes[0]
+	}).success : mediaIdentifierSchema.safeParse(value.identifier).success;
+	return allowedKind && admitted ? [] : [issue(plan, "invalidMedia")];
+}
 function shouldRequireValue(plan, value, ctx) {
 	if (!plan.required || ctx.allowIncomplete) return false;
 	if (value === null && ctx.allowNull) return false;
@@ -32758,7 +33085,7 @@ function validateGroupPlan(plan, value, ctx) {
 	const childCtx = childValidationContext(plan, ctx);
 	const childIssues = selectedGroupChildPlans(plan, value).flatMap((childPlan) => validateNormalizedFieldValue(childPlan, value[childPlan.fieldId], childCtx));
 	if (childIssues.length > 0) return childIssues;
-	if (plan.valueContract === "boxBackground" && !boxBackgroundSchema.safeParse(value).success) return [issue(plan, "invalidBoxBackground")];
+	if (plan.valueContract === "boxBackground" && !(ctx.mode === "render" ? runtimeBoxBackgroundSchema : boxBackgroundSchema).safeParse(value).success) return [issue(plan, "invalidBoxBackground")];
 	return [];
 }
 function childValidationContext(plan, ctx) {
@@ -32858,11 +33185,16 @@ function fieldPlanToObjectPropertyZod(plan, options = {}) {
 		default: return assertNever$4(presence);
 	}
 }
-/** Validate stored field values without applying editor/write normalization. */
-function fieldPlanToStoredObjectPropertyZod(plan) {
-	const ctx = strictValidationContext({ allowNull: false });
+/** Validate stored or runtime fields without applying editor/write normalization. */
+function fieldPlanToStrictObjectPropertyZod(plan, mode = "strict") {
+	const ctx = strictValidationContext({
+		allowNull: false,
+		mode
+	});
 	const schema = z.any().superRefine((value, zodCtx) => {
-		for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
+		validateNormalizedFieldValue(plan, value, ctx).forEach((validationIssue) => {
+			addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
+		});
 	});
 	return plan.required ? schema : schema.optional();
 }
@@ -33065,7 +33397,7 @@ function preprocessEmptyValues(content) {
 function compileManifestContentContract(manifestOrFields) {
 	const plans = derivePlansFromManifestOrFields(manifestOrFields);
 	const strictOptions = { allowNull: false };
-	const strictStoredSchema = deriveStrictStoredZodFromPlans(plans);
+	const strictStoredSchema = deriveStrictContentZodFromPlans(plans);
 	return Object.freeze({ [compiledManifestContentContract]: Object.freeze({
 		plans,
 		strictStoredSchema,
@@ -33075,7 +33407,7 @@ function compileManifestContentContract(manifestOrFields) {
 			allowIncomplete: true,
 			mode: "draft"
 		}, normalizeStoredContentValues),
-		renderSchema: strictStoredSchema,
+		renderSchema: deriveStrictContentZodFromPlans(plans, "render"),
 		findNonPortableMediaPaths: (content) => findNonPortableMediaPaths(plans, content)
 	}) });
 }
@@ -33105,9 +33437,8 @@ function deriveContentZodFromPlans(plans, options) {
 	for (const plan of plans) shape[plan.fieldId] = fieldPlanToObjectPropertyZod(plan, options);
 	return z.object(shape).catchall(z.unknown()).passthrough();
 }
-function deriveStrictStoredZodFromPlans(plans) {
-	const shape = {};
-	for (const plan of plans) shape[plan.fieldId] = fieldPlanToStoredObjectPropertyZod(plan);
+function deriveStrictContentZodFromPlans(plans, mode = "strict") {
+	const shape = Object.fromEntries(plans.map((plan) => [plan.fieldId, fieldPlanToStrictObjectPropertyZod(plan, mode)]));
 	return z.object(shape).catchall(z.unknown()).passthrough();
 }
 function derivePlansFromManifestOrFields(manifestOrFields) {
@@ -33131,41 +33462,51 @@ function findNonPortableMediaPaths(plans, content) {
 	collectNonPortablePlannedMedia(plans, content, [], paths);
 	return [...paths].sort();
 }
-function collectNonPortablePlannedMedia(plans, content, parentPath, paths) {
+/** One descriptor walker covers references and stored portability, including inactive retained fields. */
+function visitPlannedMedia(plans, content, parentPath, visit) {
 	if (!isPlainRecord(content)) return;
-	for (const plan of plans) {
-		if (!(plan.fieldId in content)) continue;
+	plans.forEach((plan) => {
+		if (!(plan.fieldId in content)) return;
 		const value = content[plan.fieldId];
 		const path = [...parentPath, plan.fieldId];
 		switch (plan.kind) {
 			case "media":
-				if (isPlainRecord(value) && hasEnvironmentSpecificMediaField(value)) paths.add(formatFieldPath(path));
-				break;
+				visit(isPlainRecord(value) ? {
+					...value,
+					type: value.type ?? plan.allowedMediaTypes[0]
+				} : value, path, "media");
+				return;
 			case "richText":
-				collectNonPortableRichTextImages(value, path, paths);
-				break;
+				visit(value, path, "richText");
+				return;
 			case "group":
-				collectNonPortablePlannedMedia(selectedGroupChildPlans(plan, value), value, path, paths);
-				break;
+				visitPlannedMedia(allGroupChildPlans(plan), value, path, visit);
+				return;
 			case "repeater":
-				collectNonPortableRepeaterMedia(plan, value, path, paths);
-				break;
-			case "string":
-			case "number":
+				visitRepeatedMedia(plan, value, path, visit);
+				return;
 			case "boolean":
 			case "inlineText":
 			case "link":
+			case "number":
+			case "passthrough":
 			case "select":
-			case "passthrough": break;
+			case "string": return;
 		}
-	}
+	});
 }
-function collectNonPortableRepeaterMedia(plan, value, path, paths) {
+function visitRepeatedMedia(plan, value, path, visit) {
 	if (!Array.isArray(value)) return;
 	value.forEach((item, index) => {
 		if (!isPlainRecord(item)) return;
-		const childPlans = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
-		if (childPlans) collectNonPortablePlannedMedia(childPlans, item, [...path, index], paths);
+		const fields = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
+		if (fields) visitPlannedMedia(fields, item, [...path, index], visit);
+	});
+}
+function collectNonPortablePlannedMedia(plans, content, parentPath, paths) {
+	visitPlannedMedia(plans, content, parentPath, (value, path, kind) => {
+		if (kind === "richText") collectNonPortableRichTextImages(value, path, paths);
+		else if (isPlainRecord(value) && (hasEnvironmentSpecificMediaField(value) || hasNonPortablePoster(value))) paths.add(formatFieldPath(path));
 	});
 }
 function collectNonPortableRichTextImages(value, path, paths) {
@@ -33180,6 +33521,10 @@ function isPlainRecord(value) {
 function hasEnvironmentSpecificMediaField(value) {
 	return "assetId" in value || "storageBucket" in value || "storagePath" in value || "src" in value || "mimeType" in value || looksLikeUuid(value.id);
 }
+function hasNonPortablePoster(value) {
+	if (value.poster === void 0) return false;
+	return !mediaPosterSchema.safeParse(value.poster).success;
+}
 //#endregion
 //#region ../blocks/src/system/designCapabilities.ts
 function declareBlockDesignCapability(capability) {
@@ -35165,6 +35510,12 @@ function parseBackgroundOverlay(value) {
 	const result = boxBackgroundOverlaySchema.safeParse(value);
 	return result.success ? result.data : void 0;
 }
+/** Rendering accepts explicit application sources separately from stored references. */
+const runtimeBackgroundContentSchema = runtimeBoxBackgroundSchema;
+function parseRuntimeBackgroundContent(value) {
+	const result = runtimeBackgroundContentSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
 //#endregion
 //#region ../blocks/src/system/transforms/registry/_utils/themeColorResolution.ts
 function resolveBackgroundColorValue(value, context) {
@@ -40015,6 +40366,15 @@ const formBlockDefinition = {
 	runtime: formBlockRuntime
 };
 //#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/contact-newsletter.ts
 const contactNewsletterLayout = styledSection({
 	children: sectionContainer([el("div", { className: "contact-newsletter-grid" }, [el("div", { className: "contact-newsletter-column contact-newsletter-contact" }, [el("div", { className: "contact-newsletter-copy" }, [text({
@@ -40178,6 +40538,10 @@ const contactNewsletterBlockDefinition = {
 		],
 		icon: "MailPlus"
 	}),
+	contentNormalizer: {
+		fieldIds: ["targeting"],
+		normalize: normalizeMailingListBlockContent
+	},
 	dataSchemas: { form: formDataSchema.optional() },
 	dataLoaders: { form: {
 		endpoint: "getPublicFormById",
@@ -43866,6 +44230,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;
@@ -44106,6 +44478,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(),
@@ -44114,7 +44490,7 @@ const publicEventBaseSchema = z.object({
 	content: z.object({ body: RichTextDocSchema.nullable().optional() }).optional(),
 	presentation: z.object({
 		summary: z.string().nullable().optional(),
-		image: mediaSchema.nullable().optional()
+		image: runtimeMediaSchema.nullable().optional()
 	}).optional(),
 	slug: z.string(),
 	path: z.string().nullable(),
@@ -44516,67 +44892,266 @@ const occurrenceContextSchema = z.object({
 	overrides: z.record(z.string(), z.unknown()).nullable().optional()
 }).nullable();
 //#endregion
-//#region ../blocks/src/system/runtime/api/readAuthority.ts
-const browserReadAuthoritySchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("published") }).strict(), z.object({
-	kind: z.literal("preview"),
-	token: z.string().min(1)
-}).strict()]);
-const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
-	kind: z.literal("unsupported"),
-	reason: z.enum([
-		"unsupportedSubject",
-		"invalidEventSeriesId",
-		"invalidEventSeriesBookingScope",
-		"invalidEventOfferingId",
-		"invalidEventOfferingBookingScope",
-		"invalidEventOfferingCatalogue"
-	])
-});
-const eventRegistrationPageSurfaceSubjectSchema = z.unknown().transform((value, ctx) => {
-	const unsupported = unsupportedEventRegistrationPageSurfaceSubjectSchema.safeParse(value);
-	if (unsupported.success) return unsupported.data;
-	const parsed = parseEventPageSurfaceSubject(value);
-	if (parsed.ok) return parsed.value;
-	ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: `Invalid event page-surface subject (${parsed.error.kind})`
-	});
-	return z.NEVER;
-});
-function resolveEventRegistrationScope(context) {
-	const occurrenceSeriesId = context.occurrenceContext?.seriesId;
-	if (occurrenceSeriesId) return {
-		kind: "occurrenceSeries",
-		seriesId: occurrenceSeriesId
+//#region ../blocks/src/system/runtime/nodes/events/domain/capacity.ts
+/**
+* Compute remaining spots for an event from `availableSpots` with a fallback
+* to `capacity - registeredCount`. Returns `{ available: null, isFull: false }`
+* for uncapped events so call sites can render no capacity indicator at all.
+*
+* The single source of truth for capacity math across event cards, agenda
+* rows, and timetable cells — keep wording variations in the call sites.
+*/
+function getEventAvailability(event) {
+	if (event.capacity == null) return {
+		available: null,
+		isFull: false
 	};
-	if (context.subject?.kind === "eventSeries") return {
-		kind: "pageSurfaceSeries",
-		seriesId: context.subject.eventSeriesId
+	const available = event.availableSpots ?? event.capacity - event.registeredCount;
+	if (available <= 0) return {
+		available: 0,
+		isFull: true
 	};
-	if (context.subject?.kind === "eventOffering") return {
-		kind: "pageSurfaceOffering",
-		offeringId: context.subject.eventOfferingId,
-		seriesIds: context.subject.catalogueEventSeriesIds
+	return {
+		available,
+		isFull: false
 	};
-	if (context.subject?.kind === "unsupported") return {
-		kind: "unsupportedPageSurfaceSubject",
-		reason: context.subject.reason
+}
+/**
+* Pick the capacity row a booking decision should read: the selected
+* attendance mode's availability when the visitor has chosen one and the
+* event publishes it, otherwise the event-level aggregate.
+*
+* The mode row is used wholesale. A mode with `capacity: null` on a capped
+* event is uncapped *by design*: the registration write path applies the
+* same rule via `getEffectiveOccurrenceCapacityForAttendanceMode`, so falling
+* back to the event's `availableSpots` here would block bookings the server
+* accepts. (Waitlist claims are still occurrence-scoped; see issue 1377.)
+*/
+function selectEventCapacitySource(event, attendanceMode) {
+	if (!attendanceMode) return event;
+	return (event.attendanceModes ?? []).find((mode) => mode.mode === attendanceMode) ?? event;
+}
+/**
+* Whether the visitor's next step is the waitlist: the source is full *and*
+* a waitlist is open. The one place this is decided — cards, rows, the
+* wizard's steps and its action bar all route through here so they agree,
+* including for producers that omit `availableSpots` and rely on the
+* `capacity - registeredCount` fallback.
+*/
+function canJoinEventWaitlist(event, options) {
+	const source = selectEventCapacitySource(event, options?.attendanceMode);
+	return getEventAvailability(source).isFull && source.waitlistEnabled === true;
+}
+/**
+* Remaining places at or below which an event reads as scarce and the exact
+* count is worth showing. Above it, no number is shown at all: "147 places
+* left" is not something a visitor acts on, and it is the figure most likely
+* to be stale on a cached page.
+*
+*   max( min(3, ceil(capacity * 0.25)), ceil(capacity * 0.05) )
+*
+* The 25% arm stops small groups shouting early (3 of 4 is not urgency); the
+* 5% floor stops large events staying silent until three remain.
+* capacity 4 -> 1, 12 -> 3, 40 -> 3, 100 -> 5, 200 -> 10.
+*/
+function lowCapacityThreshold(capacity) {
+	return Math.max(Math.min(3, Math.ceil(capacity * .25)), Math.ceil(capacity * .05));
+}
+function getRemainingPlaces(source) {
+	const { available, isFull } = getEventAvailability(source);
+	if (available === null || source.capacity === null) return { kind: "unlimited" };
+	if (isFull) return {
+		kind: "full",
+		waitlist: canJoinEventWaitlist(source)
 	};
-	return { kind: "unscoped" };
+	if (available <= lowCapacityThreshold(source.capacity)) return {
+		kind: "low",
+		remaining: available
+	};
+	return { kind: "open" };
 }
-function resolveEventRegistrationScopedEvents(events, context) {
-	const scope = resolveEventRegistrationScope(context);
-	switch (scope.kind) {
-		case "occurrenceSeries":
-		case "pageSurfaceSeries": return events.filter((event) => event.seriesId === scope.seriesId);
-		case "pageSurfaceOffering": {
-			const seriesIds = new Set(scope.seriesIds);
-			return events.filter((event) => seriesIds.has(event.seriesId));
-		}
-		case "unsupportedPageSurfaceSubject": return [];
-		case "unscoped": return [...events];
+/**
+* The one place a remaining-places count becomes text. Returns `null` when
+* nothing should be shown: uncapped events, and capped events above the
+* scarcity threshold. Surfaces that need their own full-state wording pass
+* it in rather than re-deriving the count.
+*/
+function formatRemainingPlaces(source, wording = {}) {
+	const remaining = getRemainingPlaces(source);
+	switch (remaining.kind) {
+		case "unlimited":
+		case "open": return null;
+		case "low": return formatPlacesLeft(remaining.remaining, wording.compact === true);
+		case "full": return remaining.waitlist ? wording.waitlist ?? "Waitlist" : wording.full ?? "Full";
 	}
 }
+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`;
+}
+/**
+* Which capacity figure wins when they disagree.
+*
+* For a hybrid event that publishes both attendance-mode rows, **the mode
+* rows are authoritative and the event-level aggregate is only a summary**.
+* The registration write path admits or refuses per mode
+* (`getEffectiveOccurrenceCapacityForAttendanceMode` on the server), so the
+* aggregate can read full while a mode still has room, and can read open
+* while the mode the visitor wants is full. Believing the aggregate on a
+* card is how a "places available" event turns into a dead end at step two.
+*
+* Everything else — single-mode events, events that publish no rows, and the
+* aggregate-only helpers {@link getEventAvailability} /
+* {@link getRemainingPlaces} that existing callers rely on — keeps reading
+* the aggregate, unchanged.
+*/
+function findHybridModeRows(event) {
+	if (event.deliveryMode !== "hybrid") return null;
+	const rows = event.attendanceModes ?? [];
+	const inPerson = rows.find((row) => row.mode === "in_person");
+	const online = rows.find((row) => row.mode === "online");
+	return inPerson && online ? {
+		inPerson,
+		online
+	} : null;
+}
+/** Openness rank; higher means more room. A full mode with a waitlist beats one without. */
+function remainingPlacesRank(remaining) {
+	switch (remaining.kind) {
+		case "unlimited": return 4;
+		case "open": return 3;
+		case "low": return 2;
+		case "full": return remaining.waitlist ? 1 : 0;
+	}
+}
+function isMoreOpen(candidate, than) {
+	const rank = remainingPlacesRank(candidate);
+	const otherRank = remainingPlacesRank(than);
+	if (rank !== otherRank) return rank > otherRank;
+	return candidate.kind === "low" && than.kind === "low" ? candidate.remaining > than.remaining : false;
+}
+/** True when `candidate` has less room left than `than`. */
+function isScarcer(candidate, than) {
+	return isMoreOpen(than, candidate);
+}
+const ATTENDANCE_MODE_LABEL = {
+	in_person: "In person",
+	online: "Online"
+};
+/** Wording for a mode with room to spare, where the count is deliberately withheld. */
+const PLACES_AVAILABLE = "Places available";
+/**
+* The browse-surface label for an event's remaining places. Single-mode
+* events get exactly the aggregate label {@link formatRemainingPlaces}
+* produces, and so does a hybrid event whose two modes tell the same story.
+* When the modes differ, both sides are named: "available" on a card is a
+* promise the registration wizard would otherwise have to break.
+*
+* Hybrid examples, in person full with 3 online places left:
+*   default                -> "Online: 3 places left · In person: Full"
+*   { full: 'Sold out' }   -> "Online: 3 places left · In person: Sold out"
+*   { compact: true }      -> "Online: 3 left"
+*/
+function formatEventRemainingPlaces(event, wording = {}) {
+	const rows = findHybridModeRows(event);
+	if (!rows) return formatRemainingPlaces(event, wording);
+	const inPerson = formatRemainingPlaces(rows.inPerson, wording);
+	const online = formatRemainingPlaces(rows.online, wording);
+	if (inPerson === online) return inPerson;
+	if (wording.compact === true) return formatCompactHybridPlaces(rows, wording);
+	return formatBothHybridSides(rows, {
+		inPerson,
+		online
+	});
+}
+/**
+* Both sides, the one with room first: that is the half a visitor can act on,
+* and it should not arrive after a full stop's worth of bad news.
+*/
+function formatBothHybridSides(rows, labels) {
+	return (isMoreOpen(getRemainingPlaces(rows.online), getRemainingPlaces(rows.inPerson)) ? [["online", labels.online], ["in_person", labels.inPerson]] : [["in_person", labels.inPerson], ["online", labels.online]]).map(([mode, label]) => namedModePlaces(mode, label)).join(" · ");
+}
+function namedModePlaces(mode, label) {
+	return `${ATTENDANCE_MODE_LABEL[mode]}: ${label ?? PLACES_AVAILABLE}`;
+}
+/**
+* Pills and timetable cells have room for one short phrase, so they name the
+* single mode that carries news rather than listing both: the scarce side
+* when there is a count to show, and otherwise the side that has closed —
+* "In person: Full", never "Online only", which reads as a statement about
+* how the event is delivered rather than about its remaining places.
+*/
+function formatCompactHybridPlaces(rows, wording) {
+	const inPerson = getRemainingPlaces(rows.inPerson);
+	const online = getRemainingPlaces(rows.online);
+	if (inPerson.kind === "full" && online.kind === "full") return formatRemainingPlaces(inPerson.waitlist ? rows.inPerson : rows.online, wording);
+	if (inPerson.kind === "full" || online.kind === "full") {
+		const fullSide = inPerson.kind === "full" ? "in_person" : "online";
+		const openSide = inPerson.kind === "full" ? "online" : "in_person";
+		const openLabel = formatRemainingPlaces(rowFor(rows, openSide), wording);
+		return openLabel !== null ? namedModePlaces(openSide, openLabel) : namedModePlaces(fullSide, formatRemainingPlaces(rowFor(rows, fullSide), wording));
+	}
+	const scarcerSide = isScarcer(online, inPerson) ? "online" : "in_person";
+	return namedModePlaces(scarcerSide, formatRemainingPlaces(rowFor(rows, scarcerSide), wording));
+}
+function rowFor(rows, mode) {
+	return mode === "online" ? rows.online : rows.inPerson;
+}
+//#endregion
+//#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$6(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/api/readAuthority.ts
+const browserReadAuthoritySchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("published") }).strict(), z.object({
+	kind: z.literal("preview"),
+	token: z.string().min(1)
+}).strict()]);
 //#endregion
 //#region ../calendar/src/grid.ts
 const MONTH_NAMES = [
@@ -44664,6 +45239,11 @@ function buildCalendarViewport(input) {
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/domain/dates.ts
 /**
+* Date and time presentation for events: the single place an event's
+* timestamps become strings or date buckets. Calendar-grid primitives are
+* re-exported from @riverbankcms/calendar so block code has one import.
+*/
+/**
 * The English locale a site's public dates are written in, read from the
 * site's own time zone (Will, 2026-09-26: "date style from site time zone").
 *
@@ -44683,6 +45263,28 @@ function eventDateLocale(siteTimeZone) {
 	if (siteTimeZone === "Pacific/Auckland" || siteTimeZone === "Pacific/Chatham") return "en-NZ";
 	return "en-US";
 }
+function formatEventCompactDateRail(isoTimestamp, options, letterCase = "capitals") {
+	const locale = options?.locale ?? "en-US";
+	const dateTime = toScheduledBookingDateTime({
+		startsAt: isoTimestamp,
+		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
+		locale
+	});
+	const cased = (value) => letterCase === "capitals" ? value.toLocaleUpperCase(locale) : value;
+	const weekday = cased(formatBookingDate(dateTime, { weekday: "short" }));
+	const month = cased(formatBookingDate(dateTime, { month: "short" }).slice(0, 3));
+	return {
+		weekday,
+		day: formatBookingDate(dateTime, { day: "numeric" }),
+		month,
+		label: formatBookingDate(dateTime, {
+			weekday: "long",
+			year: "numeric",
+			month: "long",
+			day: "numeric"
+		})
+	};
+}
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/domain/destination.ts
 function isRecord$8(value) {
@@ -44702,6 +45304,15 @@ function resolveRuntimeEventDestination(event) {
 	};
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/events/domain/pricing.ts
+/**
+* Format an event's price directly from its pricing value (without the full
+* event). Same output as {@link formatEventPrice}.
+*/
+function formatEventPriceDisplay(pricing) {
+	return formatEventPricing(pricing, { decimals: "auto" });
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/events/domain/listWeek.ts
 /** Civil weeks use the site zone, including weeks containing a clock change. */
 function buildEventListWeek(anchor, startOfWeek, timeZone) {
@@ -44736,6 +45347,642 @@ function eventListWindowEvents(events, window) {
 	});
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
+function eventMatchesOccurrenceId(event, occurrenceId) {
+	return event.registrationSubject.kind === "occurrence" && (event.registrationSubject.occurrenceId === occurrenceId || event.selectionId === occurrenceId);
+}
+function findPreSelectedEvent(input) {
+	const occurrenceContext = input.occurrenceContext;
+	if (!occurrenceContext) return input.scopedEvents.length === 1 ? input.scopedEvents[0] ?? null : null;
+	const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
+		startsAt: occurrenceContext.startsAt,
+		timeZone: occurrenceContext.timeZone
+	}));
+	return input.scopedEvents.find((event) => eventMatchesOccurrenceId(event, occurrenceContext.id) || getBookingLocalDateKey(toScheduledBookingDateTime({
+		startsAt: event.startsAt,
+		timeZone: event.timeZone
+	})) === contextDate) ?? null;
+}
+function resolveEventRequiresPayment(input) {
+	if (input.eligibility) return input.eligibility.requiresPayment;
+	if (input.selectedTicketType) return input.selectedTicketType.priceAmount > 0;
+	if (!input.event) return false;
+	return publicEventPricingType(input.event.pricing) === "paid";
+}
+//#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/blocks/offerings-preview/model.ts
+const OFFERINGS_PREVIEW_DEFAULT_BUTTON_TEXT = "Book";
+const OFFERINGS_PREVIEW_DEFAULT_EMPTY_MESSAGE = "Nothing scheduled just yet.";
+const OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS = [
+	{
+		preset: "class",
+		sourceKey: "eventPreset:class",
+		dataKey: "classEvents",
+		label: "Classes"
+	},
+	{
+		preset: "workshop",
+		sourceKey: "eventPreset:workshop",
+		dataKey: "workshopEvents",
+		label: "Workshops"
+	},
+	{
+		preset: "retreat",
+		sourceKey: "eventPreset:retreat",
+		dataKey: "retreatEvents",
+		label: "Retreats"
+	},
+	{
+		preset: "performance",
+		sourceKey: "eventPreset:performance",
+		dataKey: "performanceEvents",
+		label: "Performances"
+	}
+];
+const OFFERINGS_PREVIEW_EVENT_PRESETS = OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => definition.preset);
+const OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS = [...OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => definition.sourceKey), "course"];
+const OFFERINGS_PREVIEW_SOURCE_KEYS = OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS;
+Object.fromEntries(OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => [definition.sourceKey, {
+	kind: "eventPreset",
+	preset: definition.preset
+}]));
+function isOfferingsPreviewSourceKey(value) {
+	return typeof value === "string" && OFFERINGS_PREVIEW_SOURCE_KEYS.includes(value);
+}
+function normalizeOfferingsPreviewGroupOrder(value) {
+	if (value == null) return { kind: "legacy" };
+	if (value.length === 0) return { kind: "default" };
+	const keys = uniqueOfferingsPreviewSourceKeys(value);
+	return keys.length > 0 ? {
+		kind: "custom",
+		keys
+	} : { kind: "default" };
+}
+function inferLegacyOfferingsPreviewGroupOrder(overrides) {
+	const keys = uniqueOfferingsPreviewSourceKeys((overrides ?? []).map((override) => override.sourceKey));
+	return keys.length >= 2 ? keys : [];
+}
+function normalizeOfferingsPreviewContentForWrite(value) {
+	if (!isRecord$7(value)) return null;
+	const groupOrderValue = value.groupOrder;
+	if (Array.isArray(groupOrderValue)) {
+		const normalized = normalizeOfferingsPreviewGroupOrder(groupOrderValue);
+		return {
+			...value,
+			groupOrder: normalized.kind === "custom" ? normalized.keys : []
+		};
+	}
+	if (groupOrderValue != null) return {
+		...value,
+		groupOrder: []
+	};
+	const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord$7) : []);
+	return legacyOrder.length > 0 ? {
+		...value,
+		groupOrder: legacyOrder
+	} : value;
+}
+/** 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;
+	if (isOfferingsPreviewEventPreset(preset.canonicalBehaviour)) return {
+		kind: "eventPreset",
+		preset: preset.canonicalBehaviour
+	};
+	return null;
+}
+function uniqueOfferingsPreviewSourceKeys(values) {
+	const keys = [];
+	for (const value of values) {
+		if (!isOfferingsPreviewSourceKey(value)) continue;
+		if (!keys.includes(value)) keys.push(value);
+	}
+	return keys;
+}
+function isRecord$7(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOfferingsPreviewEventPreset(value) {
+	return typeof value === "string" && OFFERINGS_PREVIEW_EVENT_PRESETS.includes(value);
+}
+//#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 {
+		...event,
+		selectionId: event.id,
+		registrationSubject: {
+			kind: "occurrence",
+			occurrenceId: event.occurrenceId
+		}
+	};
+}
+function toRegistrationEvents(events) {
+	return events.filter((event) => event.bookingScope === "single_occurrence").map(toRegistrationEvent);
+}
+/**
+* Project one whole-series run onto the registration surface.
+*
+* Capacity, pricing, payment terms and consent come straight off the canonical
+* Event record; only the schedule is widened from the single occurrence to the
+* live run. A run without live sessions has no registration event.
+*/
+function toWholeSeriesRegistrationEvent(group) {
+	const { representative, run } = group;
+	const sessions = orderedLiveRunSessions(run.sessions);
+	const firstSession = sessions[0];
+	if (!firstSession) return null;
+	const lastSession = sessions[sessions.length - 1] ?? firstSession;
+	return {
+		...representative,
+		selectionId: run.eventSeriesId,
+		registrationSubject: {
+			kind: "wholeSeries",
+			eventSeriesId: run.eventSeriesId,
+			sessions
+		},
+		startsAt: firstSession.startsAt,
+		endsAt: lastSession.endsAt,
+		timeZone: firstSession.timeZone
+	};
+}
+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() ?? ""
+	};
+}
+const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
+	kind: z.literal("unsupported"),
+	reason: z.enum([
+		"unsupportedSubject",
+		"invalidEventSeriesId",
+		"invalidEventSeriesBookingScope",
+		"invalidEventOfferingId",
+		"invalidEventOfferingBookingScope",
+		"invalidEventOfferingCatalogue"
+	])
+});
+const eventRegistrationPageSurfaceSubjectSchema = z.unknown().transform((value, ctx) => {
+	const unsupported = unsupportedEventRegistrationPageSurfaceSubjectSchema.safeParse(value);
+	if (unsupported.success) return unsupported.data;
+	const parsed = parseEventPageSurfaceSubject(value);
+	if (parsed.ok) return parsed.value;
+	ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `Invalid event page-surface subject (${parsed.error.kind})`
+	});
+	return z.NEVER;
+});
+function resolveEventRegistrationScope(context) {
+	const occurrenceSeriesId = context.occurrenceContext?.seriesId;
+	if (occurrenceSeriesId) return {
+		kind: "occurrenceSeries",
+		seriesId: occurrenceSeriesId
+	};
+	if (context.subject?.kind === "eventSeries") return {
+		kind: "pageSurfaceSeries",
+		seriesId: context.subject.eventSeriesId
+	};
+	if (context.subject?.kind === "eventOffering") return {
+		kind: "pageSurfaceOffering",
+		offeringId: context.subject.eventOfferingId,
+		seriesIds: context.subject.catalogueEventSeriesIds
+	};
+	if (context.subject?.kind === "unsupported") return {
+		kind: "unsupportedPageSurfaceSubject",
+		reason: context.subject.reason
+	};
+	return { kind: "unscoped" };
+}
+function resolveEventRegistrationScopedEvents(events, context) {
+	const scope = resolveEventRegistrationScope(context);
+	switch (scope.kind) {
+		case "occurrenceSeries":
+		case "pageSurfaceSeries": return events.filter((event) => event.seriesId === scope.seriesId);
+		case "pageSurfaceOffering": {
+			const seriesIds = new Set(scope.seriesIds);
+			return events.filter((event) => seriesIds.has(event.seriesId));
+		}
+		case "unsupportedPageSurfaceSubject": return [];
+		case "unscoped": return [...events];
+	}
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
 const previewStageSchema = z.enum(["preview", "published"]);
 const registrationButtonVariantSchema = blockButtonRoleSchema;
@@ -44760,95 +46007,6 @@ const calendarTabViewsSchema = z.enum([
 	"week"
 ]);
 //#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"];
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
-function eventMatchesOccurrenceId(event, occurrenceId) {
-	return event.registrationSubject.kind === "occurrence" && (event.registrationSubject.occurrenceId === occurrenceId || event.selectionId === occurrenceId);
-}
-function findPreSelectedEvent(input) {
-	const occurrenceContext = input.occurrenceContext;
-	if (!occurrenceContext) return input.scopedEvents.length === 1 ? input.scopedEvents[0] ?? null : null;
-	const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
-		startsAt: occurrenceContext.startsAt,
-		timeZone: occurrenceContext.timeZone
-	}));
-	return input.scopedEvents.find((event) => eventMatchesOccurrenceId(event, occurrenceContext.id) || getBookingLocalDateKey(toScheduledBookingDateTime({
-		startsAt: event.startsAt,
-		timeZone: event.timeZone
-	})) === contextDate) ?? null;
-}
-function resolveEventRequiresPayment(input) {
-	if (input.eligibility) return input.eligibility.requiresPayment;
-	if (input.selectedTicketType) return input.selectedTicketType.priceAmount > 0;
-	if (!input.event) return false;
-	return publicEventPricingType(input.event.pricing) === "paid";
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
-function toRegistrationEvent(event) {
-	return {
-		...event,
-		selectionId: event.id,
-		registrationSubject: {
-			kind: "occurrence",
-			occurrenceId: event.occurrenceId
-		}
-	};
-}
-function toRegistrationEvents(events) {
-	return events.filter((event) => event.bookingScope === "single_occurrence").map(toRegistrationEvent);
-}
-/**
-* Project one whole-series run onto the registration surface.
-*
-* Capacity, pricing, payment terms and consent come straight off the canonical
-* Event record; only the schedule is widened from the single occurrence to the
-* live run. A run without live sessions has no registration event.
-*/
-function toWholeSeriesRegistrationEvent(group) {
-	const { representative, run } = group;
-	const sessions = orderedLiveRunSessions(run.sessions);
-	const firstSession = sessions[0];
-	if (!firstSession) return null;
-	const lastSession = sessions[sessions.length - 1] ?? firstSession;
-	return {
-		...representative,
-		selectionId: run.eventSeriesId,
-		registrationSubject: {
-			kind: "wholeSeries",
-			eventSeriesId: run.eventSeriesId,
-			sessions
-		},
-		startsAt: firstSession.startsAt,
-		endsAt: lastSession.endsAt,
-		timeZone: firstSession.timeZone
-	};
-}
-function toWholeSeriesRegistrationEvents(events) {
-	return groupPublicEventsByRun(events).map(toWholeSeriesRegistrationEvent).filter((event) => event !== null);
-}
-//#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({
@@ -44891,27 +46049,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(),
@@ -44936,32 +46084,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({
@@ -44976,7 +46143,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",
@@ -44985,6 +46152,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",
@@ -45001,11 +46170,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;
@@ -45014,14 +46186,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 : [], {
@@ -45037,29 +46210,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({
@@ -45069,6 +46225,7 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 		render: createZodCodec(eventRegistrationRenderSchema)
 	},
 	buildRender: (source) => {
+		const display = resolveRegistrationDisplay(source);
 		const eventSource = resolveEventRegistrationEventSource({
 			events: source.events,
 			wholeSeriesRunEvents: source.wholeSeriesRunEvents,
@@ -45076,7 +46233,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,
@@ -45086,29 +46243,29 @@ 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)
 			}
 		};
 	}
 });
 function normalizeEventRegistrationEventInput(value) {
-	if (!isRecord$7(value)) return value;
+	if (!isRecord$6(value)) return value;
 	return {
 		...value,
 		destination: resolveRuntimeEventDestination(value)
 	};
 }
-function isRecord$7(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const eventRegistrationBlockDefinition = {
@@ -45148,7 +46305,7 @@ const eventRegistrationBlockDefinition = {
 				description: "Main heading for the registration form",
 				required: false,
 				multiline: false,
-				defaultValue: "Register for this event"
+				defaultValue: ""
 			},
 			{
 				id: "description",
@@ -45220,11 +46377,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()
@@ -45256,21 +46413,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: {
@@ -47931,7 +49088,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()
@@ -48404,90 +49575,6 @@ const recurringScheduleBlockDefinition = {
 	} }
 };
 //#endregion
-//#region ../blocks/src/system/blocks/offerings-preview/model.ts
-const OFFERINGS_PREVIEW_DEFAULT_BUTTON_TEXT = "Book";
-const OFFERINGS_PREVIEW_DEFAULT_EMPTY_MESSAGE = "Nothing scheduled just yet.";
-const OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS = [
-	{
-		preset: "class",
-		sourceKey: "eventPreset:class",
-		dataKey: "classEvents",
-		label: "Classes"
-	},
-	{
-		preset: "workshop",
-		sourceKey: "eventPreset:workshop",
-		dataKey: "workshopEvents",
-		label: "Workshops"
-	},
-	{
-		preset: "retreat",
-		sourceKey: "eventPreset:retreat",
-		dataKey: "retreatEvents",
-		label: "Retreats"
-	},
-	{
-		preset: "performance",
-		sourceKey: "eventPreset:performance",
-		dataKey: "performanceEvents",
-		label: "Performances"
-	}
-];
-OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => definition.preset);
-const OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS = [...OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => definition.sourceKey), "course"];
-const OFFERINGS_PREVIEW_SOURCE_KEYS = OFFERINGS_PREVIEW_AUTHORABLE_SOURCE_KEYS;
-Object.fromEntries(OFFERINGS_PREVIEW_EVENT_PRESET_DEFINITIONS.map((definition) => [definition.sourceKey, {
-	kind: "eventPreset",
-	preset: definition.preset
-}]));
-function isOfferingsPreviewSourceKey(value) {
-	return typeof value === "string" && OFFERINGS_PREVIEW_SOURCE_KEYS.includes(value);
-}
-function normalizeOfferingsPreviewGroupOrder(value) {
-	if (value == null) return { kind: "legacy" };
-	if (value.length === 0) return { kind: "default" };
-	const keys = uniqueOfferingsPreviewSourceKeys(value);
-	return keys.length > 0 ? {
-		kind: "custom",
-		keys
-	} : { kind: "default" };
-}
-function inferLegacyOfferingsPreviewGroupOrder(overrides) {
-	const keys = uniqueOfferingsPreviewSourceKeys((overrides ?? []).map((override) => override.sourceKey));
-	return keys.length >= 2 ? keys : [];
-}
-function normalizeOfferingsPreviewContentForWrite(value) {
-	if (!isRecord$6(value)) return null;
-	const groupOrderValue = value.groupOrder;
-	if (Array.isArray(groupOrderValue)) {
-		const normalized = normalizeOfferingsPreviewGroupOrder(groupOrderValue);
-		return {
-			...value,
-			groupOrder: normalized.kind === "custom" ? normalized.keys : []
-		};
-	}
-	if (groupOrderValue != null) return {
-		...value,
-		groupOrder: []
-	};
-	const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord$6) : []);
-	return legacyOrder.length > 0 ? {
-		...value,
-		groupOrder: legacyOrder
-	} : value;
-}
-function uniqueOfferingsPreviewSourceKeys(values) {
-	const keys = [];
-	for (const value of values) {
-		if (!isOfferingsPreviewSourceKey(value)) continue;
-		if (!keys.includes(value)) keys.push(value);
-	}
-	return keys;
-}
-function isRecord$6(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region ../blocks/src/system/blocks/offerings-preview/fields.ts
 const groupOverrideFields = [
 	{
@@ -48851,7 +49938,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(),
@@ -52449,11 +53551,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,
@@ -52510,60 +53612,12 @@ function projectNewsletterFormHydrationTarget(source) {
 		default: return assertNever$6(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 parseRequiredMailingListSignupBlockId(value) {
 	const parsed = parseMailingListBlockId(value);
@@ -52672,6 +53726,10 @@ function sanitizeNewsletterSignupPublicContent(content) {
 }
 const newsletterSignupBlockDefinition = {
 	manifest: newsletterSignupManifest,
+	contentNormalizer: {
+		fieldIds: ["targeting"],
+		normalize: normalizeMailingListBlockContent
+	},
 	runtime: newsletterFormBlockRuntime
 };
 //#endregion
@@ -52699,7 +53757,7 @@ const memberPhotoClassName = (baseClass) => cardRoleChildClass({
 	baseClass,
 	stylesFrom: "content._cardStyles"
 });
-const teamMemberPhotoSchema = mediaSchema.refine((media) => media.type === "image", { message: "Team member photos must be image media" }).nullable();
+const teamMemberPhotoSchema = runtimeMediaSchema.refine((media) => media.type === "image", { message: "Team member photos must be image media" }).nullable();
 const teamMemberDataSchema = z.object({
 	_type: z.literal("teamMember"),
 	id: z.string(),
@@ -53404,7 +54462,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
@@ -54228,11 +55299,14 @@ const offeringsPreviewDatesReadEnabled = {
 //#endregion
 //#region ../blocks/src/system/helpers/backgroundMedia.ts
 function resolveBackgroundMedia(input) {
-	const parsedMedia = mediaSchema.safeParse(input.image);
+	const parsedMedia = runtimeMediaSchema.safeParse(input.image);
 	if (!parsedMedia.success) return null;
 	switch (parsedMedia.data.type) {
 		case "image":
-		case "video": return parsedMedia.data;
+		case "video": return {
+			...parsedMedia.data,
+			type: parsedMedia.data.type
+		};
 		case "audio":
 		case "document":
 		case "spreadsheet":
@@ -54244,6 +55318,75 @@ function backgroundVideoMobileClassNames(input) {
 	return input.showVideoOnMobile === true ? "" : "rb-hidden rb-md-block";
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/mediaContext.ts
+/**
+* Server-side: AsyncLocalStorage for request isolation.
+* Prevents race conditions when multiple requests are processed concurrently.
+*
+* Lazy initialization to avoid issues in environments that don't support async_hooks.
+*/
+const serverStorageState = {
+	storage: null,
+	checked: false
+};
+function getServerStorage() {
+	if (typeof window !== "undefined") return null;
+	if (serverStorageState.checked) return serverStorageState.storage;
+	serverStorageState.checked = true;
+	try {
+		const globalWithNonWebpackRequire = globalThis;
+		const AsyncLocalStorage = (typeof globalWithNonWebpackRequire.__non_webpack_require__ === "function" ? globalWithNonWebpackRequire.__non_webpack_require__ : new Function("id", "return require(id)"))("async_hooks").AsyncLocalStorage;
+		if (AsyncLocalStorage) {
+			serverStorageState.storage = new AsyncLocalStorage();
+			return serverStorageState.storage;
+		}
+		return null;
+	} catch {
+		if (process.env.NODE_ENV !== "production") console.warn("[blocks] AsyncLocalStorage not available - using module-level state");
+		return null;
+	}
+}
+/**
+* Client-side context storage.
+* Safe because browsers are single-threaded per tab.
+*
+* IMPORTANT: This must be shared across bundles.
+* SDK preview mode can load multiple independently-bundled entrypoints
+* (e.g. `@riverbankcms/sdk/rendering` + `@riverbankcms/sdk/preview-next/client`),
+* which can otherwise each get their own module-scoped singleton.
+*/
+const RB_MEDIA_CONTEXT_KEY = Symbol.for("riverbankcms.blocks.mediaContext");
+function getClientContextStore() {
+	const g = globalThis;
+	const existing = g[RB_MEDIA_CONTEXT_KEY];
+	if (existing && typeof existing === "object") return existing;
+	const next = {};
+	g[RB_MEDIA_CONTEXT_KEY] = next;
+	return next;
+}
+/**
+* Get the current media context.
+* Server-side: Uses AsyncLocalStorage for request isolation.
+* Client-side: Uses module-level state (safe in single-threaded browser).
+*/
+function getMediaContext() {
+	const storage = getServerStorage();
+	if (storage) return storage.getStore() ?? {};
+	return getClientContextStore();
+}
+function getCurrentResolveImageUrlContext() {
+	const context = getMediaContext();
+	if (!context.supabaseUrl && !context.siteId && !context.mediaAssetIndex) return;
+	return {
+		supabaseUrl: context.supabaseUrl,
+		siteId: context.siteId,
+		mediaAssetIndex: context.mediaAssetIndex
+	};
+}
+function getMediaAssetIndex(context) {
+	return context?.mediaAssetIndex ?? getMediaContext().mediaAssetIndex;
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/media.tsx
 function getValidSourceDimension(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
@@ -54279,41 +55422,72 @@ function applyRectTransform(existingStyle, patch) {
 	if (patch.transform) next.transform = appendTransform(existingStyle?.transform, patch.transform);
 	return next;
 }
-function computeMediaTransformStyle(value, style, targetAspectRatio, options) {
+/** Resolve portable content without exposing runtime metadata as saved values. */
+function resolveMediaWithContext(reference, context) {
+	return resolveManagedMediaReference(reference, getMediaAssetIndex(context ?? void 0));
+}
+function sourceFromAsset(value, asset) {
+	return {
+		type: value.type,
+		alt: value.alt,
+		filename: value.filename,
+		purpose: value.purpose,
+		placeholder: value.placeholder,
+		transform: value.transform,
+		poster: value.poster,
+		identifier: asset.identifier,
+		assetId: asset.id,
+		storageBucket: asset.storageBucket,
+		storagePath: asset.storagePath,
+		mimeType: asset.mimeType,
+		width: asset.width,
+		height: asset.height
+	};
+}
+function resolveRuntimeMedia(value, context) {
+	if ("asset" in value && value.asset) return sourceFromAsset(value, value.asset);
+	if ("src" in value && value.src) return value;
+	if (!value.identifier) return void 0;
+	const resolved = resolveMediaWithContext(value, context);
+	return resolved.kind === "resolved" ? sourceFromAsset(resolved.reference, resolved.asset) : void 0;
+}
+function usesProxyFraming(source, transform) {
+	if (!source?.assetId || !isExplicitCropProxyEnabled()) return false;
+	return Boolean(transform.rotation) || isExplicitRectCrop(transform.rect, getValidSourceDimension(source.width), getValidSourceDimension(source.height));
+}
+function rectFramingPatch(source, rect, proxy, style) {
+	if (!source || !rect || proxy) return {};
+	const patch = buildCssRectStylePatch(source, rect);
+	return patch ? applyRectTransform(style, patch) : {};
+}
+function hotspotFramingPatch(transform, proxy, rectPatch, style) {
+	if (!transform.hotspot || rectPatch.objectPosition !== void 0) return {};
+	const fit = style?.objectFit;
+	if (fit && fit !== "cover" && fit !== "contain") return {};
+	const point = proxy && transform.rotation ? rotateNormalizedPoint(transform.hotspot, transform.rotation) : transform.hotspot;
+	return { objectPosition: `${point.x * 100}% ${point.y * 100}%` };
+}
+function rotationFramingPatch(rotation, proxy, rectPatch, style) {
+	if (!rotation || proxy) return {};
+	return {
+		transform: appendTransform(rectPatch.transform ?? style?.transform, `rotate(${rotation}deg)`),
+		transformOrigin: rectPatch.transformOrigin ?? "center"
+	};
+}
+/** CSS framing is a pure projection of the resolved source and per-use transform. */
+function deriveMediaFramingStyle(source, transform, proxy, style) {
+	if (!transform.rect && !transform.hotspot && !transform.rotation) return style;
+	const rectPatch = rectFramingPatch(source, transform.rect, proxy, style);
+	return mergeStyles(style, {
+		...rectPatch,
+		...hotspotFramingPatch(transform, proxy, rectPatch, style),
+		...rotationFramingPatch(transform.rotation, proxy, rectPatch, style)
+	});
+}
+function computeMediaTransformStyle(value, style, targetAspectRatio, options, context) {
+	const source = resolveRuntimeMedia(value, context ?? getCurrentResolveImageUrlContext());
 	const transform = options?.resolvedTransform ?? resolveMediaTransformForAspect(value.transform, targetAspectRatio);
-	const rect = transform.rect;
-	const hotspot = transform.hotspot;
-	const rotation = transform.rotation;
-	if (!rect && !hotspot && !rotation) return style;
-	const stylePatch = {};
-	const heuristicSuppressCss = Boolean(isExplicitCropProxyEnabled() && value.assetId && (typeof rotation === "number" && rotation !== 0 || isExplicitRectCrop(rect, getValidSourceDimension(value.width), getValidSourceDimension(value.height))));
-	const shouldSuppressCss = options?.isProxy ?? heuristicSuppressCss;
-	if (rect && !shouldSuppressCss) {
-		const rectPatch = buildCssRectStylePatch(value, rect);
-		if (rectPatch) {
-			const mergedRect = applyRectTransform(style, rectPatch);
-			Object.assign(stylePatch, mergedRect);
-		}
-	}
-	if (hotspot) {
-		const effectiveObjectFit = stylePatch.objectFit ?? style?.objectFit;
-		if ((!effectiveObjectFit || effectiveObjectFit === "cover" || effectiveObjectFit === "contain") && stylePatch.objectPosition === void 0) {
-			const resolved = shouldSuppressCss && rotation ? rotateNormalizedPoint({
-				x: hotspot.x,
-				y: hotspot.y
-			}, rotation) : {
-				x: hotspot.x,
-				y: hotspot.y
-			};
-			stylePatch.objectPosition = `${resolved.x * 100}% ${resolved.y * 100}%`;
-		}
-	}
-	if (rotation && !shouldSuppressCss) {
-		const existingTransform = stylePatch.transform ?? style?.transform;
-		stylePatch.transform = existingTransform ? `${existingTransform} rotate(${rotation}deg)` : `rotate(${rotation}deg)`;
-		if (!stylePatch.transformOrigin) stylePatch.transformOrigin = "center";
-	}
-	return mergeStyles(style, stylePatch);
+	return deriveMediaFramingStyle(source, transform, options?.isProxy ?? usesProxyFraming(source, transform), style);
 }
 //#endregion
 //#region ../blocks/src/system/transforms/registry/background.ts
@@ -54462,11 +55636,11 @@ const backgroundTransforms = [
 	}
 ];
 function parseMediaBackground(value) {
-	const background = parseBackgroundContent(value);
+	const background = parseRuntimeBackgroundContent(value);
 	return background?.type === "image" || background?.type === "video" ? background : null;
 }
 function resolveBackgroundLayerStyle(value, fallbackToken, context) {
-	const background = parseBackgroundContent(value);
+	const background = parseRuntimeBackgroundContent(value);
 	const style = {};
 	const gradient = background?.type === "gradient" ? isString(background.gradient) ? background.gradient.trim() : gradientPresetCss(background.gradientPresetId) : null;
 	const color = background?.type === "color" && isString(background.color) ? background.color.trim() : null;
@@ -54609,17 +55783,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",
@@ -54646,6 +55810,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;
+}
 const eventCalendarSelectionParam = {
 	id: "events.calendarSelectionParam",
 	kind: "formatter",