@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/server/page-converter.mjs

@@ -4568,6 +4568,11 @@ const gradientConfigSchema = z.object({
 	position: z.string().optional(),
 	stops: z.array(gradientStopSchema).min(2)
 });
+const gradientsSchema = z.object({
+	button: z.string().min(1).nullable().optional(),
+	hero: z.string().min(1).nullable().optional(),
+	background: z.string().min(1).nullable().optional()
+});
 //#endregion
 //#region ../theme-core/src/interactive/baseSchema.ts
 /**
@@ -5318,11 +5323,30 @@ const headerContainerSchema = z.object({
 	tint: z.string().nullable().optional(),
 	opacity: z.number().min(0).max(1).default(.12)
 }).optional();
-const headerInteractionPaletteSchema = z.enum([
+//#endregion
+//#region ../theme-core/src/header/interactionPalette.ts
+/**
+* The palettes that fill the nav link with a colour on hover and focus. Each
+* one names a background/foreground token pair.
+*/
+const headerInteractionPillPaletteValues = [
 	"primary",
 	"secondary",
 	"accent"
-]);
+];
+/**
+* "No pill": the nav link keeps whatever hover treatment its recipe compiled,
+* and the palette step writes nothing at all (#1318 Phase 4c decision 2).
+*
+* It exists because "a colour change on hover, no filled background" was not
+* expressible in the vocabulary, and it is what
+* `anna-raven-therapy-and-yoga` and `kirtan-lucy` have rendered since before
+* the palette existed. Without it those two rows can only be classified as a
+* conscious visual change.
+*/
+const headerInteractionQuietPalette = "quiet";
+const headerInteractionPaletteValues = [...headerInteractionPillPaletteValues, headerInteractionQuietPalette];
+const headerInteractionPaletteSchema = z.enum(headerInteractionPaletteValues);
 //#endregion
 //#region ../theme-core/src/boxBackgroundSchema.ts
 const boxBackgroundOverlaySchema = z.preprocess(normalizeAuthoringOpacity, z.discriminatedUnion("type", [
@@ -5380,7 +5404,7 @@ const boxBackgroundSchema = z.discriminatedUnion("type", [
 	})
 ]);
 function normalizeAuthoringOpacity(value) {
-	if (!isRecord$7(value)) return value;
+	if (!isRecord$6(value)) return value;
 	return {
 		...value,
 		opacity: normalizeOpacity(value.opacity)
@@ -5389,7 +5413,7 @@ function normalizeAuthoringOpacity(value) {
 function normalizeOpacity(value) {
 	return typeof value === "number" && value > 1 && value <= 100 ? value / 100 : value;
 }
-function isRecord$7(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -5704,11 +5728,12 @@ const inputStyle = z.object({
 	]),
 	label: z.enum(["inside", "above"])
 });
-const headerPositioning = z.enum([
+const headerPositioningValues = [
 	"static",
 	"sticky",
 	"fixed"
-]);
+];
+const headerPositioning = z.enum(headerPositioningValues);
 const headerNavStyle = z.enum([
 	"minimal",
 	"underline",
@@ -5843,7 +5868,7 @@ const headerSchema = z.object({
 	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
-	maxWidth: headerMaxWidth,
+	maxWidth: headerMaxWidth.default("container"),
 	scrollTreatment: headerScrollTreatmentSchema,
 	background: headerBackgroundSchema.default({
 		type: "color",
@@ -6042,11 +6067,6 @@ const bodyTextSchema = z.object({ intro: z.object({
 	paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
 	headingSize: bodyTextIntroTypographySizeSchema.optional()
 }).optional() }).optional();
-const gradientsSchema = z.object({
-	button: z.string().min(1).nullable().optional(),
-	hero: z.string().min(1).nullable().optional(),
-	background: z.string().min(1).nullable().optional()
-});
 /**
 * Testimonial quote-mark treatment, owned by the site style (analogous to the
 * accordion icon). `style` is the coarse selector; the optional fields fine-tune
@@ -6927,6 +6947,12 @@ function cardRoleFromLegacyVocabulary(value) {
 */
 const cardRoleWithLegacyAliasSchema = z.preprocess((value) => cardRoleFromLegacyVocabulary(value) ?? value, cardRoleSchema);
 //#endregion
+//#region ../theme-core/src/site-styles/compilationPlan.ts
+const defaultHeaderBrandPreferences = {
+	brandDisplay: "auto",
+	logoSize: "auto"
+};
+//#endregion
 //#region ../theme-core/src/site-styles/sectionTransitions.ts
 function boundaryRuntimeMetrics(family, size, heightExpression) {
 	return {
@@ -7945,6 +7971,12 @@ const overlayLogoAccommodations = [
 	inlineMarkWithTitleLogoAccommodation,
 	unbackedOverlayLogoAccommodation
 ];
+const allCuratedLogoAccommodations = [
+	...inlineClassicLogoAccommodations,
+	...centeredLogoAccommodations,
+	...overlayLogoAccommodations
+];
+new Set(allCuratedLogoAccommodations.filter((option) => option.providesBacking === true).map((option) => option.pattern));
 const headerLayoutCatalog = defineExactCatalog()([
 	{
 		id: asHeaderLayoutId("classic"),
@@ -8094,6 +8126,10 @@ defineLookOptionGroup({
 		{
 			id: "secondary",
 			label: "Secondary"
+		},
+		{
+			id: headerInteractionQuietPalette,
+			label: "Text only"
 		}
 	]
 });
@@ -10515,6 +10551,67 @@ const blockDesignFallback = {
 };
 blockDesignFallback.sectionSurface, blockDesignFallback.contentFrame, blockDesignFallback.transitionAfter, blockDesignFallback.sectionHeight, blockDesignFallback.heroLegibility, blockDesignFallback.imageSurfaceTreatment, blockDesignFallback.imageSurfaceMotion, blockDesignFallback.tileTreatment, blockDesignFallback.eventListTreatment, blockDesignFallback.eyebrowTreatment, blockDesignFallback.accordionIconTreatment, blockDesignFallback.composition;
 //#endregion
+//#region ../theme-core/src/site-styles/siteChromeBackgrounds.ts
+const siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
+const quickSiteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceQuickColorTokenNames);
+siteChromeBackgroundColorTokens.filter((token) => !quickSiteChromeBackgroundColorTokens.includes(token));
+function parseSiteChromeBackgroundColorToken(value) {
+	const token = parseBackgroundAppearanceColorToken(value);
+	return token ? token : null;
+}
+function toSiteChromeBackgroundColorTokens(tokenNames) {
+	return tokenNames.flatMap((name) => {
+		const token = parseSiteChromeBackgroundColorToken(name);
+		return token ? [token] : [];
+	});
+}
+//#endregion
+//#region ../theme-core/src/site-styles/siteChromeNavPreferences.ts
+const headerNavTypographyPreferenceValues = [
+	"inherit",
+	"body",
+	"heading"
+];
+const headerNavFontSizePreferenceValues = [
+	"inherit",
+	"sm",
+	"base",
+	"lg",
+	"xl"
+];
+const defaultHeaderNavPreferences = {
+	typography: "inherit",
+	fontSize: "inherit",
+	interactionPalette: "recommended"
+};
+//#endregion
+//#region ../theme-core/src/site-styles/headerBrandPresentation.ts
+/**
+* Whether the header wears a brand presentation at all (#1318 Phase 4c).
+*
+* `applyHeaderBrandPresentation` is unconditional today: given a logo context
+* it always writes a `logo` object carrying a resolved display, size and
+* accommodation. That makes "this header has no brand presentation block" —
+* which is what several live sites persist, including one whose site *does*
+* have a logo asset — a state the preference record could not express, so a
+* recompile would silently give the site a logo treatment it has never
+* rendered.
+*
+* This is the third field in this phase with that shape, after the interaction
+* palette and the nav text size: the persisted bytes carry intent the reader
+* cannot say, so the recompile "corrects" it. The fix is the same one — widen
+* the closed vocabulary with a named member and derive it by baseline
+* comparison — and it is a *widening*, not a restyle: `'recommended'` is the
+* default and reproduces today's behaviour exactly, so no row whose bytes carry
+* a presentation compiles differently for `'plain'` existing.
+*
+* `'plain'` is deliberately not "preserve whatever bytes are there". It is a
+* constructive instruction — *write no presentation block* — so Phase 4e's
+* compiler, which builds the header from nothing, can produce it.
+*/
+const headerBrandPresentationValues = ["recommended", "plain"];
+defaultHeaderBrandPreferences.brandDisplay, defaultHeaderBrandPreferences.logoSize, defaultHeaderNavPreferences.typography, defaultHeaderNavPreferences.fontSize, defaultHeaderNavPreferences.interactionPalette;
+//#endregion
 //#region ../theme-core/src/site-styles/generatedSchemas.ts
 function uniqueNonEmpty(values) {
 	const uniqueValues = [...new Set(values)];
@@ -10583,6 +10680,56 @@ z.object({
 	blocks: z.array(generatedPageDesignBlockIntentSchema)
 }).strict();
 //#endregion
+//#region ../theme-core/src/site-styles/headerPreferencesPersistence.ts
+const backgroundColorTokenSchema = z.unknown().transform((value, ctx) => {
+	const token = parseSiteChromeBackgroundColorToken(value);
+	if (token === null) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Unknown site chrome background colour token"
+		});
+		return z.NEVER;
+	}
+	return token;
+});
+const backgroundOverrideSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("default") }).strict(), z.object({
+	kind: z.literal("color"),
+	token: backgroundColorTokenSchema
+}).strict()]);
+const logoTextIntentSchema = z.object({
+	mobileMaxWidth: z.enum([
+		"xs",
+		"sm",
+		"md"
+	]).optional(),
+	mobileWrapLines: z.union([z.literal(1), z.literal(2)]).optional(),
+	hideOnShrink: z.boolean().optional()
+}).strict();
+const structureSchema = z.object({
+	positioning: z.union([z.literal("inherit"), z.enum(headerPositioningValues)]),
+	shrinkOnScroll: z.union([z.literal("inherit"), z.boolean()]),
+	logoText: z.union([
+		z.literal("inherit"),
+		z.literal("none"),
+		logoTextIntentSchema
+	])
+}).strict();
+const headerPreferencesShape = {
+	brandPresentation: z.enum(headerBrandPresentationValues),
+	brandDisplay: z.enum(brandDisplayModeValues),
+	logoSize: z.enum(logoSizePolicyValues),
+	navFontRole: z.enum(headerNavTypographyPreferenceValues),
+	navTextSize: z.enum(headerNavFontSizePreferenceValues),
+	interactionPalette: z.union([z.literal("recommended"), z.enum(headerInteractionPaletteValues)]),
+	background: backgroundOverrideSchema,
+	structure: structureSchema
+};
+z.object(headerPreferencesShape).strict();
+z.object(headerPreferencesShape).omit({
+	brandPresentation: true,
+	structure: true
+}).strict();
+//#endregion
 //#region ../theme-core/src/site-styles/pageDesignAuthority.ts
 const nonEmptyStringSchema = z.string().min(1);
 const blockContentVersionIdSchema = nonEmptyStringSchema.transform(asBlockContentVersionId);
@@ -10684,21 +10831,6 @@ function collectBlockSequenceIssues(snapshots) {
 	return issues;
 }
 //#endregion
-//#region ../theme-core/src/site-styles/siteChromeBackgrounds.ts
-const siteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceColorTokenNames);
-const quickSiteChromeBackgroundColorTokens = toSiteChromeBackgroundColorTokens(backgroundAppearanceQuickColorTokenNames);
-siteChromeBackgroundColorTokens.filter((token) => !quickSiteChromeBackgroundColorTokens.includes(token));
-function parseSiteChromeBackgroundColorToken(value) {
-	const token = parseBackgroundAppearanceColorToken(value);
-	return token ? token : null;
-}
-function toSiteChromeBackgroundColorTokens(tokenNames) {
-	return tokenNames.flatMap((name) => {
-		const token = parseSiteChromeBackgroundColorToken(name);
-		return token ? [token] : [];
-	});
-}
-//#endregion
 //#region ../theme-core/src/site-styles/tokenRecipes.ts
 const themeTokenRecipeOptions = {
 	palette: [
@@ -10905,22 +11037,59 @@ function formatCurrencyAmount(amountCents, currency, options) {
 	}
 }
 //#endregion
+//#region ../core/src/planner.ts
+/** Default clock for production callers that do not inject time explicitly. */
+const systemPlanningClock = { now: () => Date.now() };
+/** Resolve current time as a Date from an explicit Date, injected clock, or system clock. */
+function resolvePlanningNowDate(input = {}) {
+	if (input.now !== void 0) return input.now;
+	return new Date((input.clock ?? systemPlanningClock).now());
+}
+//#endregion
 //#region ../core/src/event-pricing.ts
+/** Capacity closes booking, but does not make an otherwise eligible price unknown. */
+function isPublicEventPricingOptionDisplayable(option) {
+	if (!option.isActive) return false;
+	if (option.availability.kind === "available") return true;
+	const reason = option.availability.reason;
+	switch (reason) {
+		case "sold_out":
+		case "overallCapacityUnavailable": return true;
+		case "inactive":
+		case "not_on_sale_yet":
+		case "sale_ended":
+		case "attendance_mode_unavailable": return false;
+		default: return assertNever$1(reason);
+	}
+}
+function publicEventPricingDisplay(pricing) {
+	switch (pricing.kind) {
+		case "free":
+		case "single":
+		case "sliding_scale": return canonicalEventPricingDisplay(pricing);
+		case "tiered": return resolvePricingOptionsPriceDisplay({
+			options: pricing.options.filter(isPublicEventPricingOptionDisplayable),
+			currency: pricing.currency,
+			purpose: "configured"
+		});
+		case "external": return {
+			kind: "external",
+			label: pricing.label
+		};
+	}
+}
 function publicEventPricingType(pricing) {
 	switch (pricing.kind) {
-		case "drop_in":
-		case "free_registration": return "free";
-		case "single_paid":
-		case "ticket_types":
-		case "sliding_scale":
-		case "whole_series": return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+		case "free": return "free";
+		case "single":
+		case "tiered":
+		case "sliding_scale": return isFreePublicEventPriceDisplay(publicEventPricingDisplay(pricing)) ? "free" : "paid";
 		case "external": return "external";
 	}
 }
 function isFreePublicEventPriceDisplay(display) {
 	switch (display.kind) {
 		case "free": return true;
-		case "whole_series": return display.display.kind === "free";
 		case "exact":
 		case "from":
 		case "range":
@@ -10929,22 +11098,126 @@ function isFreePublicEventPriceDisplay(display) {
 		case "external": return false;
 	}
 }
+function resolvePricingOptionSaleWindowState(option, now) {
+	if (option.saleStartsAt !== null && option.saleStartsAt !== void 0 && new Date(option.saleStartsAt) > now) return "not_started";
+	if (option.saleEndsAt !== null && option.saleEndsAt !== void 0 && new Date(option.saleEndsAt) < now) return "ended";
+	return "open";
+}
+function resolvePricingOptionsPriceDisplay(input) {
+	const now = input.purpose === "available_now" ? resolvePlanningNowDate({
+		now: input.now,
+		clock: input.clock
+	}) : null;
+	const amounts = input.options.filter((option) => option.isActive && (now === null || resolvePricingOptionSaleWindowState(option, now) === "open")).map((option) => option.priceAmount);
+	return amounts.length === 0 ? {
+		kind: "unavailable",
+		currency: input.currency
+	} : amountRangeDisplay(amounts, input.currency);
+}
+function amountRangeDisplay(amounts, currency) {
+	const minAmount = Math.min(...amounts);
+	const maxAmount = Math.max(...amounts);
+	if (minAmount === maxAmount) return minAmount === 0 ? {
+		kind: "free",
+		currency
+	} : {
+		kind: "exact",
+		amount: minAmount,
+		currency
+	};
+	if (minAmount === 0) {
+		const paidAmounts = amounts.filter((amount) => amount > 0);
+		return {
+			kind: "mixed",
+			paidFromAmount: Math.min(...paidAmounts),
+			paidToAmount: maxAmount,
+			currency
+		};
+	}
+	return {
+		kind: "range",
+		minAmount,
+		maxAmount,
+		currency
+	};
+}
+/** Derives configured price presentation directly from canonical pricing. */
+function canonicalEventPricingDisplay(pricing) {
+	switch (pricing.kind) {
+		case "free": return {
+			kind: "free",
+			currency: pricing.currency
+		};
+		case "single": return {
+			kind: "exact",
+			amount: pricing.amount,
+			currency: pricing.currency
+		};
+		case "sliding_scale": return pricing.minimum === pricing.maximum ? {
+			kind: "exact",
+			amount: pricing.maximum,
+			currency: pricing.currency
+		} : {
+			kind: "range",
+			minAmount: pricing.minimum,
+			maxAmount: pricing.maximum,
+			currency: pricing.currency
+		};
+		case "tiered": return resolvePricingOptionsPriceDisplay({
+			options: pricing.options,
+			currency: pricing.currency,
+			purpose: "configured"
+		});
+		default: return assertNever$1(pricing);
+	}
+}
 //#endregion
 //#region ../core/src/event-page-surface-subject.ts
-function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope, eventDestinationMode) {
+	const mode = eventDestinationMode ? { eventDestinationMode } : {};
 	return bookingScope === "whole_series" ? {
 		kind: "eventSeries",
 		eventSeriesId,
 		bookingScope,
-		isWholeSeriesBooking: true
+		isWholeSeriesBooking: true,
+		...mode
 	} : {
 		kind: "eventSeries",
 		eventSeriesId,
-		bookingScope
+		bookingScope,
+		...mode
+	};
+}
+function createEventOfferingPageSurfaceSubject(eventOfferingId, input) {
+	const mode = input.eventDestinationMode ? { eventDestinationMode: input.eventDestinationMode } : {};
+	const identity = {
+		kind: "eventOffering",
+		eventOfferingId,
+		catalogueEventSeriesIds: input.catalogueEventSeriesIds
+	};
+	return input.bookingScope === "whole_series" ? {
+		...identity,
+		bookingScope: input.bookingScope,
+		isWholeSeriesBooking: true,
+		...mode
+	} : {
+		...identity,
+		bookingScope: input.bookingScope,
+		...mode
 	};
 }
+/**
+* Read the destination mode off a wire value.
+*
+* Absent or unrecognised reads as absent, which leaves the routed Event record
+* as the only authority — the behaviour every caller had before the field
+* existed.
+*/
+function parseEventPageSurfaceDestinationMode(value) {
+	return value === "cms-managed" || value === "system-managed" ? value : void 0;
+}
 function parseEventPageSurfaceSubject(value) {
-	if (!isRecord$6(value)) return err({ kind: "notObject" });
+	if (!isRecord$5(value)) return err({ kind: "notObject" });
 	switch (value.kind) {
 		case "eventSeries": {
 			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
@@ -10956,7 +11229,7 @@ function parseEventPageSurfaceSubject(value) {
 				kind: "invalidEventSeriesBookingScope",
 				bookingScope: value.bookingScope
 			});
-			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope, parseEventPageSurfaceDestinationMode(value.eventDestinationMode)));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -10964,24 +11237,22 @@ function parseEventPageSurfaceSubject(value) {
 				kind: "invalidEventOfferingId",
 				error: eventOfferingId.error
 			});
-			if (!Array.isArray(value.availableEventSeriesIds)) return err({
-				kind: "unsupportedSubject",
-				subjectKind: value.kind
+			if (!Array.isArray(value.catalogueEventSeriesIds)) return err({
+				kind: "invalidEventOfferingCatalogue",
+				catalogue: value.catalogueEventSeriesIds
 			});
-			const parsedSeriesIds = [];
-			for (const valueId of value.availableEventSeriesIds) {
-				const eventSeriesId = parseEventSeriesId(valueId);
-				if (!eventSeriesId.ok) return err({
-					kind: "invalidEventSeriesId",
-					error: eventSeriesId.error
-				});
-				parsedSeriesIds.push(eventSeriesId.value);
-			}
-			return ok({
-				kind: "eventOffering",
-				eventOfferingId: eventOfferingId.value,
-				availableEventSeriesIds: parsedSeriesIds
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") return err({
+				kind: "invalidEventOfferingBookingScope",
+				bookingScope: value.bookingScope
 			});
+			const parsedCatalogueIds = parseEventSeriesIdList(value.catalogueEventSeriesIds);
+			if (!parsedCatalogueIds.ok) return parsedCatalogueIds;
+			const eventDestinationMode = parseEventPageSurfaceDestinationMode(value.eventDestinationMode);
+			return ok(createEventOfferingPageSurfaceSubject(eventOfferingId.value, {
+				catalogueEventSeriesIds: parsedCatalogueIds.value,
+				bookingScope: value.bookingScope,
+				...eventDestinationMode ? { eventDestinationMode } : {}
+			}));
 		}
 		default: return err({
 			kind: "unsupportedSubject",
@@ -10989,7 +11260,19 @@ function parseEventPageSurfaceSubject(value) {
 		});
 	}
 }
-function isRecord$6(value) {
+function parseEventSeriesIdList(values) {
+	const parsed = [];
+	for (const value of values) {
+		const eventSeriesId = parseEventSeriesId(value);
+		if (!eventSeriesId.ok) return err({
+			kind: "invalidEventSeriesId",
+			error: eventSeriesId.error
+		});
+		parsed.push(eventSeriesId.value);
+	}
+	return ok(parsed);
+}
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -11163,27 +11446,21 @@ function toLocationCoordinates(value) {
 function parseNewsletterSignupDestinationProvider(value) {
 	return value === "riverbank" || value === "mailchimp" ? value : null;
 }
-//#endregion
-//#region ../core/src/planner.ts
-/** Default clock for production callers that do not inject time explicitly. */
-const systemPlanningClock = { now: () => Date.now() };
-/** Resolve current time as a Date from an explicit Date, injected clock, or system clock. */
-function resolvePlanningNowDate(input = {}) {
-	if (input.now !== void 0) return input.now;
-	return new Date((input.clock ?? systemPlanningClock).now());
+function sessionStartMs(session) {
+	return Date.parse(session.startsAt);
 }
 /**
-* Resolve a Date-compatible planner input.
+* The run's sessions that still count, in schedule order.
 *
-* Precedence: bare Date, `{ now }`, `{ clock }`, then `systemPlanningClock`.
-* Explicit Date inputs are returned by reference, not cloned.
+* Sessions whose start cannot be read are dropped rather than sorted to an
+* arbitrary end: an unparseable date is not a date a visitor can attend.
 */
-function resolvePlanningDateInput(input = {}) {
-	if (input instanceof Date) return input;
-	return resolvePlanningNowDate(input);
+function orderedLiveRunSessions(sessions) {
+	return sessions.filter((session) => session.status !== "cancelled" && Number.isFinite(sessionStartMs(session))).sort((left, right) => sessionStartMs(left) - sessionStartMs(right));
 }
 //#endregion
 //#region ../core/src/event-series-behaviour.ts
+const WHOLE_SERIES_EVENT_PRESET_VALUES = ["course", "term"];
 const SURFACE_EVENT_PRESET_VALUES = [
 	"class",
 	"course",
@@ -21060,296 +21337,51 @@ const bookingRequirementConsentFieldSchema = z.object({
 });
 z.union([blockBookingConsentSchema, bookingRequirementConsentFieldSchema]);
 //#endregion
-//#region ../blocks/src/system/blocks/events/whole-series/pricing.ts
-function isSaleWindowOpen(option, now) {
-	if (!option.isActive) return false;
-	if (option.saleStartsAt && new Date(option.saleStartsAt) > now) return false;
-	if (option.saleEndsAt && new Date(option.saleEndsAt) < now) return false;
-	return true;
-}
-function toExactOrFreeDisplay(amount, currency) {
-	if (amount <= 0) return {
-		kind: "free",
-		currency
-	};
-	return {
-		kind: "exact",
-		amount,
-		currency
-	};
-}
-function getSelectableWholeSeriesPricingOptionsForNow(offering, now) {
-	if (offering.pricing.pricingStrategy !== "tiered") return [];
-	return [...offering.pricing.options].filter((option) => isSaleWindowOpen(option, now)).sort((left, right) => {
-		if (left.sortOrder !== right.sortOrder) return left.sortOrder - right.sortOrder;
-		if (left.priceAmount !== right.priceAmount) return left.priceAmount - right.priceAmount;
-		return left.name.localeCompare(right.name);
-	});
-}
-function resolveWholeSeriesPricingState(offering, selectedPricingOptionId, selectedSlidingAmountOrNowInput, nowInput = {}) {
-	const selection = normalizePricingSelectionInput(selectedSlidingAmountOrNowInput, nowInput);
-	const currency = offering.pricing.currency;
-	switch (offering.pricing.pricingStrategy) {
-		case "free": return resolveFreePricing(currency);
-		case "single": return resolveSinglePricing(offering.pricing.singlePriceAmount ?? 0, currency);
-		case "tiered": return resolveTieredPricing(offering, selectedPricingOptionId, selection.nowInput);
-		case "sliding_scale": return resolveSlidingScalePricing(offering, selection.selectedSlidingAmount);
-	}
-}
-function normalizePricingSelectionInput(selectedSlidingAmountOrNowInput, nowInput) {
-	return typeof selectedSlidingAmountOrNowInput === "object" && selectedSlidingAmountOrNowInput !== null ? {
-		selectedSlidingAmount: null,
-		nowInput: selectedSlidingAmountOrNowInput
-	} : {
-		selectedSlidingAmount: typeof selectedSlidingAmountOrNowInput === "number" || selectedSlidingAmountOrNowInput === null ? selectedSlidingAmountOrNowInput : null,
-		nowInput
-	};
-}
-function resolveFreePricing(currency) {
-	return {
-		currency,
-		display: {
-			kind: "free",
-			currency
-		},
-		selectableOptions: [],
-		requiresSelection: false,
-		selectedOption: null,
-		slidingScale: null,
-		selectedSlidingAmount: null,
-		selectedPriceAmount: 0,
-		selectedRequiresPayment: false,
-		hasPaidSelection: false,
-		hasFreeSelection: true
-	};
-}
-function resolveSinglePricing(amount, currency) {
-	return {
-		currency,
-		display: toExactOrFreeDisplay(amount, currency),
-		selectableOptions: [],
-		requiresSelection: false,
-		selectedOption: null,
-		slidingScale: null,
-		selectedSlidingAmount: null,
-		selectedPriceAmount: amount,
-		selectedRequiresPayment: amount > 0,
-		hasPaidSelection: amount > 0,
-		hasFreeSelection: amount <= 0
-	};
-}
-function resolveTieredPricing(offering, selectedPricingOptionId, nowInput) {
-	const currency = offering.pricing.currency;
-	const selectableOptions = getSelectableWholeSeriesPricingOptionsForNow(offering, resolvePlanningDateInput(nowInput));
-	const selectedOption = resolveSelectedTier(selectableOptions, selectedPricingOptionId);
-	return {
-		currency,
-		display: resolveTieredDisplay(selectableOptions.reduce((lowest, option) => lowest === null || option.priceAmount < lowest ? option.priceAmount : lowest, null), selectableOptions.length, currency),
-		selectableOptions,
-		requiresSelection: selectableOptions.length > 1,
-		selectedOption,
-		slidingScale: null,
-		selectedSlidingAmount: null,
-		selectedPriceAmount: selectedOption?.priceAmount ?? null,
-		selectedRequiresPayment: (selectedOption?.priceAmount ?? 0) > 0,
-		hasPaidSelection: selectableOptions.some((option) => option.priceAmount > 0),
-		hasFreeSelection: selectableOptions.some((option) => option.priceAmount === 0)
-	};
-}
-function resolveSelectedTier(options, selectedId) {
-	return (selectedId ? options.find((option) => option.id === selectedId) : null) ?? (options.length === 1 ? options[0] ?? null : null);
-}
-function resolveTieredDisplay(lowestAmount, optionCount, currency) {
-	if (lowestAmount === null) return {
-		kind: "unavailable",
-		currency
-	};
-	return optionCount > 1 && lowestAmount > 0 ? {
-		kind: "from",
-		amount: lowestAmount,
-		currency
-	} : toExactOrFreeDisplay(lowestAmount, currency);
-}
-function resolveSlidingScalePricing(offering, selectedSlidingAmount) {
-	const currency = offering.pricing.currency;
-	const minAmount = offering.pricing.slidingMinAmount ?? null;
-	const maxAmount = offering.pricing.slidingMaxAmount ?? null;
-	if (minAmount === null || maxAmount === null || minAmount < 0 || maxAmount < minAmount) return unavailableSlidingScale(currency);
-	const selectedAmount = Number.isFinite(selectedSlidingAmount) ? selectedSlidingAmount : null;
-	return {
-		currency,
-		display: {
-			kind: "range",
-			minAmount,
-			maxAmount,
-			currency
-		},
-		selectableOptions: [],
-		requiresSelection: selectedAmount === null,
-		selectedOption: null,
-		slidingScale: {
-			minAmount,
-			maxAmount,
-			suggestedAmount: offering.pricing.slidingSuggestedAmount ?? null
-		},
-		selectedSlidingAmount: selectedAmount,
-		selectedPriceAmount: selectedAmount,
-		selectedRequiresPayment: (selectedAmount ?? 0) > 0,
-		hasPaidSelection: maxAmount > 0,
-		hasFreeSelection: minAmount === 0
-	};
-}
-function unavailableSlidingScale(currency) {
-	return {
-		currency,
-		display: {
-			kind: "unavailable",
-			currency
-		},
-		selectableOptions: [],
-		requiresSelection: true,
-		selectedOption: null,
-		slidingScale: null,
-		selectedSlidingAmount: null,
-		selectedPriceAmount: null,
-		selectedRequiresPayment: false,
-		hasPaidSelection: false,
-		hasFreeSelection: false
-	};
-}
-//#endregion
-//#region ../blocks/src/system/blocks/events/whole-series/schemas.ts
-const wholeSeriesVenueSchema = z.object({
+//#region ../blocks/src/system/blocks/events/shared/schemas.ts
+const eventPresetSchema = z.enum([
+	"event",
+	"class",
+	"course",
+	"term",
+	"workshop",
+	"retreat",
+	"performance"
+]);
+const eventScheduleScopeSchema$2 = z.enum(["recurring", "oneOff"]);
+const publicEventRecurrenceSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("weekly"),
+	interval: z.number().int().positive(),
+	weekdays: z.array(z.enum([
+		"MO",
+		"TU",
+		"WE",
+		"TH",
+		"FR",
+		"SA",
+		"SU"
+	]))
+}).readonly(), z.object({ kind: z.literal("other") }).readonly()]);
+const eventDestinationModeSchema = z.enum(["cms-managed", "system-managed"]);
+const publicEventDestinationSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("native"),
+	mode: eventDestinationModeSchema,
+	path: z.string()
+}), z.object({
+	kind: z.literal("external"),
+	url: z.string(),
+	label: z.string()
+})]);
+/**
+* Zod schema for venue data
+*/
+const eventVenueSchema = z.object({
 	id: z.string(),
 	name: z.string(),
-	address: z.string().nullable()
-});
-const wholeSeriesSessionSchema = z.object({
-	id: z.string(),
-	startsAt: z.string(),
-	endsAt: z.string(),
-	timeZone: z.string(),
-	capacityOverride: z.number().nullable().optional(),
-	overrides: z.record(z.string(), z.unknown()).nullable().optional()
-});
-const wholeSeriesTeamMemberSummarySchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	roleLabel: z.string().nullable(),
-	summary: z.string().nullable(),
-	profilePath: z.string().nullable()
-});
-const wholeSeriesPricingOptionSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	description: z.string().nullable(),
-	priceAmount: z.number(),
-	isActive: z.boolean(),
-	sortOrder: z.number(),
-	capacityLimit: z.number().nullable(),
-	saleStartsAt: z.string().nullable(),
-	saleEndsAt: z.string().nullable(),
-	attendanceScope: z.enum([
-		"in_person",
-		"online",
-		"both"
-	]).nullable().optional()
-});
-const wholeSeriesPricingSchema = z.object({
-	bookingRequirement: z.enum(["none", "required"]),
-	pricingStrategy: z.enum([
-		"free",
-		"single",
-		"tiered",
-		"sliding_scale"
-	]),
-	currency: z.string(),
-	singlePriceAmount: z.number().nullable(),
-	slidingMinAmount: z.number().nullable().optional(),
-	slidingMaxAmount: z.number().nullable().optional(),
-	slidingSuggestedAmount: z.number().nullable().optional(),
-	paymentTerms: blockBookingPaymentTermsSchema,
-	options: z.array(wholeSeriesPricingOptionSchema)
-});
-const publicWholeSeriesOfferingSchema = z.object({
-	eventSeriesId: z.string(),
-	eventOfferingId: z.string(),
-	title: z.string(),
-	slug: z.string(),
-	description: z.unknown().nullable(),
-	deliveryMode: z.enum([
-		"in_person",
-		"online",
-		"hybrid"
-	]),
-	waitlistEnabled: z.boolean(),
-	requireGuestDetails: z.boolean(),
-	teamMembers: z.array(wholeSeriesTeamMemberSummarySchema).optional(),
-	enrollmentOpen: z.boolean(),
-	pricing: wholeSeriesPricingSchema,
-	currency: z.string(),
-	paymentTerms: blockBookingPaymentTermsSchema,
-	consent: blockBookingConsentSchema.nullable(),
-	enrollmentCapacity: z.number().nullable(),
-	acceptsMemberships: z.boolean(),
-	status: z.enum([
-		"active",
-		"draft",
-		"cancelled"
-	]),
-	sessionsCount: z.number(),
-	enrolledCount: z.number(),
-	availableSpots: z.number().nullable(),
-	sessions: z.array(wholeSeriesSessionSchema),
-	venue: wholeSeriesVenueSchema.nullable()
-});
-const publicWholeSeriesOfferingsArraySchema = z.array(publicWholeSeriesOfferingSchema);
-//#endregion
-//#region ../blocks/src/system/blocks/events/shared/schemas.ts
-const eventPresetSchema = z.enum([
-	"event",
-	"class",
-	"course",
-	"term",
-	"workshop",
-	"retreat",
-	"performance"
-]);
-const eventScheduleScopeSchema$2 = z.enum(["recurring", "oneOff"]);
-const publicEventRecurrenceSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("weekly"),
-	interval: z.number().int().positive(),
-	weekdays: z.array(z.enum([
-		"MO",
-		"TU",
-		"WE",
-		"TH",
-		"FR",
-		"SA",
-		"SU"
-	]))
-}).readonly(), z.object({ kind: z.literal("other") }).readonly()]);
-const eventDestinationModeSchema = z.enum(["cms-managed", "system-managed"]);
-const publicEventDestinationSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("native"),
-	mode: eventDestinationModeSchema,
-	path: z.string()
-}), z.object({
-	kind: z.literal("external"),
-	url: z.string(),
-	label: z.string()
-})]);
-/**
-* Zod schema for venue data
-*/
-const eventVenueSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	address: z.string().nullable(),
-	location: z.object({
-		lat: z.number(),
-		lng: z.number()
-	}).nullable()
+	address: z.string().nullable(),
+	location: z.object({
+		lat: z.number(),
+		lng: z.number()
+	}).nullable()
 });
 /**
 * Zod schema for event category data
@@ -21359,77 +21391,14 @@ const eventCategorySchema = z.object({
 	name: z.string(),
 	color: z.string().nullable()
 });
-z.enum([
-	"free",
-	"paid",
-	"external"
-]);
 /**
 * Access restriction type for public events
 */
 const accessRestrictionSchema = z.enum(["none", "category"]);
-z.enum(["single", "ticket_types"]);
-const freePriceDisplaySchema = z.object({
-	kind: z.literal("free"),
-	currency: z.string()
-});
-const exactPriceDisplaySchema = z.object({
-	kind: z.literal("exact"),
-	amount: z.number(),
-	currency: z.string()
-});
-const fromPriceDisplaySchema = z.object({
-	kind: z.literal("from"),
-	amount: z.number(),
-	currency: z.string()
-});
-const unavailablePriceDisplaySchema = z.object({
-	kind: z.literal("unavailable"),
-	currency: z.string()
-});
-const rangePriceDisplaySchema = z.object({
-	kind: z.literal("range"),
-	minAmount: z.number(),
-	maxAmount: z.number(),
-	currency: z.string()
-});
-const mixedPriceDisplaySchema = z.object({
-	kind: z.literal("mixed"),
-	paidFromAmount: z.number(),
-	paidToAmount: z.number(),
-	currency: z.string()
-});
-const publicWholeSeriesPriceDisplaySchema = z.discriminatedUnion("kind", [
-	freePriceDisplaySchema,
-	exactPriceDisplaySchema,
-	fromPriceDisplaySchema,
-	rangePriceDisplaySchema,
-	unavailablePriceDisplaySchema
-]);
-z.discriminatedUnion("kind", [
-	freePriceDisplaySchema,
-	exactPriceDisplaySchema,
-	fromPriceDisplaySchema,
-	rangePriceDisplaySchema,
-	mixedPriceDisplaySchema,
-	unavailablePriceDisplaySchema,
-	z.object({
-		kind: z.literal("external"),
-		label: z.string()
-	}),
-	z.object({
-		kind: z.literal("whole_series"),
-		display: publicWholeSeriesPriceDisplaySchema
-	})
-]);
-const publicEventTicketTypePriceDisplaySchema = z.union([
-	freePriceDisplaySchema,
-	exactPriceDisplaySchema,
-	fromPriceDisplaySchema,
-	rangePriceDisplaySchema,
-	mixedPriceDisplaySchema,
-	unavailablePriceDisplaySchema
-]);
+const publicCurrencySchema = z.string().regex(/^[A-Z]{3}$/u);
+const publicCentsSchema = z.number().int().nonnegative();
+const publicPositiveCentsSchema = z.number().int().positive();
+const publicIsoDateTimeSchema = z.string().datetime({ offset: true });
 const publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
 const publicEventAttendanceModeAvailabilitySchema = z.object({
 	mode: publicEventAttendanceModeSchema,
@@ -21438,9 +21407,9 @@ const publicEventAttendanceModeAvailabilitySchema = z.object({
 	availableSpots: z.number().nullable(),
 	waitlistEnabled: z.boolean()
 });
-const publicEventTicketTypeAvailabilitySchema = z.union([z.object({
+const publicEventPricingOptionAvailabilitySchema = z.union([z.object({
 	kind: z.literal("available"),
-	remainingCapacity: z.number().nullable()
+	remainingPlaces: z.number().int().nonnegative().nullable()
 }), z.object({
 	kind: z.literal("unavailable"),
 	reason: z.enum([
@@ -21448,91 +21417,69 @@ const publicEventTicketTypeAvailabilitySchema = z.union([z.object({
 		"not_on_sale_yet",
 		"sale_ended",
 		"sold_out",
-		"event_sold_out"
+		"attendance_mode_unavailable",
+		"overallCapacityUnavailable"
 	]),
-	remainingCapacity: z.number().nullable()
+	remainingPlaces: z.number().int().nonnegative().nullable()
 })]);
-const publicEventTicketTypeSchema = z.object({
-	id: z.string(),
-	siteId: z.string(),
-	eventSeriesId: z.string(),
-	name: z.string(),
+const publicEventPricingOptionSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
 	description: z.string().nullable(),
-	priceAmount: z.number(),
+	priceAmount: publicCentsSchema,
 	isActive: z.boolean(),
-	sortOrder: z.number(),
-	capacityMode: z.enum(["limited", "unlimited"]),
-	capacityLimit: z.number().nullable(),
+	sortOrder: z.number().int().nonnegative(),
 	attendanceScope: z.enum([
 		"in_person",
 		"online",
 		"both"
-	]).optional(),
-	saleStartsAt: z.string().nullable(),
-	saleEndsAt: z.string().nullable(),
-	availability: publicEventTicketTypeAvailabilitySchema,
-	createdAt: z.string(),
-	updatedAt: z.string()
+	]),
+	saleStartsAt: publicIsoDateTimeSchema.nullable(),
+	saleEndsAt: publicIsoDateTimeSchema.nullable(),
+	availability: publicEventPricingOptionAvailabilitySchema
+}).superRefine((option, context) => {
+	if (option.saleStartsAt && option.saleEndsAt && Date.parse(option.saleEndsAt) <= Date.parse(option.saleStartsAt)) context.addIssue({
+		code: "custom",
+		path: ["saleEndsAt"],
+		message: "Sale end must be after sale start"
+	});
 });
 const publicEventPricingSchema = z.discriminatedUnion("kind", [
 	z.object({
-		kind: z.literal("drop_in"),
-		currency: z.string(),
-		display: z.object({
-			kind: z.literal("free"),
-			currency: z.string()
-		})
-	}),
-	z.object({
-		kind: z.literal("free_registration"),
-		currency: z.string(),
-		display: z.object({
-			kind: z.literal("free"),
-			currency: z.string()
-		})
+		kind: z.literal("free"),
+		currency: publicCurrencySchema
 	}),
 	z.object({
-		kind: z.literal("single_paid"),
-		amount: z.number(),
-		currency: z.string(),
-		display: z.object({
-			kind: z.literal("exact"),
-			amount: z.number(),
-			currency: z.string()
-		})
+		kind: z.literal("single"),
+		amount: publicPositiveCentsSchema,
+		currency: publicCurrencySchema
 	}),
 	z.object({
-		kind: z.literal("ticket_types"),
-		currency: z.string(),
-		ticketTypes: z.array(publicEventTicketTypeSchema),
-		display: publicEventTicketTypePriceDisplaySchema
+		kind: z.literal("tiered"),
+		currency: publicCurrencySchema,
+		options: z.tuple([publicEventPricingOptionSchema], publicEventPricingOptionSchema)
 	}),
 	z.object({
 		kind: z.literal("sliding_scale"),
-		minAmount: z.number(),
-		maxAmount: z.number(),
-		suggestedAmount: z.number().nullable(),
-		currency: z.string(),
-		display: z.object({
-			kind: z.literal("range"),
-			minAmount: z.number(),
-			maxAmount: z.number(),
-			currency: z.string()
-		})
-	}),
-	z.object({
-		kind: z.literal("whole_series"),
-		display: z.object({
-			kind: z.literal("whole_series"),
-			display: publicWholeSeriesPriceDisplaySchema
-		})
+		minimum: publicCentsSchema,
+		maximum: publicPositiveCentsSchema,
+		suggested: publicCentsSchema.nullable(),
+		currency: publicCurrencySchema
+	}).superRefine((pricing, context) => {
+		if (pricing.minimum > pricing.maximum) context.addIssue({
+			code: "custom",
+			path: ["minimum"],
+			message: "Minimum must not exceed maximum"
+		});
+		if (pricing.suggested !== null && (pricing.suggested < pricing.minimum || pricing.suggested > pricing.maximum)) context.addIssue({
+			code: "custom",
+			path: ["suggested"],
+			message: "Suggested amount must be within the sliding-scale range"
+		});
 	}),
 	z.object({
 		kind: z.literal("external"),
-		display: z.object({
-			kind: z.literal("external"),
-			label: z.string()
-		})
+		label: z.string().min(1)
 	})
 ]);
 const publicTeamMemberSummarySchema = z.object({
@@ -21558,11 +21505,30 @@ const publicEventBookingAvailabilitySchema = z.discriminatedUnion("kind", [z.obj
 		"enrollment_closed"
 	])
 })]);
+const publicRunSessionSchema = z.object({
+	occurrenceId: z.string(),
+	startsAt: z.string(),
+	endsAt: z.string(),
+	timeZone: z.string(),
+	status: z.string()
+});
+const publicWholeSeriesRunSchema = z.object({
+	eventSeriesId: z.string(),
+	eventOfferingId: z.string(),
+	enrollmentOpen: z.boolean(),
+	visibility: z.enum(["public", "unlisted"]),
+	lifecycle: z.enum([
+		"upcoming",
+		"in_progress",
+		"completed",
+		"cancelled"
+	]),
+	sessions: z.array(publicRunSessionSchema)
+});
 /**
-* Zod schema for public event data
+* Zod schema for the fields shared by both booking scopes.
 */
-const publicEventSchema = z.object({
-	bookingScope: z.enum(["single_occurrence", "whole_series"]),
+const publicEventBaseSchema = z.object({
 	eventPreset: eventPresetSchema.optional(),
 	eventDestinationMode: eventDestinationModeSchema.optional(),
 	scheduleScope: eventScheduleScopeSchema$2.optional(),
@@ -21612,20 +21578,68 @@ const publicEventSchema = z.object({
 	accessRestriction: accessRestrictionSchema,
 	allowedCategoryIds: z.array(z.string()),
 	requireGuestDetails: z.boolean().optional(),
-	acceptsPasses: z.boolean().optional(),
-	acceptsMemberships: z.boolean().optional(),
-	wholeSeries: z.object({
-		eventSeriesId: z.string(),
-		pricing: wholeSeriesPricingSchema,
-		currency: z.string(),
-		enrollmentOpen: z.boolean()
-	}).nullable().optional()
+	acceptsPasses: z.boolean(),
+	acceptsMemberships: z.boolean()
 });
 /**
+* Zod schema for public event data.
+*
+* The booking scope discriminates: a `whole_series` record without complete
+* `run` facts is rejected, and a `single_occurrence` record never carries them.
+*/
+const publicEventSchema = z.union([publicEventBaseSchema.extend({
+	bookingScope: z.literal("single_occurrence"),
+	run: z.undefined().optional()
+}), publicEventBaseSchema.extend({
+	bookingScope: z.literal("whole_series"),
+	run: publicWholeSeriesRunSchema
+})]);
+/**
 * Schema for an array of public events
 */
 const publicEventsArraySchema = z.array(publicEventSchema);
 //#endregion
+//#region ../blocks/src/system/blocks/events/shared/runGrouping.ts
+function isWholeSeriesPublicEvent(event) {
+	return event.bookingScope === "whole_series";
+}
+/**
+* Group events into one entry per whole-series run.
+*
+* Single-occurrence events are ignored. Run order follows first appearance, so
+* a caller's sort survives the grouping, and an occurrence that arrives twice
+* is kept once.
+*/
+function groupPublicEventsByRun(events) {
+	const occurrencesBySeriesId = /* @__PURE__ */ new Map();
+	const order = [];
+	const seenOccurrenceIds = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (!isWholeSeriesPublicEvent(event)) continue;
+		if (seenOccurrenceIds.has(event.occurrenceId)) continue;
+		seenOccurrenceIds.add(event.occurrenceId);
+		const seriesId = event.run.eventSeriesId;
+		const existing = occurrencesBySeriesId.get(seriesId);
+		if (existing) {
+			existing.push(event);
+			continue;
+		}
+		occurrencesBySeriesId.set(seriesId, [event]);
+		order.push(seriesId);
+	}
+	return order.map((eventSeriesId) => {
+		const occurrences = occurrencesBySeriesId.get(eventSeriesId) ?? [];
+		const representative = occurrences[0];
+		if (!representative) throw new Error(`Run ${eventSeriesId} grouped without any occurrence`);
+		return {
+			eventSeriesId,
+			run: representative.run,
+			occurrences,
+			representative
+		};
+	});
+}
+//#endregion
 //#region ../blocks/src/system/blocks/events/shared/fields.ts
 /**
 * Shared card styling fields for event blocks
@@ -21675,7 +21689,7 @@ const eventDisplayFields = [
 	{
 		id: "showCapacity",
 		type: "boolean",
-		label: "Show available spots",
+		label: "Show available places",
 		description: "Display remaining capacity",
 		required: false,
 		defaultValue: true,
@@ -21906,7 +21920,9 @@ const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
 		"unsupportedSubject",
 		"invalidEventSeriesId",
 		"invalidEventSeriesBookingScope",
-		"invalidEventOfferingId"
+		"invalidEventOfferingId",
+		"invalidEventOfferingBookingScope",
+		"invalidEventOfferingCatalogue"
 	])
 });
 const eventRegistrationPageSurfaceSubjectSchema = z.unknown().transform((value, ctx) => {
@@ -21933,7 +21949,7 @@ function resolveEventRegistrationScope(context) {
 	if (context.subject?.kind === "eventOffering") return {
 		kind: "pageSurfaceOffering",
 		offeringId: context.subject.eventOfferingId,
-		seriesIds: context.subject.availableEventSeriesIds
+		seriesIds: context.subject.catalogueEventSeriesIds
 	};
 	if (context.subject?.kind === "unsupported") return {
 		kind: "unsupportedPageSurfaceSubject",
@@ -21955,31 +21971,12 @@ function resolveEventRegistrationScopedEvents(events, context) {
 	}
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/event-registration/registrationSurface.ts
-function planEventRegistrationScope(input) {
-	const subject = input.subject;
-	const selectedRunOffering = input.wholeSeriesOffering;
-	if (subject?.kind !== "eventOffering" || !selectedRunOffering) return {
-		kind: "context",
-		events: resolveEventRegistrationScopedEvents(input.events, {
-			occurrenceContext: input.occurrenceContext,
-			subject
-		})
-	};
-	if (!(selectedRunOffering.eventOfferingId === subject.eventOfferingId && subject.availableEventSeriesIds.some((seriesId) => seriesId === selectedRunOffering.eventSeriesId))) return { kind: "invalidSelectedRun" };
-	return {
-		kind: "selectedRun",
-		events: input.events.filter((event) => event.seriesId === selectedRunOffering.eventSeriesId),
-		offering: selectedRunOffering
-	};
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/destination.ts
-function isRecord$5(value) {
+//#region ../blocks/src/system/runtime/nodes/events/domain/destination.ts
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRuntimeEventDestination(value) {
-	if (!isRecord$5(value) || typeof value.kind !== "string") return false;
+	if (!isRecord$4(value) || typeof value.kind !== "string") return false;
 	if (value.kind === "native") return (value.mode === "cms-managed" || value.mode === "system-managed") && typeof value.path === "string";
 	return value.kind === "external" && typeof value.url === "string" && typeof value.label === "string";
 }
@@ -21992,174 +21989,6 @@ function resolveRuntimeEventDestination(event) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
-const DEFAULT_EVENT_CURRENCY = "USD";
-function resolveRuntimeEventPricing(event) {
-	if (isPublicEventPricing(event.pricing)) return event.pricing;
-	if (resolveRuntimeEventDestination(event).kind === "external") return {
-		kind: "external",
-		display: {
-			kind: "external",
-			label: "External registration"
-		}
-	};
-	const legacy = event;
-	const currency = readCurrency(legacy.currency);
-	if (event.requiresRegistration === false) return {
-		kind: "drop_in",
-		currency,
-		display: {
-			kind: "free",
-			currency
-		}
-	};
-	if (legacy.pricingMode === "ticket_types") return {
-		kind: "ticket_types",
-		currency,
-		ticketTypes: Array.isArray(legacy.ticketTypes) ? legacy.ticketTypes.filter(isPublicEventTicketType) : [],
-		display: readTicketTypePriceDisplay(legacy.priceDisplay, currency)
-	};
-	const amount = typeof legacy.price === "number" ? legacy.price : 0;
-	if (legacy.pricingType === "paid" && amount > 0) return {
-		kind: "single_paid",
-		amount,
-		currency,
-		display: {
-			kind: "exact",
-			amount,
-			currency
-		}
-	};
-	return {
-		kind: "free_registration",
-		currency,
-		display: {
-			kind: "free",
-			currency
-		}
-	};
-}
-function readCurrency(value) {
-	return typeof value === "string" && value.trim().length > 0 ? value : DEFAULT_EVENT_CURRENCY;
-}
-function isRecord$4(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPublicEventPricing(value) {
-	if (!isRecord$4(value) || typeof value.kind !== "string") return false;
-	return value.kind === "drop_in" || value.kind === "free_registration" || value.kind === "single_paid" || value.kind === "sliding_scale" || value.kind === "ticket_types" || value.kind === "whole_series" || value.kind === "external";
-}
-function isPublicEventTicketType(value) {
-	return isRecord$4(value) && typeof value.id === "string";
-}
-function readTicketTypePriceDisplay(value, currency) {
-	const display = readLegacyPriceDisplay(value, currency);
-	return display.kind === "whole_series" || display.kind === "external" ? {
-		kind: "unavailable",
-		currency
-	} : display;
-}
-function readLegacyPriceDisplay(value, currency) {
-	if (!isRecord$4(value) || typeof value.kind !== "string") return {
-		kind: "unavailable",
-		currency
-	};
-	const displayCurrency = readCurrency(value.currency);
-	switch (value.kind) {
-		case "free": return {
-			kind: "free",
-			currency: displayCurrency
-		};
-		case "exact": return readAmount(value.amount) !== null ? {
-			kind: "exact",
-			amount: readAmount(value.amount) ?? 0,
-			currency: displayCurrency
-		} : {
-			kind: "unavailable",
-			currency
-		};
-		case "from": return readAmount(value.amount) !== null ? {
-			kind: "from",
-			amount: readAmount(value.amount) ?? 0,
-			currency: displayCurrency
-		} : {
-			kind: "unavailable",
-			currency
-		};
-		case "range": {
-			const minAmount = readAmount(value.minAmount);
-			const maxAmount = readAmount(value.maxAmount);
-			return minAmount !== null && maxAmount !== null ? {
-				kind: "range",
-				minAmount,
-				maxAmount,
-				currency: displayCurrency
-			} : {
-				kind: "unavailable",
-				currency
-			};
-		}
-		case "mixed": return readAmount(value.paidFromAmount) !== null ? {
-			kind: "mixed",
-			paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
-			paidToAmount: readAmount(value.paidToAmount) ?? readAmount(value.paidFromAmount) ?? 0,
-			currency: displayCurrency
-		} : {
-			kind: "unavailable",
-			currency
-		};
-		case "unavailable": return {
-			kind: "unavailable",
-			currency: displayCurrency
-		};
-		case "whole_series": return isRecord$4(value.display) ? {
-			kind: "whole_series",
-			display: readCoursePriceDisplay(value.display, displayCurrency)
-		} : {
-			kind: "whole_series",
-			display: {
-				kind: "unavailable",
-				currency: displayCurrency
-			}
-		};
-		default: return {
-			kind: "unavailable",
-			currency
-		};
-	}
-}
-function readCoursePriceDisplay(value, currency) {
-	switch (value.kind) {
-		case "free": return {
-			kind: "free",
-			currency: readCurrency(value.currency)
-		};
-		case "exact": return readAmount(value.amount) !== null ? {
-			kind: "exact",
-			amount: readAmount(value.amount) ?? 0,
-			currency: readCurrency(value.currency)
-		} : {
-			kind: "unavailable",
-			currency
-		};
-		case "from": return readAmount(value.amount) !== null ? {
-			kind: "from",
-			amount: readAmount(value.amount) ?? 0,
-			currency: readCurrency(value.currency)
-		} : {
-			kind: "unavailable",
-			currency
-		};
-		default: return {
-			kind: "unavailable",
-			currency
-		};
-	}
-}
-function readAmount(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-//#endregion
 //#region ../blocks/src/system/constants/events.ts
 const eventCalendarDisplayModeValues = [
 	"combined",
@@ -22191,6 +22020,10 @@ const eventCalendarListLayoutOptions = [
 function isEventCalendarDisplayMode(value) {
 	return typeof value === "string" && eventCalendarDisplayModeValues.includes(value);
 }
+function normalizeEventCalendarDisplayMode$1(input) {
+	if (isEventCalendarDisplayMode(input.variant)) return input.variant;
+	return isEventCalendarDisplayMode(input.displayMode) ? input.displayMode : void 0;
+}
 function isEventCalendarDefaultView(value) {
 	return typeof value === "string" && eventCalendarDefaultViewValues.includes(value);
 }
@@ -22260,14 +22093,13 @@ 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(resolveRuntimeEventPricing(input.event)) === "paid";
+	return publicEventPricingType(input.event.pricing) === "paid";
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
 function toRegistrationEvent(event) {
 	return {
 		...event,
-		pricing: resolveRuntimeEventPricing(event),
 		selectionId: event.id,
 		registrationSubject: {
 			kind: "occurrence",
@@ -22278,118 +22110,35 @@ function toRegistrationEvent(event) {
 function toRegistrationEvents(events) {
 	return events.filter((event) => event.bookingScope === "single_occurrence").map(toRegistrationEvent);
 }
-function toWholeSeriesTicketType(option) {
-	return {
-		...option,
-		capacityMode: option.capacityLimit === null ? "unlimited" : "limited",
-		attendanceScope: option.attendanceScope ?? void 0,
-		availability: {
-			kind: "available",
-			remainingCapacity: option.capacityLimit
-		}
-	};
-}
-function toWholeSeriesPricing(offering) {
-	const resolved = resolveWholeSeriesPricingState(offering);
-	switch (offering.pricing.pricingStrategy) {
-		case "free": return {
-			kind: "free_registration",
-			currency: offering.currency,
-			display: {
-				kind: "free",
-				currency: offering.currency
-			}
-		};
-		case "single": {
-			const amount = offering.pricing.singlePriceAmount ?? 0;
-			return amount === 0 ? {
-				kind: "free_registration",
-				currency: offering.currency,
-				display: {
-					kind: "free",
-					currency: offering.currency
-				}
-			} : {
-				kind: "single_paid",
-				amount,
-				currency: offering.currency,
-				display: {
-					kind: "exact",
-					amount,
-					currency: offering.currency
-				}
-			};
-		}
-		case "tiered": return {
-			kind: "ticket_types",
-			currency: offering.currency,
-			ticketTypes: resolved.selectableOptions.map((option) => toWholeSeriesTicketType(option)),
-			display: resolved.display
-		};
-		case "sliding_scale": return {
-			kind: "sliding_scale",
-			minAmount: offering.pricing.slidingMinAmount ?? 0,
-			maxAmount: offering.pricing.slidingMaxAmount ?? 0,
-			suggestedAmount: offering.pricing.slidingSuggestedAmount ?? null,
-			currency: offering.currency,
-			display: {
-				kind: "range",
-				minAmount: offering.pricing.slidingMinAmount ?? 0,
-				maxAmount: offering.pricing.slidingMaxAmount ?? 0,
-				currency: offering.currency
-			}
-		};
-	}
-}
-function toAttendanceModes(offering) {
-	return (offering.deliveryMode === "hybrid" ? ["in_person", "online"] : [offering.deliveryMode]).map((mode) => ({
-		mode,
-		capacity: offering.enrollmentCapacity,
-		registeredCount: offering.enrolledCount,
-		availableSpots: offering.availableSpots,
-		waitlistEnabled: offering.waitlistEnabled
-	}));
-}
-function toWholeSeriesRegistrationEvent(offering) {
-	const firstSession = offering.sessions[0];
-	const lastSession = offering.sessions[offering.sessions.length - 1];
+/**
+* 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 {
-		selectionId: offering.eventSeriesId,
+		...representative,
+		selectionId: run.eventSeriesId,
 		registrationSubject: {
 			kind: "wholeSeries",
-			eventSeriesId: offering.eventSeriesId,
-			sessions: offering.sessions
-		},
-		seriesId: offering.eventSeriesId,
-		title: offering.title,
-		startsAt: firstSession?.startsAt ?? "",
-		endsAt: lastSession?.endsAt ?? firstSession?.endsAt ?? "",
-		bookingAvailability: offering.enrollmentOpen ? { kind: "open" } : {
-			kind: "closed",
-			reason: "enrollment_closed"
-		},
-		deliveryMode: offering.deliveryMode,
-		attendanceModes: toAttendanceModes(offering),
-		capacity: offering.enrollmentCapacity,
-		registeredCount: offering.enrolledCount,
-		availableSpots: offering.availableSpots,
-		waitlistEnabled: offering.waitlistEnabled,
-		venue: offering.venue ? {
-			...offering.venue,
-			location: null
-		} : null,
-		eventCategory: null,
-		teamMembers: offering.teamMembers,
-		status: offering.status,
-		timeZone: firstSession?.timeZone ?? "UTC",
-		pricing: toWholeSeriesPricing(offering),
-		paymentTerms: offering.paymentTerms,
-		consent: offering.consent,
-		requireGuestDetails: offering.requireGuestDetails,
-		acceptsPasses: false,
-		acceptsMemberships: offering.acceptsMemberships
+			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.interactive.ts
 const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = [
@@ -22409,8 +22158,7 @@ const eventRegistrationHydrationSchemaShape = {
 	occurrenceContext: occurrenceContextSchema.optional(),
 	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
 	events: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
-	wholeSeriesOfferings: publicWholeSeriesOfferingsArraySchema.nullable().optional(),
-	wholeSeriesOffering: publicWholeSeriesOfferingSchema.nullable().optional(),
+	wholeSeriesRunEvents: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
 	maxTickets: z.string().optional(),
 	showVenue: z.boolean().optional(),
 	showCapacity: z.boolean().optional(),
@@ -22428,7 +22176,6 @@ const eventRegistrationSourceSchema = z.object({
 	portalToken: z.string().nullable().optional(),
 	previewToken: z.string().nullable().optional(),
 	...eventRegistrationHydrationSchemaShape,
-	subjectWholeSeriesOffering: publicWholeSeriesOfferingSchema.nullable().optional(),
 	className: z.string().nullable().optional(),
 	buttonText: z.string().nullable().optional(),
 	maxTickets: z.string().nullable().optional(),
@@ -22462,7 +22209,8 @@ z.object({
 	stage: previewStageSchema.optional()
 });
 function buildEventRegistrationDisplay(source) {
-	if (resolveWholeSeriesOffering(source)?.enrollmentOpen === false) return {
+	const selectedRun = resolveSelectedWholeSeriesRun(source);
+	if (selectedRun && (!selectedRun.run.enrollmentOpen || toWholeSeriesRegistrationEvent(selectedRun) === null)) return {
 		kind: "event-registration",
 		state: "registration-closed",
 		className: source.className ?? null,
@@ -22480,13 +22228,11 @@ function buildEventRegistrationDisplay(source) {
 		summaryButtonText: source.buttonText?.trim() || "Register"
 	};
 }
-function resolveWholeSeriesOffering(source) {
-	return source.wholeSeriesOffering ?? source.subjectWholeSeriesOffering ?? null;
-}
 function buildEventRegistrationShellStepLabels(source) {
-	const selectedOffering = resolveWholeSeriesOffering(source);
-	if (selectedOffering) {
-		const selectedEvent = toWholeSeriesRegistrationEvent(selectedOffering);
+	const selectedRun = resolveSelectedWholeSeriesRun(source);
+	if (selectedRun) {
+		const selectedEvent = toWholeSeriesRegistrationEvent(selectedRun);
+		if (!selectedEvent) return EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
 		return getWizardStepsForContext(true, resolveEventRequiresPayment({
 			eligibility: null,
 			selectedTicketType: null,
@@ -22507,16 +22253,31 @@ function buildEventRegistrationShellStepLabels(source) {
 	}) : false).map((step) => shellLabelForRegistrationStep(step, scopedEvents));
 }
 function scopeEventRegistrationEvents(source) {
-	return toRegistrationEvents(scopeEventRegistrationSourceEvents(source));
+	const scoped = scopeEventRegistrationSourceEvents(source);
+	return [...toRegistrationEvents(scoped), ...toWholeSeriesRegistrationEvents(scoped)];
 }
+/**
+* Every event this surface may register for, from both of its loads.
+*
+* The date page and the run read answer different questions and can name the
+* same occurrence, so the two lists are joined and any occurrence that arrives
+* twice is kept once, in the order the date page gave it.
+*/
 function scopeEventRegistrationSourceEvents(source) {
-	const scope = planEventRegistrationScope({
-		events: source.events ?? [],
-		wholeSeriesOffering: source.wholeSeriesOffering,
+	const byOccurrenceId = /* @__PURE__ */ new Map();
+	for (const event of [...source.events ?? [], ...source.wholeSeriesRunEvents ?? []]) if (!byOccurrenceId.has(event.occurrenceId)) byOccurrenceId.set(event.occurrenceId, event);
+	return resolveEventRegistrationScopedEvents([...byOccurrenceId.values()], {
 		occurrenceContext: source.occurrenceContext,
 		subject: source.subject
 	});
-	return scope.kind === "invalidSelectedRun" ? [] : [...scope.events];
+}
+/**
+* The one run this surface is registering for, when the scoped events describe
+* exactly one. More than one run means the visitor still has to choose.
+*/
+function resolveSelectedWholeSeriesRun(source) {
+	const runs = groupPublicEventsByRun(scopeEventRegistrationSourceEvents(source));
+	return runs.length === 1 ? runs[0] : null;
 }
 function shellLabelForRegistrationStep(step, events) {
 	switch (step) {
@@ -22556,8 +22317,6 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 				occurrenceContext: source.occurrenceContext ?? null,
 				subject: source.subject ?? null,
 				events,
-				wholeSeriesOfferings: source.wholeSeriesOfferings ?? null,
-				wholeSeriesOffering: resolveWholeSeriesOffering(source),
 				maxTickets: source.maxTickets ?? void 0,
 				showVenue: source.showVenue,
 				showCapacity: source.showCapacity,
@@ -22576,8 +22335,7 @@ function normalizeEventRegistrationEventInput(value) {
 	if (!isRecord$3(value)) return value;
 	return {
 		...value,
-		destination: resolveRuntimeEventDestination(value),
-		pricing: resolveRuntimeEventPricing(value)
+		destination: resolveRuntimeEventDestination(value)
 	};
 }
 function isRecord$3(value) {
@@ -22672,7 +22430,7 @@ const eventRegistrationBlockDefinition = {
 			{
 				id: "showCapacity",
 				type: "boolean",
-				label: "Show available spots",
+				label: "Show available places",
 				description: "Display remaining capacity",
 				required: false,
 				defaultValue: true,
@@ -22733,9 +22491,7 @@ const eventRegistrationBlockDefinition = {
 						fallback: false
 					} },
 					events: { $bind: { from: "data.events" } },
-					wholeSeriesOffering: { $bind: { from: "data.selectedRunOffering.offering" } },
-					subjectWholeSeriesOffering: { $bind: { from: "data.subjectWholeSeriesOffering.offering" } },
-					wholeSeriesOfferings: { $bind: { from: "data.wholeSeriesOfferings" } },
+					wholeSeriesRunEvents: { $bind: { from: "data.wholeSeriesRunEvents" } },
 					sitePasses: { $bind: { from: "data.sitePasses" } },
 					siteMemberships: { $bind: { from: "data.siteMemberships" } },
 					stage: { $bind: {
@@ -22749,9 +22505,7 @@ const eventRegistrationBlockDefinition = {
 	runtime: eventRegistrationBlockRuntime,
 	dataSchemas: {
 		events: publicEventsArraySchema.optional(),
-		selectedRunOffering: z.object({ offering: publicWholeSeriesOfferingSchema }).optional(),
-		subjectWholeSeriesOffering: z.object({ offering: publicWholeSeriesOfferingSchema }).optional(),
-		wholeSeriesOfferings: z.array(publicWholeSeriesOfferingSchema).optional(),
+		wholeSeriesRunEvents: publicEventsArraySchema.optional(),
 		sitePasses: publicPassProductCollectionSchema.optional(),
 		siteMemberships: publicMembershipProductCollectionSchema.optional(),
 		occurrenceContext: occurrenceContextSchema.optional()
@@ -22769,7 +22523,7 @@ const eventRegistrationBlockDefinition = {
 				readProfile: "registration",
 				seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
 				seriesIds: { $bind: {
-					from: "$root.subject.availableEventSeriesIds",
+					from: "$root.subject.catalogueEventSeriesIds",
 					transforms: [{ id: "value.csv" }]
 				} },
 				runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } },
@@ -22777,50 +22531,39 @@ const eventRegistrationBlockDefinition = {
 			},
 			mode: "server"
 		},
-		selectedRunOffering: {
-			endpoint: "getPublicWholeSeriesOffering",
-			params: {
-				siteId: { $bind: { from: "$root.siteId" } },
-				eventSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } },
-				stage: { $bind: {
-					from: "$root.previewStage",
-					fallback: "published"
-				} }
-			},
-			requiredParams: ["eventSeriesId"],
-			mode: "server"
-		},
-		subjectWholeSeriesOffering: {
-			endpoint: "getPublicWholeSeriesOffering",
+		/**
+		* The runs this page can register for, finished ones included.
+		*
+		* The `events` page above is date-bounded, so a run whose first session has
+		* passed contributes no rows to it and the surface would have nothing to
+		* render as closed. This asks for runs instead, and only on a page whose
+		* subject books whole runs. It is scoped exactly like the date page — same
+		* series, same run subroute — because scope and grain are separate
+		* questions. The two lists are joined by occurrence, so a run that appears
+		* in both is still one run.
+		*/
+		wholeSeriesRunEvents: {
+			endpoint: "listPublicEvents",
 			when: { $bind: {
 				from: "$root.subject.isWholeSeriesBooking",
 				fallback: false
 			} },
 			params: {
 				siteId: { $bind: { from: "$root.siteId" } },
-				eventSeriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
+				readIntent: "runs",
+				limit: "50",
 				stage: { $bind: {
 					from: "$root.previewStage",
 					fallback: "published"
-				} }
-			},
-			requiredParams: ["eventSeriesId"],
-			mode: "server"
-		},
-		wholeSeriesOfferings: {
-			endpoint: "listPublicWholeSeriesOfferings",
-			params: {
-				siteId: { $bind: { from: "$root.siteId" } },
-				eventSeriesIds: { $bind: {
-					from: "$root.subject.availableEventSeriesIds",
+				} },
+				readProfile: "registration",
+				seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
+				seriesIds: { $bind: {
+					from: "$root.subject.catalogueEventSeriesIds",
 					transforms: [{ id: "value.csv" }]
 				} },
-				stage: { $bind: {
-					from: "$root.previewStage",
-					fallback: "published"
-				} }
+				runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } }
 			},
-			requiredParams: ["eventSeriesIds"],
 			mode: "server"
 		},
 		sitePasses: {
@@ -23073,7 +22816,7 @@ const eventDetailsBlockDefinition = {
 			readProfile: "details",
 			seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
 			seriesIds: { $bind: {
-				from: "$root.subject.availableEventSeriesIds",
+				from: "$root.subject.catalogueEventSeriesIds",
 				transforms: [{ id: "value.csv" }]
 			} },
 			runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } },
@@ -23233,7 +22976,11 @@ const eventSpotlightBlockDefinition = {
 	} }
 };
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/utils.ts
+//#region ../blocks/src/system/runtime/nodes/events/shared/listingLayout.ts
+/**
+* Layout classes for event listing containers and cards. Presentation
+* plumbing rather than event domain logic, so it lives beside the components.
+*/
 /**
 * Column class mappings for grid layouts, derived from the canonical
 * responsive column ladder (see gridUserColumnLadder).
@@ -23317,6 +23064,93 @@ function resolveEventListPaginationAction(input) {
 	};
 }
 //#endregion
+//#region ../blocks/src/system/blocks/events/shared/calendarWindow.ts
+/** Runtime picker sentinels and bound loader IDs must describe the same query. */
+function normalizeCalendarFilterId(value) {
+	const id = value?.trim();
+	return !id || id === "all" ? void 0 : id;
+}
+const calendarMonthSchema = z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/).refine((month) => Number(month.slice(0, 4)) > 0, "Invalid calendar year");
+function calendarMonthDate(month) {
+	return {
+		year: Number(month.slice(0, 4)),
+		month: Number(month.slice(5, 7)),
+		day: 1
+	};
+}
+const monthNumber = (month) => {
+	const date = calendarMonthDate(month);
+	return date.year * 12 + date.month - 1;
+};
+const calendarMonthWindowSchema = z.object({
+	startMonth: calendarMonthSchema,
+	endMonthExclusive: calendarMonthSchema
+}).refine((window) => {
+	const width = monthNumber(window.endMonthExclusive) - monthNumber(window.startMonth);
+	return width > 0 && width <= 3;
+}, "Calendar windows must cover one to three months");
+z.object({
+	startMonth: calendarMonthSchema.optional(),
+	endMonthExclusive: calendarMonthSchema.optional(),
+	afterStartsAt: z.string().datetime({ offset: true }).optional(),
+	afterId: z.string().uuid().optional(),
+	limit: z.coerce.number().int().min(1).max(200).default(100),
+	stage: z.enum(["published", "preview"]).default("published"),
+	readProfile: z.enum(["listing-card", "timetable"]).optional(),
+	eventSurface: z.enum(eventSurfaceScopeValues).optional(),
+	eventPresets: z.string().optional(),
+	scheduleScope: z.enum(eventScheduleScopeValues).optional(),
+	categoryIds: z.string().optional(),
+	venueId: z.string().transform(normalizeCalendarFilterId).optional(),
+	staffMemberId: z.string().transform(normalizeCalendarFilterId).optional()
+}).superRefine((query, ctx) => {
+	if (Boolean(query.startMonth) !== Boolean(query.endMonthExclusive)) ctx.addIssue({
+		code: "custom",
+		message: "Both month bounds are required"
+	});
+	if (query.startMonth && query.endMonthExclusive && !calendarMonthWindowSchema.safeParse(query).success) ctx.addIssue({
+		code: "custom",
+		message: "Invalid calendar window"
+	});
+	if (Boolean(query.afterStartsAt) !== Boolean(query.afterId)) ctx.addIssue({
+		code: "custom",
+		message: "Both cursor fields are required"
+	});
+	if (query.afterStartsAt && !query.startMonth) ctx.addIssue({
+		code: "custom",
+		message: "A continuation requires explicit month bounds"
+	});
+});
+const calendarSourceCursorSchema = z.object({
+	startsAt: z.string().datetime({ offset: true }),
+	occurrenceId: z.string().uuid()
+});
+z.discriminatedUnion("kind", [z.object({ kind: z.literal("complete") }), z.object({
+	kind: z.literal("partial"),
+	nextCursor: calendarSourceCursorSchema
+})]);
+const pageFields = {
+	scope: z.object({
+		key: z.string(),
+		timeZone: z.string().transform(toBookingTimeZone)
+	}),
+	window: calendarMonthWindowSchema,
+	initialToday: z.object({
+		year: z.number().int(),
+		month: z.number().int().min(1).max(12),
+		day: z.number().int().min(1).max(31)
+	}),
+	events: z.array(publicEventSchema)
+};
+const calendarWindowPageSchema = z.discriminatedUnion("kind", [z.object({
+	...pageFields,
+	kind: z.literal("complete")
+}), z.object({
+	...pageFields,
+	kind: z.literal("partial"),
+	nextCursor: calendarSourceCursorSchema
+})]);
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/events/shared/eventCollectionContract.ts
 const eventSurfaceScopeSchema$1 = z.enum(eventSurfaceScopeValues);
 const eventScheduleScopeSchema$1 = z.enum(eventScheduleScopeValues);
@@ -23333,6 +23167,7 @@ const eventCollectionFilterSourceSchemaShape = {
 	filterVenueId: z.string().nullable().optional()
 };
 const eventCollectionSourceSchemaShape = {
+	calendarWindow: calendarWindowPageSchema.nullable().optional(),
 	events: z.array(publicEventSchema).nullable().optional(),
 	siteId: z.string(),
 	apiBaseUrl: z.string().optional(),
@@ -23386,6 +23221,7 @@ const eventCollectionDisplaySchemaShape = {
 };
 const eventCollectionHydrationSchema = z.object({
 	siteId: z.string(),
+	calendarWindow: calendarWindowPageSchema.optional(),
 	stage: previewStageSchema.optional(),
 	prefetchedEvents: z.boolean(),
 	eventSurface: eventSurfaceScopeSchema$1,
@@ -23444,8 +23280,9 @@ function buildEventCollectionPresentationDisplay(source) {
 	};
 }
 function buildEventCollectionHydration(source, now = /* @__PURE__ */ new Date()) {
-	const timeZone = toBookingTimeZone(source.bookingTimeZone);
+	const timeZone = source.calendarWindow?.scope.timeZone ?? toBookingTimeZone(source.bookingTimeZone);
 	return {
+		calendarWindow: source.calendarWindow ?? void 0,
 		siteId: source.siteId,
 		stage: source.stage,
 		prefetchedEvents: source.events != null,
@@ -23454,7 +23291,7 @@ function buildEventCollectionHydration(source, now = /* @__PURE__ */ new Date())
 		scheduleScope: normalizeEventScheduleScope(source.scheduleScope),
 		calendarContext: {
 			timeZone,
-			initialToday: getLocalScheduleDate(now, timeZone)
+			initialToday: source.calendarWindow?.initialToday ?? getLocalScheduleDate(now, timeZone)
 		}
 	};
 }
@@ -24003,7 +23840,7 @@ function buildEventCalendarDisplay(source) {
 			listColumns: source.listColumns ?? source.columns
 		}),
 		kind: "event-calendar",
-		displayMode: source.variant ?? source.displayMode ?? "combined",
+		displayMode: normalizeEventCalendarDisplayMode$1(source) ?? "combined",
 		className: source.className ?? null,
 		events: (source.events ?? []).slice().sort((left, right) => new Date(left.startsAt).getTime() - new Date(right.startsAt).getTime()),
 		boardTitle: normalizeOptionalText(source.boardTitle),
@@ -24021,15 +23858,75 @@ const eventCalendarBlockRuntime = defineProgressiveBlockRuntime({
 		render: createZodCodec(eventCalendarRenderSchema)
 	},
 	buildRender: (source) => ({
-		display: buildEventCalendarDisplay(source),
+		display: buildEventCalendarDisplay(source.calendarWindow && (source.variant ?? source.displayMode ?? "combined") !== "combined" && (source.variant ?? source.displayMode) !== "list" ? {
+			...source,
+			events: source.calendarWindow.events
+		} : source),
 		hydration: buildEventCollectionHydration(source)
 	})
 });
 //#endregion
+//#region ../blocks/src/system/blocks/events/eventCalendarDataLoaders.ts
+const scopeParams = {
+	siteId: { $bind: { from: "$root.siteId" } },
+	stage: { $bind: {
+		from: "$root.previewStage",
+		fallback: "published"
+	} },
+	eventSurface: { $bind: { from: "content.eventSurface" } },
+	eventPresets: { $bind: {
+		from: "content.filterEventPresets",
+		transforms: [{ id: "value.csv" }]
+	} },
+	scheduleScope: { $bind: { from: "content.scheduleScope" } },
+	categoryIds: { $bind: { from: "content.filterCategoryIds" } },
+	staffMemberId: { $bind: { from: "content.filterStaffMemberId" } },
+	venueId: { $bind: { from: "content.filterVenueId" } }
+};
+/** Combined renders two jobs; calendar-only variants never pay for the list seed. */
+const eventCalendarDataLoaders = {
+	events: {
+		endpoint: "listPublicEvents",
+		when: { $bind: {
+			from: "content",
+			transforms: [{
+				id: "events.calendarReadEnabled",
+				options: { job: "list" }
+			}]
+		} },
+		params: {
+			...scopeParams,
+			limit: 100,
+			detailLevel: "listing",
+			readProfile: "listing-card"
+		},
+		mode: "server"
+	},
+	calendarWindow: {
+		endpoint: "listPublicEventCalendarWindow",
+		when: { $bind: {
+			from: "content",
+			transforms: [{
+				id: "events.calendarReadEnabled",
+				options: { job: "calendar" }
+			}]
+		} },
+		params: {
+			...scopeParams,
+			limit: 100,
+			readProfile: { $bind: {
+				from: "content",
+				transforms: [{ id: "events.calendarReadProfile" }]
+			} }
+		},
+		mode: "server"
+	}
+};
+//#endregion
 //#region ../blocks/src/system/blocks/events/event-calendar.ts
 function normalizeEventCalendarContent(content) {
 	const record = typeof content === "object" && content !== null ? content : {};
-	const variant = normalizeEventCalendarDisplayMode(record.variant) ?? normalizeEventCalendarDisplayMode(record.displayMode);
+	const variant = normalizeEventCalendarDisplayMode$1(record);
 	return {
 		...record,
 		...variant ? { variant } : {},
@@ -24077,6 +23974,7 @@ const eventCalendarLayout = [styledSection({
 		rootProps: { gap: "lg" },
 		children: [...eventSectionHeaderLayoutNodes({ splitClassName: "event-section-head event-section-head--split" }), el("event-calendar", withApiBindings({
 			events: { $bind: { from: "data.events" } },
+			calendarWindow: { $bind: { from: "data.calendarWindow" } },
 			stage: { $bind: {
 				from: "$root.previewStage",
 				fallback: "published"
@@ -24565,7 +24463,7 @@ const eventCalendarAdditionalFields = [
 	{
 		id: "showCapacity",
 		type: "boolean",
-		label: "Show available spots",
+		label: "Show available places",
 		description: "Display remaining capacity on event cards and timetable cells",
 		required: false,
 		defaultValue: true,
@@ -24900,33 +24798,11 @@ const eventCalendarBlockDefinition = {
 		}
 	}, eventCalendarContentShape),
 	normalizeContent: normalizeEventCalendarContent,
-	dataSchemas: { events: publicEventsArraySchema.optional() },
-	dataLoaders: { events: {
-		endpoint: "listPublicEvents",
-		params: {
-			siteId: { $bind: { from: "$root.siteId" } },
-			limit: 100,
-			stage: { $bind: {
-				from: "$root.previewStage",
-				fallback: "published"
-			} },
-			detailLevel: "listing",
-			readProfile: { $bind: {
-				from: "content.variant",
-				fallback: "listing-card"
-			} },
-			eventSurface: { $bind: { from: "content.eventSurface" } },
-			eventPresets: { $bind: {
-				from: "content.filterEventPresets",
-				transforms: [{ id: "value.csv" }]
-			} },
-			scheduleScope: { $bind: { from: "content.scheduleScope" } },
-			categoryIds: { $bind: { from: "content.filterCategoryIds" } },
-			staffMemberId: { $bind: { from: "content.filterStaffMemberId" } },
-			venueId: { $bind: { from: "content.filterVenueId" } }
-		},
-		mode: "server"
-	} },
+	dataSchemas: {
+		events: publicEventsArraySchema.optional(),
+		calendarWindow: calendarWindowPageSchema.optional()
+	},
+	dataLoaders: eventCalendarDataLoaders,
 	runtime: eventCalendarBlockRuntime
 };
 const recurringScheduleWeekdaySchema = z.enum([
@@ -25316,6 +25192,12 @@ function isRecord$2(value) {
 }
 //#endregion
 //#region ../blocks/src/system/blocks/offerings-preview/index.ts
+/**
+* The whole-series presets, as the CSV `listPublicEvents` expects. Both
+* whole-series presets share one loader: the block renders them as a single
+* run group.
+*/
+const WHOLE_SERIES_EVENT_PRESETS_PARAM = WHOLE_SERIES_EVENT_PRESET_VALUES.join(",");
 const publicRouteCandidatesSchema = z.object({ routes: z.array(z.object({
 	entityId: z.string(),
 	path: z.string(),
@@ -25597,7 +25479,7 @@ const offeringsPreviewManifest = createBlockManifest({
 					fallback: "published"
 				} },
 				routeCandidates: { $bind: { from: "data.routeCandidates" } },
-				wholeSeriesOfferings: { $bind: { from: "data.wholeSeriesOfferings" } },
+				wholeSeriesRunEvents: { $bind: { from: "data.wholeSeriesRunEvents" } },
 				...offeringsPreviewEventDataBindings
 			})
 		], { gap: "lg" }),
@@ -25614,7 +25496,7 @@ const offeringsPreviewBlockDefinition = {
 	dataSchemas: {
 		...offeringsPreviewEventDataSchemas,
 		routeCandidates: publicRouteCandidatesSchema.optional(),
-		wholeSeriesOfferings: publicWholeSeriesOfferingsArraySchema.optional()
+		wholeSeriesRunEvents: optionalPublicEventsArraySchema
 	},
 	dataLoaders: {
 		...offeringsPreviewEventDataLoaders,
@@ -25623,24 +25505,21 @@ const offeringsPreviewBlockDefinition = {
 			params: {},
 			mode: "server"
 		},
-		wholeSeriesOfferings: {
-			endpoint: "listPublicWholeSeriesOfferings",
-			params: {
-				siteId: { $bind: { from: "$root.siteId" } },
-				limit: { $bind: {
-					from: "content.itemLimit",
-					fallback: "3"
-				} },
-				stage: { $bind: {
-					from: "$root.previewStage",
-					fallback: "published"
-				} }
-			},
-			mode: "server"
-		}
+		wholeSeriesRunEvents: wholeSeriesRunLoader()
 	}
 };
-function eventPresetLoader(preset) {
+/**
+* One row per whole-series run, finished runs included.
+*
+* A page of dates cannot answer this: a finished run has no upcoming date, and
+* a long run would spend the whole page on its own sessions. `readIntent:
+* 'runs'` asks for runs instead, so `itemLimit` counts run cards rather than
+* dates, and each card arrives with the run's complete schedule.
+*/
+function wholeSeriesRunLoader() {
+	return eventPresetLoader(WHOLE_SERIES_EVENT_PRESETS_PARAM, { readIntent: "runs" });
+}
+function eventPresetLoader(eventPresets, extraParams = {}) {
 	return {
 		endpoint: "listPublicEvents",
 		params: {
@@ -25655,7 +25534,8 @@ function eventPresetLoader(preset) {
 			} },
 			detailLevel: "listing",
 			readProfile: "listing-card",
-			eventPresets: preset
+			eventPresets,
+			...extraParams
 		},
 		mode: "server"
 	};