@riverbankcms/sdk 0.136.0 → 0.137.0

package/dist/server/next.mjs

@@ -2179,6 +2179,83 @@ const SDK_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 		errors: ["validation:invalid_input", "server:internal_error"]
 	}
 });
+//#endregion
+//#region ../api/src/sdkMediaEndpointDefinitions.ts
+const SDK_MEDIA_ENDPOINT_DEFINITIONS = {
+	sdkMediaExists: {
+		path: "/sdk/{siteId}/media/exists",
+		method: "POST",
+		errors: ["validation:invalid_input"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaFindByChecksum: {
+		path: "/sdk/{siteId}/media/find-by-checksum",
+		method: "POST",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaResolve: {
+		path: "/sdk/{siteId}/media/resolve",
+		method: "POST",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaList: {
+		path: "/sdk/{siteId}/media",
+		method: "GET",
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaDownload: {
+		path: "/sdk/{siteId}/media/{identifier}/download",
+		method: "GET",
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaDeletePreview: {
+		path: "/sdk/{siteId}/media/{identifier}/delete-preview",
+		method: "POST",
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaDeleteApply: {
+		path: "/sdk/{siteId}/media/{identifier}",
+		method: "DELETE",
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaUploadUrl: {
+		path: "/sdk/{siteId}/media/upload-url",
+		method: "POST",
+		errors: [
+			"resource:not_found",
+			"validation:invalid_input",
+			"resource:conflict",
+			"validation:payload_too_large",
+			"billing:plan_limit_exceeded",
+			"server:internal_error"
+		],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkMediaUploadFinalize: {
+		path: "/sdk/{siteId}/media/upload",
+		method: "POST",
+		errors: [
+			"resource:not_found",
+			"validation:invalid_input",
+			"resource:conflict",
+			"validation:payload_too_large",
+			"billing:plan_limit_exceeded",
+			"server:internal_error"
+		],
+		auth: "service",
+		responseKind: "json"
+	}
+};
 const API_ENDPOINTS$1 = {
 	...ACCOUNT_ENDPOINT_DEFINITIONS,
 	...PUBLIC_EVENT_ENDPOINT_DEFINITIONS,
@@ -4319,26 +4396,6 @@ const API_ENDPOINTS$1 = {
 		auth: "public",
 		responseKind: "json"
 	},
-	createTheme: {
-		path: "/ai/chat/create-theme",
-		method: "POST",
-		revalidate: 60,
-		tags: ["theme", "ai-theme"],
-		auth: "user",
-		responseKind: "json"
-	},
-	generateThemes: {
-		path: "/theme/generate",
-		method: "POST",
-		errors: [
-			"validation:invalid_input",
-			"resource:not_found",
-			"server:internal_error"
-		],
-		tags: ["theme"],
-		auth: "user",
-		responseKind: "json"
-	},
 	extractThemeFromInspiration: {
 		path: "/theme/extract-from-inspiration",
 		method: "POST",
@@ -4512,7 +4569,7 @@ const API_ENDPOINTS$1 = {
 		method: "DELETE",
 		tags: ["media", "media-{assetId}"],
 		auth: "user",
-		responseKind: "void"
+		responseKind: "json"
 	},
 	mediaBulkDelete: {
 		path: "/media/bulk-delete",
@@ -7098,42 +7155,13 @@ const API_ENDPOINTS$1 = {
 		auth: "user",
 		responseKind: "json"
 	},
+	...SDK_MEDIA_ENDPOINT_DEFINITIONS,
 	sdkIdentifiersBackfill: {
 		path: "/sdk/{siteId}/identifiers/backfill",
 		method: "POST",
 		auth: "service",
 		responseKind: "json"
 	},
-	sdkMediaExists: {
-		path: "/sdk/{siteId}/media/exists",
-		method: "POST",
-		auth: "service",
-		responseKind: "json"
-	},
-	sdkMediaFindByChecksum: {
-		path: "/sdk/{siteId}/media/find-by-checksum",
-		method: "POST",
-		auth: "service",
-		responseKind: "json"
-	},
-	sdkMediaResolve: {
-		path: "/sdk/{siteId}/media/resolve",
-		method: "POST",
-		auth: "service",
-		responseKind: "json"
-	},
-	sdkMediaUploadUrl: {
-		path: "/sdk/{siteId}/media/upload-url",
-		method: "POST",
-		auth: "service",
-		responseKind: "json"
-	},
-	sdkMediaUploadFinalize: {
-		path: "/sdk/{siteId}/media/upload",
-		method: "POST",
-		auth: "service",
-		responseKind: "json"
-	},
 	sdkUpdateWorkflowRunStatus: {
 		path: "/sdk/{siteId}/workflows/runs/{runId}/status",
 		method: "POST",
@@ -16987,6 +17015,11 @@ const gradientConfigSchema = z$1.object({
 	position: z$1.string().optional(),
 	stops: z$1.array(gradientStopSchema).min(2)
 });
+const gradientsSchema = z$1.object({
+	button: z$1.string().min(1).nullable().optional(),
+	hero: z$1.string().min(1).nullable().optional(),
+	background: z$1.string().min(1).nullable().optional()
+});
 //#endregion
 //#region ../theme-core/src/interactive/baseSchema.ts
 /**
@@ -17987,11 +18020,30 @@ const headerContainerSchema = z$1.object({
 	tint: z$1.string().nullable().optional(),
 	opacity: z$1.number().min(0).max(1).default(.12)
 }).optional();
-const headerInteractionPaletteSchema = z$1.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$1.enum(headerInteractionPaletteValues);
 //#endregion
 //#region ../theme-core/src/boxBackgroundSchema.ts
 const boxBackgroundOverlaySchema = z$1.preprocess(normalizeAuthoringOpacity, z$1.discriminatedUnion("type", [
@@ -18373,11 +18425,12 @@ const inputStyle = z$1.object({
 	]),
 	label: z$1.enum(["inside", "above"])
 });
-const headerPositioning = z$1.enum([
+const headerPositioningValues = [
 	"static",
 	"sticky",
 	"fixed"
-]);
+];
+const headerPositioning = z$1.enum(headerPositioningValues);
 const headerNavStyle = z$1.enum([
 	"minimal",
 	"underline",
@@ -18512,7 +18565,7 @@ const headerSchema = z$1.object({
 	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z$1.boolean(),
-	maxWidth: headerMaxWidth,
+	maxWidth: headerMaxWidth.default("container"),
 	scrollTreatment: headerScrollTreatmentSchema,
 	background: headerBackgroundSchema.default({
 		type: "color",
@@ -18711,11 +18764,6 @@ const bodyTextSchema = z$1.object({ intro: z$1.object({
 	paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
 	headingSize: bodyTextIntroTypographySizeSchema.optional()
 }).optional() }).optional();
-const gradientsSchema = z$1.object({
-	button: z$1.string().min(1).nullable().optional(),
-	hero: z$1.string().min(1).nullable().optional(),
-	background: z$1.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
@@ -21759,12 +21807,12 @@ function allGroupChildPlans(plan) {
 }
 function selectedGroupChildPlans(plan, value) {
 	if (plan.childSelection.kind === "all") return plan.childSelection.fields;
-	if (!isPlainObject$6(value)) return [];
+	if (!isPlainObject$7(value)) return [];
 	const selectedType = value[plan.childSelection.activeTabField];
 	return plan.childSelection.tabs.find((tab) => tab.typeId === selectedType)?.fields ?? [];
 }
 function canonicalizeObjectForWrite(plans, value) {
-	if (!isPlainObject$6(value)) return value;
+	if (!isPlainObject$7(value)) return value;
 	const canonical = { ...value };
 	for (const plan of plans) {
 		if (!(plan.fieldId in canonical)) continue;
@@ -21788,7 +21836,7 @@ function canonicalizeFieldValue(plan, value) {
 	}
 }
 function canonicalizeMedia(value) {
-	if (!isPlainObject$6(value)) return value;
+	if (!isPlainObject$7(value)) return value;
 	const canonical = { ...value };
 	if (mediaIdentifierSchema.safeParse(canonical.identifier).success) deleteEnvSpecificKeys(canonical);
 	return canonical;
@@ -21796,13 +21844,13 @@ function canonicalizeMedia(value) {
 function canonicalizeRepeater(plan, value) {
 	if (!isUnknownArray$3(value)) return value;
 	return value.map((item) => {
-		if (!isPlainObject$6(item)) return item;
+		if (!isPlainObject$7(item)) return item;
 		const childPlans = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
 		return childPlans ? canonicalizeObjectForWrite(childPlans, item) : item;
 	});
 }
 function canonicalizeDiscriminatedGroup(plan, value) {
-	if (!isPlainObject$6(value) || plan.childSelection.kind !== "discriminatedTabs") return value;
+	if (!isPlainObject$7(value) || plan.childSelection.kind !== "discriminatedTabs") return value;
 	const selection = plan.childSelection;
 	const selectedPlans = selectedGroupChildPlans(plan, value);
 	const selectedIds = rootFieldIds(selectedPlans);
@@ -21817,10 +21865,10 @@ function rootFieldIds(plans) {
 }
 function omitUndefined(value) {
 	if (isUnknownArray$3(value)) return value.map(omitUndefined);
-	if (!isPlainObject$6(value)) return value;
+	if (!isPlainObject$7(value)) return value;
 	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0).map(([key, field]) => [key, omitUndefined(field)]));
 }
-function isPlainObject$6(value) {
+function isPlainObject$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isUnknownArray$3(value) {
@@ -22216,7 +22264,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$5(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 isPlainObject$6(value) && mediaIdentifierSchema.safeParse(value.identifier).success && (value.type === void 0 || typeof value.type === "string" && plan.allowedMediaTypes.includes(value.type)) ? [] : [issue(plan, "invalidMedia")];
 		case "link": return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
 		case "repeater": return validateRepeaterPlan(plan, value, ctx);
 		case "group": return validateGroupPlan(plan, value, ctx);
@@ -22309,7 +22357,7 @@ function validateRepeaterPlan(plan, value, ctx) {
 	}), ...value.flatMap((item, index) => validateRepeaterItem(plan, item, index, ctx))];
 }
 function validateRepeaterItem(plan, item, index, ctx) {
-	if (!isPlainObject$5(item)) return [{
+	if (!isPlainObject$6(item)) return [{
 		kind: "wrongType",
 		path: [...plan.path, index],
 		fieldId: plan.fieldId,
@@ -22335,7 +22383,7 @@ function validateRepeaterItem(plan, item, index, ctx) {
 	});
 }
 function validateGroupPlan(plan, value, ctx) {
-	if (!isPlainObject$5(value)) return [issue(plan, "wrongType", { expected: "an object" })];
+	if (!isPlainObject$6(value)) return [issue(plan, "wrongType", { expected: "an object" })];
 	if (plan.childSelection.kind === "discriminatedTabs") {
 		const selectedType = value[plan.childSelection.activeTabField];
 		if (selectedType !== void 0 && selectedType !== null && !plan.childSelection.tabs.some((tab) => tab.typeId === selectedType)) return [{
@@ -22638,7 +22686,7 @@ function isEmptyValue$1(value) {
 	if (isEmptyRichTextDoc(value)) return true;
 	return false;
 }
-function isPlainObject$5(value) {
+function isPlainObject$6(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isUnknownArray$2(value) {
@@ -22648,7 +22696,7 @@ function isValidRichTextDoc(value) {
 	return isRichTextDoc(value);
 }
 function isEmptyRichTextDoc(value) {
-	if (!isPlainObject$5(value)) return false;
+	if (!isPlainObject$6(value)) return false;
 	if (value.type !== "doc") return false;
 	const content = value.content;
 	if (!Array.isArray(content) || content.length === 0) return true;
@@ -22700,26 +22748,6 @@ function compileManifestContentContract(manifestOrFields) {
 		findNonPortableMediaPaths: (content) => findNonPortableMediaPaths(plans, content)
 	}) });
 }
-/** Strictly admits already-persisted content without repairing it. */
-function admitStoredManifestContent(contract, content) {
-	const state = contract[compiledManifestContentContract];
-	const nonPortablePaths = state.findNonPortableMediaPaths(content);
-	if (nonPortablePaths.length > 0) return {
-		ok: false,
-		error: {
-			kind: "non_portable_media",
-			paths: nonPortablePaths
-		}
-	};
-	const parsed = state.strictStoredSchema.safeParse(content);
-	return parsed.success ? {
-		ok: true,
-		value: content
-	} : {
-		ok: false,
-		error: zodAdmissionError(parsed.error)
-	};
-}
 /** Validates raw editor state without granting a stored-content proof. */
 function validateManifestDraft(contract, data) {
 	const parsed = contract[compiledManifestContentContract].draftSchema.safeParse(data);
@@ -22737,21 +22765,6 @@ function validateManifestDraft(contract, data) {
 	};
 }
 /**
-* Applies a pure runtime projection to admitted stored content and validates
-* the resulting render shape before granting the renderable proof.
-*/
-function deriveRenderableManifestContent(contract, stored, project) {
-	const projected = project(stored);
-	const parsed = contract[compiledManifestContentContract].renderSchema.safeParse(projected);
-	return parsed.success ? {
-		ok: true,
-		value: projected
-	} : {
-		ok: false,
-		error: zodAdmissionError(parsed.error)
-	};
-}
-/**
 * Re-admits renderable content after a transport boundary has erased its
 * compile-time proof. Unlike write admission, this never canonicalizes or
 * grants a stored proof, so hydrated media cannot flow back to persistence.
@@ -22907,6 +22920,23 @@ function defineLookOptionGroup(group) {
 	defaultOption(group);
 	return group;
 }
+function resolveLookOption(group, requestedOptionId) {
+	const fallback = defaultOption(group);
+	if (requestedOptionId === null || requestedOptionId === void 0) return {
+		kind: "defaulted",
+		option: fallback
+	};
+	const selected = group.options.find((option) => option.id === requestedOptionId);
+	return selected ? {
+		kind: "selected",
+		option: selected
+	} : {
+		kind: "repaired",
+		requestedOptionId,
+		option: fallback,
+		reason: "unsupported-option"
+	};
+}
 function defaultOption(group) {
 	const option = group.options.find((candidate) => candidate.id === group.defaultOptionId);
 	if (option) return option;
@@ -23797,6 +23827,12 @@ function cardRoleFromLegacyVocabulary(value) {
 */
 const cardRoleWithLegacyAliasSchema = z$1.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 {
@@ -26178,6 +26214,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"),
@@ -26327,9 +26369,50 @@ defineLookOptionGroup({
 		{
 			id: "secondary",
 			label: "Secondary"
+		},
+		{
+			id: headerInteractionQuietPalette,
+			label: "Text only"
 		}
 	]
 });
+/**
+* Key-sorted serialisation, because one side of the comparison is built here
+* and the other comes back out of `jsonb` in whatever order it was stored.
+* `JSON.stringify` alone reported two identical effect lists as different,
+* which is the same key-order trap the `logoText` derivation hit in Phase 4a.
+*/
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (typeof value === "object" && value !== null) return `{${Object.entries(value).filter(([, member]) => member !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, member]) => `${JSON.stringify(key)}:${canonicalJson(member)}`).join(",")}}`;
+	return value === void 0 ? "undefined" : JSON.stringify(value);
+}
+//#endregion
+//#region ../theme-core/src/site-styles/headerNavStyles.ts
+function applyNavTypography(style, typography) {
+	switch (typography) {
+		case "plain": return style;
+		case "heading": return {
+			...style,
+			typography: "heading",
+			fontWeight: "medium",
+			letterSpacing: "wide"
+		};
+		case "quiet-caps": return {
+			...style,
+			textTransform: "uppercase",
+			textSize: "sm",
+			letterSpacing: "wide"
+		};
+		case "brand-caps": return {
+			...style,
+			textTransform: "uppercase",
+			textSize: "sm",
+			letterSpacing: "wider"
+		};
+		default: return assertNever$19(typography, "Unhandled header nav typography");
+	}
+}
 function asFooterLookId(value) {
 	return value;
 }
@@ -27038,6 +27121,37 @@ function uniformSectionForeground(token) {
 		supportingColor: token
 	};
 }
+function compileTransitionRuntime(input) {
+	return {
+		treatment: input.treatment,
+		from: input.from,
+		to: input.to,
+		cssVars: {
+			from: transitionEndpointCssValue(input.from),
+			to: transitionEndpointCssValue(input.to)
+		}
+	};
+}
+function transitionEndpointCssValue(endpoint) {
+	switch (endpoint.kind) {
+		case "color-token": return themeColorTokenCssValue(endpoint.token);
+		case "surface": return themeColorTokenCssValue(tokenForTransitionSurface(endpoint.surface));
+		default: return assertNever$19(endpoint);
+	}
+}
+function tokenForTransitionSurface(surface) {
+	switch (surface) {
+		case "base":
+		case "hero-image": return "background";
+		case "muted-band": return "muted";
+		case "accent-band": return "accent";
+		case "brand-depth-band": return "primary-800";
+		default: return assertNever$19(surface);
+	}
+}
+function themeColorTokenCssValue(token) {
+	return `rgb(var(--tb-${token}))`;
+}
 //#endregion
 //#region ../theme-core/src/site-styles/curatedSiteStyles.ts
 const SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
@@ -28745,6 +28859,142 @@ 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"
+};
+/**
+* Applies the user's nav font-role/size overrides on top of a style-resolved
+* nav link style. This is where the precedence contract lands:
+*
+* - The nav typography TREATMENT (case/tracking identity: plain / heading /
+*   quiet-caps / brand-caps) is ALWAYS owned by the active header style and is
+*   baked into `style` before this call (see `applyNavTypography` in
+*   headerLayoutStyles.ts).
+* - Each treatment resolves through a DEFAULT font role: `heading` resolves
+*   through the heading role; `plain` / `quiet-caps` / `brand-caps` resolve
+*   through the body role.
+* - The user's `navFontRole` (surfaced here as `preferences.typography`) only
+*   overrides which font ROLE the treatment resolves through. It never changes
+*   the treatment. `'inherit'` keeps the treatment's default role.
+*/
+function mergeHeaderNavTypographyPreference(style, preferences) {
+	return preferences.typography === "inherit" && preferences.fontSize === "inherit" ? style : {
+		...style,
+		...preferences.typography === "inherit" ? {} : { typography: preferences.typography },
+		...preferences.fontSize === "inherit" ? {} : { textSize: preferences.fontSize }
+	};
+}
+function readHeaderNavFontSizePreference(value) {
+	return value === "sm" || value === "base" || value === "lg" || value === "xl" ? value : "inherit";
+}
+//#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"];
+/**
+* Key-order-safe structural equality over the persisted `logo` object.
+*
+* The persisted value comes back from `jsonb`, whose key order is not the order
+* the applier builds; a `JSON.stringify` comparison would read two equal logo
+* blocks as different and quietly classify a `'recommended'` row as
+* unrecognised — the same trap the interaction-palette transcription test
+* exists to catch.
+*/
+function jsonEquals(left, right) {
+	if (left === right) return true;
+	if (left === null || right === null) return false;
+	if (typeof left !== "object" || typeof right !== "object") return false;
+	if (Array.isArray(left) !== Array.isArray(right)) return false;
+	if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((value, index) => jsonEquals(value, right[index]));
+	const leftRecord = left;
+	const rightRecord = right;
+	const keys = /* @__PURE__ */ new Set([...Object.keys(leftRecord), ...Object.keys(rightRecord)]);
+	for (const key of keys) if (!jsonEquals(leftRecord[key], rightRecord[key])) return false;
+	return true;
+}
+defaultHeaderBrandPreferences.brandDisplay, defaultHeaderBrandPreferences.logoSize, defaultHeaderNavPreferences.typography, defaultHeaderNavPreferences.fontSize, defaultHeaderNavPreferences.interactionPalette;
+function retargetCompiledBoundaryRuntimeForContentAdjacency(boundary, adjacency) {
+	const fromSurface = contentOwnedBackgroundEndpoint(adjacency.currentContent) ?? boundary.from;
+	const toSurface = contentOwnedBackgroundEndpoint(adjacency.nextContent) ?? boundary.to;
+	if (fromSurface === boundary.from && toSurface === boundary.to) return boundary;
+	const transition = compileTransitionRuntime({
+		treatment: boundary.treatment,
+		from: fromSurface,
+		to: toSurface
+	});
+	return {
+		...boundary,
+		from: transition.from,
+		to: transition.to,
+		cssVars: transition.cssVars
+	};
+}
+function contentOwnedBackgroundEndpoint(content) {
+	const background = readRecord(readRecord(content?._sectionStyles)?.background);
+	if (background?.contentOwner !== "page-design-editor" || background.type !== "color") return null;
+	const token = parseThemeColorToken(background.color);
+	if (!token) return null;
+	return {
+		kind: "color-token",
+		token
+	};
+}
+function readRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+//#endregion
 //#region ../theme-core/src/site-styles/generatedSchemas.ts
 function uniqueNonEmpty(values) {
 	const uniqueValues = [...new Set(values)];
@@ -28813,6 +29063,76 @@ z$1.object({
 	blocks: z$1.array(generatedPageDesignBlockIntentSchema)
 }).strict();
 //#endregion
+//#region ../theme-core/src/site-styles/headerPreferencesPersistence.ts
+const backgroundColorTokenSchema = z$1.unknown().transform((value, ctx) => {
+	const token = parseSiteChromeBackgroundColorToken(value);
+	if (token === null) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Unknown site chrome background colour token"
+		});
+		return z$1.NEVER;
+	}
+	return token;
+});
+const backgroundOverrideSchema = z$1.discriminatedUnion("kind", [z$1.object({ kind: z$1.literal("default") }).strict(), z$1.object({
+	kind: z$1.literal("color"),
+	token: backgroundColorTokenSchema
+}).strict()]);
+const logoTextIntentSchema = z$1.object({
+	mobileMaxWidth: z$1.enum([
+		"xs",
+		"sm",
+		"md"
+	]).optional(),
+	mobileWrapLines: z$1.union([z$1.literal(1), z$1.literal(2)]).optional(),
+	hideOnShrink: z$1.boolean().optional()
+}).strict();
+const structureSchema = z$1.object({
+	positioning: z$1.union([z$1.literal("inherit"), z$1.enum(headerPositioningValues)]),
+	shrinkOnScroll: z$1.union([z$1.literal("inherit"), z$1.boolean()]),
+	logoText: z$1.union([
+		z$1.literal("inherit"),
+		z$1.literal("none"),
+		logoTextIntentSchema
+	])
+}).strict();
+const headerPreferencesShape = {
+	brandPresentation: z$1.enum(headerBrandPresentationValues),
+	brandDisplay: z$1.enum(brandDisplayModeValues),
+	logoSize: z$1.enum(logoSizePolicyValues),
+	navFontRole: z$1.enum(headerNavTypographyPreferenceValues),
+	navTextSize: z$1.enum(headerNavFontSizePreferenceValues),
+	interactionPalette: z$1.union([z$1.literal("recommended"), z$1.enum(headerInteractionPaletteValues)]),
+	background: backgroundOverrideSchema,
+	structure: structureSchema
+};
+z$1.object(headerPreferencesShape).strict();
+z$1.object(headerPreferencesShape).omit({
+	brandPresentation: true,
+	structure: true
+}).strict();
+//#endregion
+//#region ../theme-core/src/site-styles/headerBytesComparison.ts
+function isPlainObject$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Structural diff by JSON path. Values are compared through
+* `JSON.stringify`, so a key present with the value `undefined` and an absent
+* key read as the same thing — which is what `jsonb` does to them anyway
+* (#1318 Correction 5).
+*/
+function diffJsonPaths(left, right, path = "") {
+	if (isPlainObject$5(left) && isPlainObject$5(right)) return [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].sort().flatMap((key) => diffJsonPaths(left[key], right[key], path ? `${path}.${key}` : key));
+	if (JSON.stringify(left) === JSON.stringify(right)) return [];
+	return [{
+		path,
+		left,
+		right
+	}];
+}
+//#endregion
 //#region ../theme-core/src/site-styles/pageDesignAuthority.ts
 const nonEmptyStringSchema = z$1.string().min(1);
 const blockContentVersionIdSchema = nonEmptyStringSchema.transform(asBlockContentVersionId);
@@ -28914,46 +29234,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] : [];
-	});
-}
-/**
-* Applies the user's nav font-role/size overrides on top of a style-resolved
-* nav link style. This is where the precedence contract lands:
-*
-* - The nav typography TREATMENT (case/tracking identity: plain / heading /
-*   quiet-caps / brand-caps) is ALWAYS owned by the active header style and is
-*   baked into `style` before this call (see `applyNavTypography` in
-*   headerLayoutStyles.ts).
-* - Each treatment resolves through a DEFAULT font role: `heading` resolves
-*   through the heading role; `plain` / `quiet-caps` / `brand-caps` resolve
-*   through the body role.
-* - The user's `navFontRole` (surfaced here as `preferences.typography`) only
-*   overrides which font ROLE the treatment resolves through. It never changes
-*   the treatment. `'inherit'` keeps the treatment's default role.
-*/
-function mergeHeaderNavTypographyPreference(style, preferences) {
-	return preferences.typography === "inherit" && preferences.fontSize === "inherit" ? style : {
-		...style,
-		...preferences.typography === "inherit" ? {} : { typography: preferences.typography },
-		...preferences.fontSize === "inherit" ? {} : { textSize: preferences.fontSize }
-	};
-}
-function readHeaderNavFontSizePreference(value) {
-	return value === "sm" || value === "base" || value === "lg" || value === "xl" ? value : "inherit";
-}
-//#endregion
 //#region ../theme-core/src/site-styles/tokenRecipes.ts
 const themeTokenRecipeOptions = {
 	palette: [
@@ -40775,7 +41055,7 @@ const eventDisplayFields = [
 	{
 		id: "showCapacity",
 		type: "boolean",
-		label: "Show available spots",
+		label: "Show available places",
 		description: "Display remaining capacity",
 		required: false,
 		defaultValue: true,
@@ -41100,7 +41380,272 @@ function planEventRegistrationScope(input) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/destination.ts
+//#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
+	};
+	const available = event.availableSpots ?? event.capacity - event.registeredCount;
+	if (available <= 0) return {
+		available: 0,
+		isFull: true
+	};
+	return {
+		available,
+		isFull: false
+	};
+}
+/**
+* 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)
+	};
+	if (available <= lowCapacityThreshold(source.capacity)) return {
+		kind: "low",
+		remaining: available
+	};
+	return { kind: "open" };
+}
+/**
+* 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`;
+}
+/** Total capacity as copy ("12 places"), for detail surfaces that state the size of an event. */
+function formatTotalCapacity(capacity) {
+	if (capacity === null) return null;
+	return capacity === 1 ? "1 place" : `${capacity} places`;
+}
+function getEventAvailabilityStatus(event) {
+	const source = selectMostOpenCapacitySource(event);
+	const remaining = getRemainingPlaces(source);
+	const label = formatEventRemainingPlaces(event, { compact: true });
+	switch (remaining.kind) {
+		case "unlimited": return {
+			status: "available",
+			available: null,
+			isFull: false,
+			label
+		};
+		case "open": return {
+			status: "available",
+			available: getEventAvailability(source).available,
+			isFull: false,
+			label
+		};
+		case "low": return {
+			status: "filling",
+			available: remaining.remaining,
+			isFull: false,
+			label
+		};
+		case "full": return {
+			status: "waitlist",
+			available: 0,
+			isFull: true,
+			label
+		};
+	}
+}
+/**
+* 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);
+}
+/**
+* The capacity row a whole-event decision should read: the most open
+* attendance mode of a hybrid event, otherwise the aggregate. A hybrid event
+* is sold out only when both of its modes are, and its waitlist is reachable
+* when either full mode has one open.
+*/
+function selectMostOpenCapacitySource(event) {
+	const rows = findHybridModeRows(event);
+	if (!rows) return event;
+	return isMoreOpen(getRemainingPlaces(rows.online), getRemainingPlaces(rows.inPerson)) ? rows.online : rows.inPerson;
+}
+/** True when no attendance mode has room. Hybrid-aware; use this for sold-out decisions. */
+function isEventFull(event) {
+	return getEventAvailability(selectMostOpenCapacitySource(event)).isFull;
+}
+/**
+* True when the event is full on every mode and at least one of those full
+* modes has a waitlist open. An event with a mode still bookable is not a
+* waitlist prospect: it should send the visitor to that mode instead.
+*/
+function canJoinEventWaitlistOnAnyMode(event) {
+	return canJoinEventWaitlist(selectMostOpenCapacitySource(event));
+}
+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/events/domain/destination.ts
 function isRecord$23(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -41118,7 +41663,701 @@ function resolveRuntimeEventDestination(event) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
+//#region ../blocks/src/system/runtime/nodes/events/domain/cta.ts
+/**
+* Booking call-to-action resolution for events: where an event links to and
+* what the button says. Sold-out and waitlist decisions come from capacity.ts
+* so cards, rows and the wizard never disagree.
+*/
+function closedEventBookingLabel(reason) {
+	switch (reason) {
+		case "occurrence_cancelled":
+		case "series_cancelled": return "Cancelled";
+		case "occurrence_completed":
+		case "series_completed": return "Completed";
+		case "series_draft":
+		case "series_archived":
+		case "parent_archived":
+		case "parent_inconsistent":
+		case "not_public":
+		case "already_started":
+		case "enrollment_closed": return "Registration closed";
+		default: return assertNever$24(reason);
+	}
+}
+function resolveEventHref(event) {
+	const destination = resolveRuntimeEventDestination(event);
+	return destination.kind === "external" ? destination.url : destination.path;
+}
+function resolveEventLinkProps(event) {
+	const href = resolveEventHref(event);
+	return resolveRuntimeEventDestination(event).kind === "external" ? {
+		href,
+		target: "_blank",
+		rel: "noopener noreferrer"
+	} : { href };
+}
+/**
+* Resolve the CTA state for an event.
+* Shared by EventCard and EventCompactRow to keep sold-out, registration-closed,
+* and course-specific defaults consistent.
+*/
+function resolveEventCta(event, buttonText) {
+	const isSoldOut = isEventFull(event);
+	const destination = resolveRuntimeEventDestination(event);
+	const isExternal = destination.kind === "external";
+	const defaultButtonText = isExternal ? destination.label : event.bookingScope === "whole_series" ? "Book course" : "Book";
+	const effectiveButtonText = buttonText ?? defaultButtonText;
+	const href = resolveEventHref(event);
+	if (event.bookingAvailability.kind === "closed") {
+		const linksToClosedWholeSeriesDetails = event.bookingAvailability.reason === "enrollment_closed" && !isExternal;
+		return {
+			label: closedEventBookingLabel(event.bookingAvailability.reason),
+			href,
+			external: isExternal,
+			hidden: !linksToClosedWholeSeriesDetails
+		};
+	}
+	if (!isExternal && isSoldOut) {
+		if (canJoinEventWaitlistOnAnyMode(event)) return {
+			label: "Join waitlist",
+			href,
+			external: false,
+			hidden: false
+		};
+		return {
+			label: "Sold out",
+			href,
+			external: false,
+			hidden: true
+		};
+	}
+	return {
+		label: effectiveButtonText,
+		href,
+		external: isExternal,
+		hidden: false
+	};
+}
+//#endregion
+//#region ../calendar/src/grid.ts
+const DAY_NAMES = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+];
+const MONTH_NAMES = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+function formatDateKey(date) {
+	return `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`;
+}
+function isToday(date, today) {
+	return isSameCalendarDay(date, today);
+}
+function isSameCalendarDay(left, right) {
+	return left.year === right.year && left.month === right.month && left.day === right.day;
+}
+function addDays(date, days) {
+	const result = new Date(Date.UTC(date.year, date.month - 1, date.day + days, 12));
+	return {
+		year: result.getUTCFullYear(),
+		month: result.getUTCMonth() + 1,
+		day: result.getUTCDate()
+	};
+}
+function getMonthCalendarDays(year, month, startOfWeek) {
+	const firstDay = {
+		year,
+		month,
+		day: 1
+	};
+	const dayOfWeek = getDayOfWeek(firstDay);
+	const gridStart = addDays(firstDay, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
+	return Array.from({ length: 42 }, (_, index) => addDays(gridStart, index));
+}
+function getWeekCalendarDays(baseDate, startOfWeek) {
+	const dayOfWeek = getDayOfWeek(baseDate);
+	const weekStart = addDays(baseDate, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
+	return Array.from({ length: 7 }, (_, index) => addDays(weekStart, index));
+}
+function getDayOfWeek(date) {
+	return new Date(Date.UTC(date.year, date.month - 1, date.day, 12)).getUTCDay();
+}
+function getWeekCalendarDayTuple(baseDate, startOfWeek) {
+	const days = getWeekCalendarDays(baseDate, startOfWeek);
+	assertWeekCalendarDays(days);
+	return days;
+}
+function assertWeekCalendarDays(days) {
+	if (days.length !== 7) throw new Error("Expected exactly 7 calendar days");
+}
+function getOrderedDayNames(startOfWeek, dayNames = DAY_NAMES) {
+	if (startOfWeek === "monday") {
+		const sunday = dayNames[0] ?? "Sun";
+		return [...dayNames.slice(1), sunday];
+	}
+	return [...dayNames];
+}
+function formatCalendarTitle(viewDate, view, days, monthNames = MONTH_NAMES) {
+	if (view === "week") {
+		const weekStart = days[0];
+		const weekEnd = days[6];
+		if (weekStart === void 0 || weekEnd === void 0) return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
+		const startMonth = monthNames[weekStart.month - 1] ?? "";
+		const endMonth = monthNames[weekEnd.month - 1] ?? "";
+		if (weekStart.month === weekEnd.month) return `${startMonth} ${weekStart.day} - ${weekEnd.day}, ${weekEnd.year}`;
+		return `${startMonth} ${weekStart.day} - ${endMonth} ${weekEnd.day}, ${weekEnd.year}`;
+	}
+	return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
+}
+function buildCalendarViewport(input) {
+	const monthNames = input.monthNames ?? MONTH_NAMES;
+	if (input.view === "week") {
+		const days = getWeekCalendarDayTuple(input.anchorDate, input.startOfWeek);
+		return {
+			kind: "week",
+			anchorDate: input.anchorDate,
+			days,
+			title: formatCalendarTitle(input.anchorDate, "week", days, monthNames)
+		};
+	}
+	const days = getMonthCalendarDays(input.anchorDate.year, input.anchorDate.month, input.startOfWeek);
+	return {
+		kind: "month",
+		anchorDate: input.anchorDate,
+		days,
+		title: formatCalendarTitle(input.anchorDate, "month", days, monthNames)
+	};
+}
+//#endregion
+//#region ../calendar/src/lane-packing.ts
+/**
+* Assign lanes to a list of intervals.
+*
+* Returns one result per input in the same order as the input. Internally
+* sorts a copy by `(start, end, orderKey)` to ensure determinism, then
+* permutes results back to input order.
+*/
+function assignLanes(intervals) {
+	if (intervals.length === 0) return [];
+	const indexed = intervals.map((interval, index) => ({
+		interval,
+		index
+	}));
+	indexed.sort((left, right) => left.interval.start - right.interval.start || left.interval.end - right.interval.end || left.interval.orderKey.localeCompare(right.interval.orderKey));
+	const results = new Array(intervals.length);
+	let cluster = [];
+	let activeLaneEnds = [];
+	let clusterMaxEnd = -Infinity;
+	const closeCluster = () => {
+		if (cluster.length === 0) return;
+		const laneCount = Math.max(1, cluster.reduce((max, entry) => Math.max(max, entry.laneIndex + 1), 0));
+		for (const entry of cluster) results[entry.index] = {
+			laneIndex: entry.laneIndex,
+			laneCount
+		};
+		cluster = [];
+		activeLaneEnds = [];
+		clusterMaxEnd = -Infinity;
+	};
+	for (const { interval, index } of indexed) {
+		if (interval.start >= clusterMaxEnd) closeCluster();
+		const laneIndex = firstAvailableLane(activeLaneEnds, interval.start);
+		activeLaneEnds[laneIndex] = interval.end;
+		clusterMaxEnd = Math.max(clusterMaxEnd, interval.end);
+		cluster.push({
+			index,
+			laneIndex
+		});
+	}
+	closeCluster();
+	return results;
+}
+function firstAvailableLane(activeLaneEnds, start) {
+	const laneIndex = activeLaneEnds.findIndex((end) => end <= start);
+	return laneIndex >= 0 ? laneIndex : activeLaneEnds.length;
+}
+//#endregion
+//#region ../calendar/src/timezone.ts
+/**
+* Timezone boundary helpers — internal.
+*
+* Both functions read an ISO instant in a given IANA timezone and project it
+* onto the wall clock of that zone. They use Intl.DateTimeFormat with
+* hourCycle: 'h23' to avoid 12/24-hour ambiguity. Used internally by the
+* timetable model and `groupItemsByDate`; not exported from the package's
+* public surface.
+*/
+const MINUTES_PER_HOUR = 60;
+/**
+* Local minute-of-day [0, 24*60) for an ISO instant in the given zone.
+* Returns NaN if the inputs cannot be parsed (caller should drop the item).
+*/
+function getLocalMinuteOfDay(isoTimestamp, timeZone) {
+	const date = new Date(isoTimestamp);
+	if (Number.isNaN(date.getTime())) return NaN;
+	if (!isValidTimeZone(timeZone)) return NaN;
+	const parts = new Intl.DateTimeFormat("en-GB", {
+		timeZone,
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23"
+	}).formatToParts(date);
+	const hourPart = Number(parts.find((part) => part.type === "hour")?.value);
+	const minute = Number(parts.find((part) => part.type === "minute")?.value);
+	const hour = hourPart === 24 ? 0 : hourPart;
+	if (Number.isNaN(hour) || Number.isNaN(minute)) return NaN;
+	return hour * MINUTES_PER_HOUR + minute;
+}
+/**
+* Local YYYY-MM-DD for an ISO instant in the given zone.
+* Returns null if the inputs cannot be parsed.
+*/
+function getLocalDateKey(isoTimestamp, timeZone) {
+	const date = new Date(isoTimestamp);
+	if (Number.isNaN(date.getTime())) return null;
+	if (!isValidTimeZone(timeZone)) return null;
+	const parts = new Intl.DateTimeFormat("en-CA", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	}).formatToParts(date);
+	const year = parts.find((part) => part.type === "year")?.value;
+	const month = parts.find((part) => part.type === "month")?.value;
+	const day = parts.find((part) => part.type === "day")?.value;
+	if (year === void 0 || year.length === 0) return null;
+	if (month === void 0 || month.length === 0) return null;
+	if (day === void 0 || day.length === 0) return null;
+	return `${year}-${month}-${day}`;
+}
+const validTimeZoneCache = /* @__PURE__ */ new Map();
+function isValidTimeZone(timeZone) {
+	if (typeof timeZone !== "string" || timeZone.length === 0) return false;
+	const cached = validTimeZoneCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone });
+		validTimeZoneCache.set(timeZone, true);
+		return true;
+	} catch {
+		validTimeZoneCache.set(timeZone, false);
+		return false;
+	}
+}
+//#endregion
+//#region ../calendar/src/timetable.ts
+/**
+* Timetable model — the package's core surface.
+*
+* Generic over `T`. Takes a list of timed items + a viewport; returns a
+* day-by-day layout with overlap-packed lanes and percent-based positions
+* plus a diagnostics list for items dropped during processing.
+*
+* The function is pure: given identical input (including `now`), it returns
+* the same output. The model has no opinion on what an item is — pass
+* accessors.
+*/
+const DEFAULT_BOUNDS = {
+	minStartHour: 5,
+	maxEndHour: 23,
+	defaultStartHour: 6,
+	defaultEndHour: 21,
+	minHeightPercent: 2.5
+};
+function buildTimetableModel$1(input) {
+	const bounds = resolveBounds(input.bounds);
+	const viewportDays = getTimetableDays(input.viewDate, input.view ?? "week", input.startOfWeek);
+	const viewportKeys = new Set(viewportDays.map(formatDateKey));
+	const parsed = parseAllItems(input.items, input);
+	const inViewport = deriveVisibleSegments(parsed.drafts, viewportKeys);
+	const hourRange = resolveHourRange(inViewport, bounds);
+	const laid = layoutCellsByDate(inViewport, hourRange, bounds);
+	return {
+		days: assembleDays(viewportDays, laid.cellsByDate, input.today),
+		hourTicks: buildHourTicks(hourRange.startHour, hourRange.endHour),
+		startHour: hourRange.startHour,
+		endHour: hourRange.endHour,
+		rangeMinutes: (hourRange.endHour - hourRange.startHour) * 60,
+		hasItems: inViewport.length > 0,
+		diagnostics: [...parsed.diagnostics, ...laid.diagnostics]
+	};
+}
+function parseAllItems(items, accessors) {
+	const drafts = [];
+	const diagnostics = [];
+	for (const item of items) {
+		const result = parseDraft(item, accessors);
+		if (result.ok) drafts.push(result.draft);
+		else diagnostics.push({
+			item,
+			reason: result.reason
+		});
+	}
+	return {
+		drafts,
+		diagnostics
+	};
+}
+function layoutCellsByDate(segments, hourRange, bounds) {
+	const rangeMinutes = (hourRange.endHour - hourRange.startHour) * 60;
+	const rangeStartMinutes = hourRange.startHour * 60;
+	const rangeEndMinutes = hourRange.endHour * 60;
+	const segmentsByDate = groupSegmentsByDate(segments);
+	const cellsByDate = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	for (const [dateKey, daySegments] of segmentsByDate) {
+		const clipped = [];
+		for (const segment of daySegments) {
+			const result = clipDraft(segment, rangeStartMinutes, rangeEndMinutes);
+			if (result.ok) clipped.push(result.clipped);
+			else diagnostics.push({
+				item: segment.draft.item,
+				reason: result.reason
+			});
+		}
+		const laneResults = assignLanes(clipped.map((entry) => ({
+			start: entry.visibleStart,
+			end: entry.visibleEnd,
+			orderKey: entry.segment.draft.orderKey
+		})));
+		cellsByDate.set(dateKey, clipped.map((entry, idx) => buildCell(entry, laneResults[idx] ?? {
+			laneIndex: 0,
+			laneCount: 1
+		}, rangeStartMinutes, rangeMinutes, bounds.minHeightPercent)));
+	}
+	return {
+		cellsByDate,
+		diagnostics
+	};
+}
+function assembleDays(viewportDays, cellsByDate, today) {
+	return viewportDays.map((date) => {
+		const dateKey = formatDateKey(date);
+		return {
+			date,
+			dateKey,
+			isToday: isSameCalendarDay(date, today),
+			cells: cellsByDate.get(dateKey) ?? []
+		};
+	});
+}
+function parseDraft(item, accessors) {
+	const startsAtIso = accessors.getStartsAt(item);
+	const endsAtIso = accessors.getEndsAt(item);
+	const timeZone = accessors.getTimeZone(item);
+	const startsAtMinutes = getLocalMinuteOfDay(startsAtIso, timeZone);
+	if (Number.isNaN(startsAtMinutes)) return {
+		ok: false,
+		reason: "invalid-start"
+	};
+	const startDateKey = getLocalDateKey(startsAtIso, timeZone);
+	if (startDateKey == null) return {
+		ok: false,
+		reason: "invalid-timezone"
+	};
+	const endDateKey = getLocalDateKey(endsAtIso, timeZone);
+	if (endDateKey == null) return {
+		ok: false,
+		reason: "invalid-end"
+	};
+	const endsAtMinutesRaw = getLocalMinuteOfDay(endsAtIso, timeZone);
+	if (Number.isNaN(endsAtMinutesRaw)) return {
+		ok: false,
+		reason: "invalid-end"
+	};
+	const spansMultipleDays = startDateKey < endDateKey;
+	const endsAtMinutes = spansMultipleDays || endsAtMinutesRaw > startsAtMinutes ? endsAtMinutesRaw : Math.min(1440, startsAtMinutes + 60);
+	if (!spansMultipleDays && endsAtMinutes <= startsAtMinutes) return {
+		ok: false,
+		reason: "non-positive-duration"
+	};
+	return {
+		ok: true,
+		draft: {
+			item,
+			startDateKey,
+			endDateKey,
+			startsAtMinutes,
+			endsAtMinutes,
+			color: accessors.getColor?.(item) ?? null,
+			orderKey: accessors.getOrderKey?.(item) ?? accessors.getId(item)
+		}
+	};
+}
+function deriveVisibleSegments(drafts, viewportKeys) {
+	const segments = [];
+	for (const draft of drafts) for (const dateKey of enumerateDateKeys(draft.startDateKey, draft.endDateKey)) {
+		if (!viewportKeys.has(dateKey)) continue;
+		const isStartDay = dateKey === draft.startDateKey;
+		const isEndDay = dateKey === draft.endDateKey;
+		const startsAtMinutes = isStartDay ? draft.startsAtMinutes : 0;
+		const endsAtMinutes = isEndDay ? draft.endsAtMinutes : 1440;
+		if (endsAtMinutes <= startsAtMinutes) continue;
+		segments.push({
+			draft,
+			dateKey,
+			startsAtMinutes,
+			endsAtMinutes,
+			continuesBefore: !isStartDay,
+			continuesAfter: !isEndDay
+		});
+	}
+	return segments;
+}
+function clipDraft(segment, rangeStartMinutes, rangeEndMinutes) {
+	const visibleStart = Math.max(rangeStartMinutes, segment.startsAtMinutes);
+	const visibleEnd = Math.min(rangeEndMinutes, segment.endsAtMinutes);
+	if (visibleEnd <= visibleStart) return {
+		ok: false,
+		reason: "out-of-visible-hours"
+	};
+	return {
+		ok: true,
+		clipped: {
+			segment,
+			visibleStart,
+			visibleEnd
+		}
+	};
+}
+function buildCell(entry, lane, rangeStartMinutes, rangeMinutes, minHeightPercent) {
+	const heightPercent = Math.max(minHeightPercent, toRangePercent(entry.visibleEnd - entry.visibleStart, rangeMinutes));
+	const rawTopPercent = toRangePercent(entry.visibleStart - rangeStartMinutes, rangeMinutes);
+	const topPercent = Math.min(rawTopPercent, 100 - heightPercent);
+	return {
+		item: entry.segment.draft.item,
+		dateKey: entry.segment.dateKey,
+		startsAtMinutes: entry.segment.startsAtMinutes,
+		endsAtMinutes: entry.segment.endsAtMinutes,
+		visibleStartsAtMinutes: entry.visibleStart,
+		visibleEndsAtMinutes: entry.visibleEnd,
+		topPercent,
+		heightPercent,
+		isClippedStart: entry.segment.continuesBefore || entry.segment.startsAtMinutes < entry.visibleStart,
+		isClippedEnd: entry.segment.continuesAfter || entry.segment.endsAtMinutes > entry.visibleEnd,
+		laneIndex: lane.laneIndex,
+		laneCount: lane.laneCount,
+		color: entry.segment.draft.color
+	};
+}
+function resolveBounds(bounds) {
+	return {
+		minStartHour: bounds?.minStartHour ?? DEFAULT_BOUNDS.minStartHour,
+		maxEndHour: bounds?.maxEndHour ?? DEFAULT_BOUNDS.maxEndHour,
+		defaultStartHour: bounds?.defaultStartHour ?? DEFAULT_BOUNDS.defaultStartHour,
+		defaultEndHour: bounds?.defaultEndHour ?? DEFAULT_BOUNDS.defaultEndHour,
+		minHeightPercent: bounds?.minHeightPercent ?? DEFAULT_BOUNDS.minHeightPercent
+	};
+}
+function resolveHourRange(segments, bounds) {
+	if (segments.length === 0) return {
+		startHour: bounds.defaultStartHour,
+		endHour: bounds.defaultEndHour
+	};
+	const earliestStart = Math.min(...segments.map((segment) => segment.startsAtMinutes));
+	const latestEnd = Math.max(...segments.map((segment) => segment.endsAtMinutes));
+	const startHour = Math.max(bounds.minStartHour, Math.floor(earliestStart / 60));
+	const endHour = Math.min(bounds.maxEndHour, Math.ceil(latestEnd / 60));
+	return {
+		startHour,
+		endHour: Math.max(startHour + 1, endHour)
+	};
+}
+function buildHourTicks(startHour, endHour) {
+	const ticks = [];
+	for (let hour = startHour; hour <= endHour; hour += 1) ticks.push(hour);
+	return ticks;
+}
+function groupSegmentsByDate(segments) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const segment of segments) {
+		const existing = grouped.get(segment.dateKey) ?? [];
+		existing.push(segment);
+		grouped.set(segment.dateKey, existing);
+	}
+	return grouped;
+}
+function toRangePercent(minutes, rangeMinutes) {
+	if (rangeMinutes <= 0) return 0;
+	return minutes / rangeMinutes * 100;
+}
+function getTimetableDays(viewDate, view, startOfWeek) {
+	if (view === "day") return [viewDate];
+	return getWeekCalendarDays(viewDate, startOfWeek);
+}
+function enumerateDateKeys(startDateKey, endDateKey) {
+	if (startDateKey > endDateKey) throw new Error(`Invalid timetable date range: ${startDateKey} is after ${endDateKey}`);
+	const start = parseDateKey(startDateKey);
+	parseDateKey(endDateKey);
+	const keys = [];
+	let cursor = start;
+	while (formatDateKey(cursor) <= endDateKey) {
+		keys.push(formatDateKey(cursor));
+		cursor = addDays(cursor, 1);
+	}
+	return keys;
+}
+function parseDateKey(dateKey) {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateKey);
+	if (match === null) throw new Error(`Invalid timetable date key: ${dateKey}`);
+	const [, year, month, day] = match;
+	return {
+		year: Number(year),
+		month: Number(month),
+		day: Number(day)
+	};
+}
+//#endregion
+//#region ../calendar/src/group.ts
+/**
+* Group items by their local date (YYYY-MM-DD in the item's own timezone).
+*
+* Generic over `T`. Items with un-parseable startsAt or invalid timezone are
+* silently dropped — call sites that need diagnostics should validate upstream.
+*
+* The output map preserves insertion order of dates (ES2015 spec) and the
+* relative order of items within each date matches input order.
+*/
+function groupItemsByDate(items, accessors) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const dateKey = getLocalDateKey(accessors.getStartsAt(item), accessors.getTimeZone(item));
+		if (dateKey == null) continue;
+		const existing = grouped.get(dateKey);
+		if (existing !== void 0) existing.push(item);
+		else grouped.set(dateKey, [item]);
+	}
+	return grouped;
+}
+//#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.
+*/
+/**
+* Format date for display.
+* Returns: "Monday, January 15, 2025"
+*/
+function formatDate$2(isoTimestamp, options) {
+	return formatBookingDate(toScheduledBookingDateTime({
+		startsAt: isoTimestamp,
+		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
+		locale: options?.locale ?? "en-US"
+	}), {
+		weekday: "long",
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	});
+}
+/**
+* Format time for display.
+* Returns: "10:00 AM"
+*/
+function formatTime(isoTimestamp, options) {
+	return formatBookingTime(toScheduledBookingDateTime({
+		startsAt: isoTimestamp,
+		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
+		locale: options?.locale ?? "en-US"
+	}), {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	});
+}
+function formatEventDateParts(args) {
+	const scheduledRange = toScheduledBookingDateRange({
+		startsAt: args.startsAt,
+		endsAt: args.endsAt,
+		timeZone: toBookingTimeZone(args.timeZone ?? "UTC"),
+		locale: args.locale ?? "en-US"
+	});
+	const { date, time: start } = formatBookingDateParts(scheduledRange, { dateFormat: {
+		weekday: "long",
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	} });
+	return {
+		date,
+		timeRange: `${start} – ${formatBookingTime(toScheduledBookingDateTime({
+			startsAt: args.endsAt,
+			timeZone: scheduledRange.timeZone,
+			locale: args.locale ?? "en-US"
+		}))}`
+	};
+}
+function formatEventCompactDateRail(isoTimestamp, options) {
+	const dateTime = toScheduledBookingDateTime({
+		startsAt: isoTimestamp,
+		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
+		locale: options?.locale ?? "en-US"
+	});
+	const weekday = formatBookingDate(dateTime, { weekday: "short" }).toLocaleUpperCase(options?.locale ?? "en-US");
+	const month = formatBookingDate(dateTime, { month: "short" }).toLocaleUpperCase(options?.locale ?? "en-US");
+	return {
+		weekday,
+		day: formatBookingDate(dateTime, { day: "numeric" }),
+		month,
+		label: formatBookingDate(dateTime, {
+			weekday: "long",
+			year: "numeric",
+			month: "long",
+			day: "numeric"
+		})
+	};
+}
+/**
+* Group events by their local date (YYYY-MM-DD key in each event's own
+* timezone). Thin domain wrapper over `groupItemsByDate` from the calendar
+* package; preserves the historical `Map<string, PublicEvent[]>` shape.
+*/
+function groupEventsByDate(events, calendarTimeZone) {
+	const grouped = groupItemsByDate(events, {
+		getStartsAt: (event) => event.startsAt,
+		getTimeZone: () => calendarTimeZone
+	});
+	const map = /* @__PURE__ */ new Map();
+	for (const [dateKey, bucket] of grouped) map.set(dateKey, [...bucket]);
+	return map;
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/events/domain/people.ts
+function formatTeamMemberNames(names) {
+	const normalized = names.map((name) => name.trim()).filter(Boolean);
+	if (normalized.length === 0) return null;
+	const [firstName, secondName] = normalized;
+	if (!firstName) return null;
+	if (normalized.length === 1) return firstName;
+	if (normalized.length === 2 && secondName) return `${firstName} and ${secondName}`;
+	const finalName = normalized[normalized.length - 1] ?? "";
+	return `${normalized.slice(0, -1).join(", ")}, and ${finalName}`;
+}
+function formatEventTeacherLine(event) {
+	const names = formatTeamMemberNames((event.teamMembers ?? []).map((teamMember) => teamMember.name));
+	return names ? `with ${names}` : null;
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/events/domain/pricing.ts
 const DEFAULT_EVENT_CURRENCY = "USD";
 function resolveRuntimeEventPricing(event) {
 	if (isPublicEventPricing(event.pricing)) return event.pricing;
@@ -41285,6 +42524,17 @@ function readCoursePriceDisplay(value, currency) {
 function readAmount(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+/**
+* Format event price for display.
+* @returns "Free", "£25", "£12 - £25", "Free / £12 - £25", "Course (From £40)", etc.
+*
+* Events render compact amounts (no trailing ".00"); the actual ADT→string
+* mapping lives in `formatBookingPriceDisplay` in @riverbankcms/core so all
+* surfaces stay consistent.
+*/
+function formatEventPrice(event) {
+	return formatEventPricing(resolveRuntimeEventPricing(event), { decimals: "auto" });
+}
 const eventCalendarDisplayModeValues = [
 	"combined",
 	"calendar",
@@ -41809,7 +43059,7 @@ const eventRegistrationBlockDefinition = {
 			{
 				id: "showCapacity",
 				type: "boolean",
-				label: "Show available spots",
+				label: "Show available places",
 				description: "Display remaining capacity",
 				required: false,
 				defaultValue: true,
@@ -42346,599 +43596,34 @@ const eventSpotlightBlockDefinition = {
 				showCapacity: { $bind: { from: "content.showCapacity" } },
 				emptyMessage: { $bind: { from: "content.emptyMessage" } }
 			})], { gap: "lg" }),
-			baseClass: "",
-			spacing: "comfortable"
-		})]
-	}),
-	dataSchemas: { events: publicEventsArraySchema.optional() },
-	dataLoaders: { events: {
-		endpoint: "listPublicEvents",
-		params: {
-			siteId: { $bind: { from: "$root.siteId" } },
-			limit: { $bind: {
-				from: "content.maxEvents",
-				fallback: "3"
-			} },
-			stage: { $bind: {
-				from: "$root.previewStage",
-				fallback: "published"
-			} },
-			detailLevel: "listing",
-			readProfile: "spotlight"
-		},
-		mode: "server"
-	} }
-};
-//#endregion
-//#region ../calendar/src/grid.ts
-const DAY_NAMES = [
-	"Sun",
-	"Mon",
-	"Tue",
-	"Wed",
-	"Thu",
-	"Fri",
-	"Sat"
-];
-const MONTH_NAMES = [
-	"January",
-	"February",
-	"March",
-	"April",
-	"May",
-	"June",
-	"July",
-	"August",
-	"September",
-	"October",
-	"November",
-	"December"
-];
-function formatDateKey(date) {
-	return `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`;
-}
-function isToday(date, today) {
-	return isSameCalendarDay(date, today);
-}
-function isSameCalendarDay(left, right) {
-	return left.year === right.year && left.month === right.month && left.day === right.day;
-}
-function addDays(date, days) {
-	const result = new Date(Date.UTC(date.year, date.month - 1, date.day + days, 12));
-	return {
-		year: result.getUTCFullYear(),
-		month: result.getUTCMonth() + 1,
-		day: result.getUTCDate()
-	};
-}
-function getMonthCalendarDays(year, month, startOfWeek) {
-	const firstDay = {
-		year,
-		month,
-		day: 1
-	};
-	const dayOfWeek = getDayOfWeek(firstDay);
-	const gridStart = addDays(firstDay, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
-	return Array.from({ length: 42 }, (_, index) => addDays(gridStart, index));
-}
-function getWeekCalendarDays(baseDate, startOfWeek) {
-	const dayOfWeek = getDayOfWeek(baseDate);
-	const weekStart = addDays(baseDate, -(startOfWeek === "monday" ? dayOfWeek === 0 ? 6 : dayOfWeek - 1 : dayOfWeek));
-	return Array.from({ length: 7 }, (_, index) => addDays(weekStart, index));
-}
-function getDayOfWeek(date) {
-	return new Date(Date.UTC(date.year, date.month - 1, date.day, 12)).getUTCDay();
-}
-function getWeekCalendarDayTuple(baseDate, startOfWeek) {
-	const days = getWeekCalendarDays(baseDate, startOfWeek);
-	assertWeekCalendarDays(days);
-	return days;
-}
-function assertWeekCalendarDays(days) {
-	if (days.length !== 7) throw new Error("Expected exactly 7 calendar days");
-}
-function getOrderedDayNames(startOfWeek, dayNames = DAY_NAMES) {
-	if (startOfWeek === "monday") {
-		const sunday = dayNames[0] ?? "Sun";
-		return [...dayNames.slice(1), sunday];
-	}
-	return [...dayNames];
-}
-function formatCalendarTitle(viewDate, view, days, monthNames = MONTH_NAMES) {
-	if (view === "week") {
-		const weekStart = days[0];
-		const weekEnd = days[6];
-		if (weekStart === void 0 || weekEnd === void 0) return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
-		const startMonth = monthNames[weekStart.month - 1] ?? "";
-		const endMonth = monthNames[weekEnd.month - 1] ?? "";
-		if (weekStart.month === weekEnd.month) return `${startMonth} ${weekStart.day} - ${weekEnd.day}, ${weekEnd.year}`;
-		return `${startMonth} ${weekStart.day} - ${endMonth} ${weekEnd.day}, ${weekEnd.year}`;
-	}
-	return `${monthNames[viewDate.month - 1] ?? ""} ${viewDate.year}`;
-}
-function buildCalendarViewport(input) {
-	const monthNames = input.monthNames ?? MONTH_NAMES;
-	if (input.view === "week") {
-		const days = getWeekCalendarDayTuple(input.anchorDate, input.startOfWeek);
-		return {
-			kind: "week",
-			anchorDate: input.anchorDate,
-			days,
-			title: formatCalendarTitle(input.anchorDate, "week", days, monthNames)
-		};
-	}
-	const days = getMonthCalendarDays(input.anchorDate.year, input.anchorDate.month, input.startOfWeek);
-	return {
-		kind: "month",
-		anchorDate: input.anchorDate,
-		days,
-		title: formatCalendarTitle(input.anchorDate, "month", days, monthNames)
-	};
-}
-//#endregion
-//#region ../calendar/src/lane-packing.ts
-/**
-* Assign lanes to a list of intervals.
-*
-* Returns one result per input in the same order as the input. Internally
-* sorts a copy by `(start, end, orderKey)` to ensure determinism, then
-* permutes results back to input order.
-*/
-function assignLanes(intervals) {
-	if (intervals.length === 0) return [];
-	const indexed = intervals.map((interval, index) => ({
-		interval,
-		index
-	}));
-	indexed.sort((left, right) => left.interval.start - right.interval.start || left.interval.end - right.interval.end || left.interval.orderKey.localeCompare(right.interval.orderKey));
-	const results = new Array(intervals.length);
-	let cluster = [];
-	let activeLaneEnds = [];
-	let clusterMaxEnd = -Infinity;
-	const closeCluster = () => {
-		if (cluster.length === 0) return;
-		const laneCount = Math.max(1, cluster.reduce((max, entry) => Math.max(max, entry.laneIndex + 1), 0));
-		for (const entry of cluster) results[entry.index] = {
-			laneIndex: entry.laneIndex,
-			laneCount
-		};
-		cluster = [];
-		activeLaneEnds = [];
-		clusterMaxEnd = -Infinity;
-	};
-	for (const { interval, index } of indexed) {
-		if (interval.start >= clusterMaxEnd) closeCluster();
-		const laneIndex = firstAvailableLane(activeLaneEnds, interval.start);
-		activeLaneEnds[laneIndex] = interval.end;
-		clusterMaxEnd = Math.max(clusterMaxEnd, interval.end);
-		cluster.push({
-			index,
-			laneIndex
-		});
-	}
-	closeCluster();
-	return results;
-}
-function firstAvailableLane(activeLaneEnds, start) {
-	const laneIndex = activeLaneEnds.findIndex((end) => end <= start);
-	return laneIndex >= 0 ? laneIndex : activeLaneEnds.length;
-}
-//#endregion
-//#region ../calendar/src/timezone.ts
-/**
-* Timezone boundary helpers — internal.
-*
-* Both functions read an ISO instant in a given IANA timezone and project it
-* onto the wall clock of that zone. They use Intl.DateTimeFormat with
-* hourCycle: 'h23' to avoid 12/24-hour ambiguity. Used internally by the
-* timetable model and `groupItemsByDate`; not exported from the package's
-* public surface.
-*/
-const MINUTES_PER_HOUR = 60;
-/**
-* Local minute-of-day [0, 24*60) for an ISO instant in the given zone.
-* Returns NaN if the inputs cannot be parsed (caller should drop the item).
-*/
-function getLocalMinuteOfDay(isoTimestamp, timeZone) {
-	const date = new Date(isoTimestamp);
-	if (Number.isNaN(date.getTime())) return NaN;
-	if (!isValidTimeZone(timeZone)) return NaN;
-	const parts = new Intl.DateTimeFormat("en-GB", {
-		timeZone,
-		hour: "2-digit",
-		minute: "2-digit",
-		hourCycle: "h23"
-	}).formatToParts(date);
-	const hourPart = Number(parts.find((part) => part.type === "hour")?.value);
-	const minute = Number(parts.find((part) => part.type === "minute")?.value);
-	const hour = hourPart === 24 ? 0 : hourPart;
-	if (Number.isNaN(hour) || Number.isNaN(minute)) return NaN;
-	return hour * MINUTES_PER_HOUR + minute;
-}
-/**
-* Local YYYY-MM-DD for an ISO instant in the given zone.
-* Returns null if the inputs cannot be parsed.
-*/
-function getLocalDateKey(isoTimestamp, timeZone) {
-	const date = new Date(isoTimestamp);
-	if (Number.isNaN(date.getTime())) return null;
-	if (!isValidTimeZone(timeZone)) return null;
-	const parts = new Intl.DateTimeFormat("en-CA", {
-		timeZone,
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit"
-	}).formatToParts(date);
-	const year = parts.find((part) => part.type === "year")?.value;
-	const month = parts.find((part) => part.type === "month")?.value;
-	const day = parts.find((part) => part.type === "day")?.value;
-	if (year === void 0 || year.length === 0) return null;
-	if (month === void 0 || month.length === 0) return null;
-	if (day === void 0 || day.length === 0) return null;
-	return `${year}-${month}-${day}`;
-}
-const validTimeZoneCache = /* @__PURE__ */ new Map();
-function isValidTimeZone(timeZone) {
-	if (typeof timeZone !== "string" || timeZone.length === 0) return false;
-	const cached = validTimeZoneCache.get(timeZone);
-	if (cached !== void 0) return cached;
-	try {
-		new Intl.DateTimeFormat("en-US", { timeZone });
-		validTimeZoneCache.set(timeZone, true);
-		return true;
-	} catch {
-		validTimeZoneCache.set(timeZone, false);
-		return false;
-	}
-}
-//#endregion
-//#region ../calendar/src/timetable.ts
-/**
-* Timetable model — the package's core surface.
-*
-* Generic over `T`. Takes a list of timed items + a viewport; returns a
-* day-by-day layout with overlap-packed lanes and percent-based positions
-* plus a diagnostics list for items dropped during processing.
-*
-* The function is pure: given identical input (including `now`), it returns
-* the same output. The model has no opinion on what an item is — pass
-* accessors.
-*/
-const DEFAULT_BOUNDS = {
-	minStartHour: 5,
-	maxEndHour: 23,
-	defaultStartHour: 6,
-	defaultEndHour: 21,
-	minHeightPercent: 2.5
+			baseClass: "",
+			spacing: "comfortable"
+		})]
+	}),
+	dataSchemas: { events: publicEventsArraySchema.optional() },
+	dataLoaders: { events: {
+		endpoint: "listPublicEvents",
+		params: {
+			siteId: { $bind: { from: "$root.siteId" } },
+			limit: { $bind: {
+				from: "content.maxEvents",
+				fallback: "3"
+			} },
+			stage: { $bind: {
+				from: "$root.previewStage",
+				fallback: "published"
+			} },
+			detailLevel: "listing",
+			readProfile: "spotlight"
+		},
+		mode: "server"
+	} }
 };
-function buildTimetableModel$1(input) {
-	const bounds = resolveBounds(input.bounds);
-	const viewportDays = getTimetableDays(input.viewDate, input.view ?? "week", input.startOfWeek);
-	const viewportKeys = new Set(viewportDays.map(formatDateKey));
-	const parsed = parseAllItems(input.items, input);
-	const inViewport = deriveVisibleSegments(parsed.drafts, viewportKeys);
-	const hourRange = resolveHourRange(inViewport, bounds);
-	const laid = layoutCellsByDate(inViewport, hourRange, bounds);
-	return {
-		days: assembleDays(viewportDays, laid.cellsByDate, input.today),
-		hourTicks: buildHourTicks(hourRange.startHour, hourRange.endHour),
-		startHour: hourRange.startHour,
-		endHour: hourRange.endHour,
-		rangeMinutes: (hourRange.endHour - hourRange.startHour) * 60,
-		hasItems: inViewport.length > 0,
-		diagnostics: [...parsed.diagnostics, ...laid.diagnostics]
-	};
-}
-function parseAllItems(items, accessors) {
-	const drafts = [];
-	const diagnostics = [];
-	for (const item of items) {
-		const result = parseDraft(item, accessors);
-		if (result.ok) drafts.push(result.draft);
-		else diagnostics.push({
-			item,
-			reason: result.reason
-		});
-	}
-	return {
-		drafts,
-		diagnostics
-	};
-}
-function layoutCellsByDate(segments, hourRange, bounds) {
-	const rangeMinutes = (hourRange.endHour - hourRange.startHour) * 60;
-	const rangeStartMinutes = hourRange.startHour * 60;
-	const rangeEndMinutes = hourRange.endHour * 60;
-	const segmentsByDate = groupSegmentsByDate(segments);
-	const cellsByDate = /* @__PURE__ */ new Map();
-	const diagnostics = [];
-	for (const [dateKey, daySegments] of segmentsByDate) {
-		const clipped = [];
-		for (const segment of daySegments) {
-			const result = clipDraft(segment, rangeStartMinutes, rangeEndMinutes);
-			if (result.ok) clipped.push(result.clipped);
-			else diagnostics.push({
-				item: segment.draft.item,
-				reason: result.reason
-			});
-		}
-		const laneResults = assignLanes(clipped.map((entry) => ({
-			start: entry.visibleStart,
-			end: entry.visibleEnd,
-			orderKey: entry.segment.draft.orderKey
-		})));
-		cellsByDate.set(dateKey, clipped.map((entry, idx) => buildCell(entry, laneResults[idx] ?? {
-			laneIndex: 0,
-			laneCount: 1
-		}, rangeStartMinutes, rangeMinutes, bounds.minHeightPercent)));
-	}
-	return {
-		cellsByDate,
-		diagnostics
-	};
-}
-function assembleDays(viewportDays, cellsByDate, today) {
-	return viewportDays.map((date) => {
-		const dateKey = formatDateKey(date);
-		return {
-			date,
-			dateKey,
-			isToday: isSameCalendarDay(date, today),
-			cells: cellsByDate.get(dateKey) ?? []
-		};
-	});
-}
-function parseDraft(item, accessors) {
-	const startsAtIso = accessors.getStartsAt(item);
-	const endsAtIso = accessors.getEndsAt(item);
-	const timeZone = accessors.getTimeZone(item);
-	const startsAtMinutes = getLocalMinuteOfDay(startsAtIso, timeZone);
-	if (Number.isNaN(startsAtMinutes)) return {
-		ok: false,
-		reason: "invalid-start"
-	};
-	const startDateKey = getLocalDateKey(startsAtIso, timeZone);
-	if (startDateKey == null) return {
-		ok: false,
-		reason: "invalid-timezone"
-	};
-	const endDateKey = getLocalDateKey(endsAtIso, timeZone);
-	if (endDateKey == null) return {
-		ok: false,
-		reason: "invalid-end"
-	};
-	const endsAtMinutesRaw = getLocalMinuteOfDay(endsAtIso, timeZone);
-	if (Number.isNaN(endsAtMinutesRaw)) return {
-		ok: false,
-		reason: "invalid-end"
-	};
-	const spansMultipleDays = startDateKey < endDateKey;
-	const endsAtMinutes = spansMultipleDays || endsAtMinutesRaw > startsAtMinutes ? endsAtMinutesRaw : Math.min(1440, startsAtMinutes + 60);
-	if (!spansMultipleDays && endsAtMinutes <= startsAtMinutes) return {
-		ok: false,
-		reason: "non-positive-duration"
-	};
-	return {
-		ok: true,
-		draft: {
-			item,
-			startDateKey,
-			endDateKey,
-			startsAtMinutes,
-			endsAtMinutes,
-			color: accessors.getColor?.(item) ?? null,
-			orderKey: accessors.getOrderKey?.(item) ?? accessors.getId(item)
-		}
-	};
-}
-function deriveVisibleSegments(drafts, viewportKeys) {
-	const segments = [];
-	for (const draft of drafts) for (const dateKey of enumerateDateKeys(draft.startDateKey, draft.endDateKey)) {
-		if (!viewportKeys.has(dateKey)) continue;
-		const isStartDay = dateKey === draft.startDateKey;
-		const isEndDay = dateKey === draft.endDateKey;
-		const startsAtMinutes = isStartDay ? draft.startsAtMinutes : 0;
-		const endsAtMinutes = isEndDay ? draft.endsAtMinutes : 1440;
-		if (endsAtMinutes <= startsAtMinutes) continue;
-		segments.push({
-			draft,
-			dateKey,
-			startsAtMinutes,
-			endsAtMinutes,
-			continuesBefore: !isStartDay,
-			continuesAfter: !isEndDay
-		});
-	}
-	return segments;
-}
-function clipDraft(segment, rangeStartMinutes, rangeEndMinutes) {
-	const visibleStart = Math.max(rangeStartMinutes, segment.startsAtMinutes);
-	const visibleEnd = Math.min(rangeEndMinutes, segment.endsAtMinutes);
-	if (visibleEnd <= visibleStart) return {
-		ok: false,
-		reason: "out-of-visible-hours"
-	};
-	return {
-		ok: true,
-		clipped: {
-			segment,
-			visibleStart,
-			visibleEnd
-		}
-	};
-}
-function buildCell(entry, lane, rangeStartMinutes, rangeMinutes, minHeightPercent) {
-	const heightPercent = Math.max(minHeightPercent, toRangePercent(entry.visibleEnd - entry.visibleStart, rangeMinutes));
-	const rawTopPercent = toRangePercent(entry.visibleStart - rangeStartMinutes, rangeMinutes);
-	const topPercent = Math.min(rawTopPercent, 100 - heightPercent);
-	return {
-		item: entry.segment.draft.item,
-		dateKey: entry.segment.dateKey,
-		startsAtMinutes: entry.segment.startsAtMinutes,
-		endsAtMinutes: entry.segment.endsAtMinutes,
-		visibleStartsAtMinutes: entry.visibleStart,
-		visibleEndsAtMinutes: entry.visibleEnd,
-		topPercent,
-		heightPercent,
-		isClippedStart: entry.segment.continuesBefore || entry.segment.startsAtMinutes < entry.visibleStart,
-		isClippedEnd: entry.segment.continuesAfter || entry.segment.endsAtMinutes > entry.visibleEnd,
-		laneIndex: lane.laneIndex,
-		laneCount: lane.laneCount,
-		color: entry.segment.draft.color
-	};
-}
-function resolveBounds(bounds) {
-	return {
-		minStartHour: bounds?.minStartHour ?? DEFAULT_BOUNDS.minStartHour,
-		maxEndHour: bounds?.maxEndHour ?? DEFAULT_BOUNDS.maxEndHour,
-		defaultStartHour: bounds?.defaultStartHour ?? DEFAULT_BOUNDS.defaultStartHour,
-		defaultEndHour: bounds?.defaultEndHour ?? DEFAULT_BOUNDS.defaultEndHour,
-		minHeightPercent: bounds?.minHeightPercent ?? DEFAULT_BOUNDS.minHeightPercent
-	};
-}
-function resolveHourRange(segments, bounds) {
-	if (segments.length === 0) return {
-		startHour: bounds.defaultStartHour,
-		endHour: bounds.defaultEndHour
-	};
-	const earliestStart = Math.min(...segments.map((segment) => segment.startsAtMinutes));
-	const latestEnd = Math.max(...segments.map((segment) => segment.endsAtMinutes));
-	const startHour = Math.max(bounds.minStartHour, Math.floor(earliestStart / 60));
-	const endHour = Math.min(bounds.maxEndHour, Math.ceil(latestEnd / 60));
-	return {
-		startHour,
-		endHour: Math.max(startHour + 1, endHour)
-	};
-}
-function buildHourTicks(startHour, endHour) {
-	const ticks = [];
-	for (let hour = startHour; hour <= endHour; hour += 1) ticks.push(hour);
-	return ticks;
-}
-function groupSegmentsByDate(segments) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const segment of segments) {
-		const existing = grouped.get(segment.dateKey) ?? [];
-		existing.push(segment);
-		grouped.set(segment.dateKey, existing);
-	}
-	return grouped;
-}
-function toRangePercent(minutes, rangeMinutes) {
-	if (rangeMinutes <= 0) return 0;
-	return minutes / rangeMinutes * 100;
-}
-function getTimetableDays(viewDate, view, startOfWeek) {
-	if (view === "day") return [viewDate];
-	return getWeekCalendarDays(viewDate, startOfWeek);
-}
-function enumerateDateKeys(startDateKey, endDateKey) {
-	if (startDateKey > endDateKey) throw new Error(`Invalid timetable date range: ${startDateKey} is after ${endDateKey}`);
-	const start = parseDateKey(startDateKey);
-	parseDateKey(endDateKey);
-	const keys = [];
-	let cursor = start;
-	while (formatDateKey(cursor) <= endDateKey) {
-		keys.push(formatDateKey(cursor));
-		cursor = addDays(cursor, 1);
-	}
-	return keys;
-}
-function parseDateKey(dateKey) {
-	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateKey);
-	if (match === null) throw new Error(`Invalid timetable date key: ${dateKey}`);
-	const [, year, month, day] = match;
-	return {
-		year: Number(year),
-		month: Number(month),
-		day: Number(day)
-	};
-}
-//#endregion
-//#region ../calendar/src/group.ts
-/**
-* Group items by their local date (YYYY-MM-DD in the item's own timezone).
-*
-* Generic over `T`. Items with un-parseable startsAt or invalid timezone are
-* silently dropped — call sites that need diagnostics should validate upstream.
-*
-* The output map preserves insertion order of dates (ES2015 spec) and the
-* relative order of items within each date matches input order.
-*/
-function groupItemsByDate(items, accessors) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const dateKey = getLocalDateKey(accessors.getStartsAt(item), accessors.getTimeZone(item));
-		if (dateKey == null) continue;
-		const existing = grouped.get(dateKey);
-		if (existing !== void 0) existing.push(item);
-		else grouped.set(dateKey, [item]);
-	}
-	return grouped;
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/eventCapacity.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
-	};
-	const available = event.availableSpots ?? event.capacity - event.registeredCount;
-	if (available <= 0) return {
-		available: 0,
-		isFull: true
-	};
-	return {
-		available,
-		isFull: false
-	};
-}
-/**
-* Derive the three-state availability status (available / filling / waitlist)
-* plus a short pill label. Builds on {@link getEventAvailability} so the
-* capacity math (availableSpots with a `capacity - registeredCount` fallback)
-* stays consistent with the binary helper used elsewhere.
-*/
-function getEventAvailabilityStatus(event, options) {
-	const threshold = options?.fillingThreshold ?? 2;
-	const { available, isFull } = getEventAvailability(event);
-	if (available == null) return {
-		status: "available",
-		available: null,
-		isFull: false,
-		label: null
-	};
-	if (isFull) return {
-		status: "waitlist",
-		available: 0,
-		isFull: true,
-		label: event.waitlistEnabled ? "Waitlist" : "Full"
-	};
-	if (available <= threshold) return {
-		status: "filling",
-		available,
-		isFull: false,
-		label: `${available} left`
-	};
-	return {
-		status: "available",
-		available,
-		isFull: false,
-		label: `${available} places`
-	};
-}
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/events/shared/utils.ts
+//#region ../blocks/src/system/runtime/nodes/events/shared/listingLayout.ts
 /**
-* Shared utility functions for event blocks
+* 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
@@ -42973,180 +43658,6 @@ function getCardOrientation(layout) {
 		case "compact": return "vertical";
 	}
 }
-/**
-* Format date for display.
-* Returns: "Monday, January 15, 2025"
-*/
-function formatDate$2(isoTimestamp, options) {
-	return formatBookingDate(toScheduledBookingDateTime({
-		startsAt: isoTimestamp,
-		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
-		locale: options?.locale ?? "en-US"
-	}), {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	});
-}
-/**
-* Format time for display.
-* Returns: "10:00 AM"
-*/
-function formatTime(isoTimestamp, options) {
-	return formatBookingTime(toScheduledBookingDateTime({
-		startsAt: isoTimestamp,
-		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
-		locale: options?.locale ?? "en-US"
-	}), {
-		hour: "numeric",
-		minute: "2-digit",
-		hour12: true
-	});
-}
-function formatEventDateParts(args) {
-	const scheduledRange = toScheduledBookingDateRange({
-		startsAt: args.startsAt,
-		endsAt: args.endsAt,
-		timeZone: toBookingTimeZone(args.timeZone ?? "UTC"),
-		locale: args.locale ?? "en-US"
-	});
-	const { date, time: start } = formatBookingDateParts(scheduledRange, { dateFormat: {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	} });
-	return {
-		date,
-		timeRange: `${start} – ${formatBookingTime(toScheduledBookingDateTime({
-			startsAt: args.endsAt,
-			timeZone: scheduledRange.timeZone,
-			locale: args.locale ?? "en-US"
-		}))}`
-	};
-}
-function formatEventCompactDateRail(isoTimestamp, options) {
-	const dateTime = toScheduledBookingDateTime({
-		startsAt: isoTimestamp,
-		timeZone: toBookingTimeZone(options?.timeZone ?? "UTC"),
-		locale: options?.locale ?? "en-US"
-	});
-	const weekday = formatBookingDate(dateTime, { weekday: "short" }).toLocaleUpperCase(options?.locale ?? "en-US");
-	const month = formatBookingDate(dateTime, { month: "short" }).toLocaleUpperCase(options?.locale ?? "en-US");
-	return {
-		weekday,
-		day: formatBookingDate(dateTime, { day: "numeric" }),
-		month,
-		label: formatBookingDate(dateTime, {
-			weekday: "long",
-			year: "numeric",
-			month: "long",
-			day: "numeric"
-		})
-	};
-}
-function formatTeamMemberNames(names) {
-	const normalized = names.map((name) => name.trim()).filter(Boolean);
-	if (normalized.length === 0) return null;
-	const [firstName, secondName] = normalized;
-	if (!firstName) return null;
-	if (normalized.length === 1) return firstName;
-	if (normalized.length === 2 && secondName) return `${firstName} and ${secondName}`;
-	const finalName = normalized[normalized.length - 1] ?? "";
-	return `${normalized.slice(0, -1).join(", ")}, and ${finalName}`;
-}
-function formatEventTeacherLine(event) {
-	const names = formatTeamMemberNames((event.teamMembers ?? []).map((teamMember) => teamMember.name));
-	return names ? `with ${names}` : null;
-}
-/**
-* Group events by their local date (YYYY-MM-DD key in each event's own
-* timezone). Thin domain wrapper over `groupItemsByDate` from the calendar
-* package; preserves the historical `Map<string, PublicEvent[]>` shape.
-*/
-function groupEventsByDate(events, calendarTimeZone) {
-	const grouped = groupItemsByDate(events, {
-		getStartsAt: (event) => event.startsAt,
-		getTimeZone: () => calendarTimeZone
-	});
-	const map = /* @__PURE__ */ new Map();
-	for (const [dateKey, bucket] of grouped) map.set(dateKey, [...bucket]);
-	return map;
-}
-/**
-* Format event price for display.
-* @returns "Free", "£25", "£12 - £25", "Free / £12 - £25", "Course (From £40)", etc.
-*
-* Events render compact amounts (no trailing ".00"); the actual ADT→string
-* mapping lives in `formatBookingPriceDisplay` in @riverbankcms/core so all
-* surfaces stay consistent.
-*/
-function formatEventPrice(event) {
-	return formatEventPricing(resolveRuntimeEventPricing(event), { decimals: "auto" });
-}
-function closedEventBookingLabel(reason) {
-	switch (reason) {
-		case "occurrence_cancelled":
-		case "series_cancelled": return "Cancelled";
-		case "occurrence_completed":
-		case "series_completed": return "Completed";
-		case "series_draft":
-		case "series_archived":
-		case "parent_archived":
-		case "parent_inconsistent":
-		case "not_public":
-		case "already_started":
-		case "enrollment_closed": return "Registration closed";
-		default: return assertNever$24(reason);
-	}
-}
-function resolveEventHref(event) {
-	const destination = resolveRuntimeEventDestination(event);
-	return destination.kind === "external" ? destination.url : destination.path;
-}
-function resolveEventLinkProps(event) {
-	const href = resolveEventHref(event);
-	return resolveRuntimeEventDestination(event).kind === "external" ? {
-		href,
-		target: "_blank",
-		rel: "noopener noreferrer"
-	} : { href };
-}
-/**
-* Resolve the CTA state for an event.
-* Shared by EventCard and EventCompactRow to keep sold-out, registration-closed,
-* and course-specific defaults consistent.
-*/
-function resolveEventCta(event, buttonText) {
-	const { isFull: isSoldOut } = getEventAvailability(event);
-	const destination = resolveRuntimeEventDestination(event);
-	const isExternal = destination.kind === "external";
-	const defaultButtonText = isExternal ? destination.label : event.bookingScope === "whole_series" ? "Book course" : "Book";
-	const effectiveButtonText = buttonText ?? defaultButtonText;
-	const href = resolveEventHref(event);
-	if (event.bookingAvailability.kind === "closed") {
-		const linksToClosedWholeSeriesDetails = event.bookingAvailability.reason === "enrollment_closed" && !isExternal;
-		return {
-			label: closedEventBookingLabel(event.bookingAvailability.reason),
-			href,
-			external: isExternal,
-			hidden: !linksToClosedWholeSeriesDetails
-		};
-	}
-	if (!isExternal && isSoldOut) return {
-		label: "Sold out",
-		href,
-		external: false,
-		hidden: true
-	};
-	return {
-		label: effectiveButtonText,
-		href,
-		external: isExternal,
-		hidden: false
-	};
-}
 //#endregion
 //#region ../blocks/src/system/media/slotContracts.ts
 const DEFAULT_MIN_SOURCE_WIDTH = 1200;
@@ -44417,7 +44928,6 @@ const EventCard = ({ event, cardRole = "default", buttonVariant = "primary", but
 	const formattedDate = formatDate$2(event.startsAt, { timeZone });
 	const formattedTime = `${formatTime(event.startsAt, { timeZone })} - ${formatTime(event.endsAt, { timeZone })}`;
 	const cta = resolveEventCta(event, buttonText);
-	const { available: spotsLeft, isFull: isSoldOut } = getEventAvailability(event);
 	const cardClass = boxStyleClassNames({ role: cardRole }, { baseClass: "event-card" });
 	const buttonClass = themeButtonClassName({
 		variant: buttonVariant,
@@ -44433,10 +44943,7 @@ const EventCard = ({ event, cardRole = "default", buttonVariant = "primary", but
 	} : null;
 	const hasImage = Boolean(showImage && image);
 	const teacherLine = formatEventTeacherLine(event);
-	const capacityText = showCapacity ? formatCapacityText(event, {
-		isSoldOut,
-		spotsLeft
-	}) : null;
+	const capacityText = showCapacity ? formatEventRemainingPlaces(event, { full: "Sold out" }) : null;
 	return /* @__PURE__ */ jsxs("article", {
 		className: `${cardClass} group rb-flex rb-flex-col rb-h-full ${eventCardOrientationClass(orientation)}`,
 		"data-orientation": orientation,
@@ -44502,7 +45009,11 @@ function EventCardContent(props) {
 			}),
 			/* @__PURE__ */ jsx("h3", {
 				className: "card-title rb-mb-3",
-				children: props.title
+				children: /* @__PURE__ */ jsx("a", {
+					className: "event-title-link",
+					...resolveEventLinkProps(event),
+					children: props.title
+				})
 			}),
 			/* @__PURE__ */ jsx("div", {
 				className: "rb-mb-2 rb-caption",
@@ -44579,13 +45090,6 @@ function eventCardOrientationClass(orientation) {
 		case "vertical": return "event-card--vertical";
 	}
 }
-function formatCapacityText(event, options) {
-	if (event.capacity == null) return null;
-	if (options.isSoldOut) return "Sold out";
-	if (options.spotsLeft == null) return null;
-	const count = options.spotsLeft;
-	return `${count} ${count === 1 ? "spot" : "spots"} available`;
-}
 function getCategoryBadgeStyle(background) {
 	const normalized = background?.trim() ?? "";
 	if (!normalized) return {
@@ -44654,7 +45158,11 @@ const EventCompactRow = ({ event, buttonVariant = "primary", buttonText }) => {
 				className: "event-compact-row-content",
 				children: [/* @__PURE__ */ jsx("h3", {
 					className: "event-compact-row-title",
-					children: event.title
+					children: /* @__PURE__ */ jsx("a", {
+						className: "event-title-link",
+						...resolveEventLinkProps(event),
+						children: event.title
+					})
 				}), /* @__PURE__ */ jsxs("div", {
 					className: "event-compact-row-meta",
 					children: [
@@ -44743,6 +45251,23 @@ function DateTimeTile({ startsAt, endsAt, timeZone }) {
 	});
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/events/shared/OfferingTitle.tsx
+/**
+* Heading for an offering card or row. Links to the offering's page when one
+* exists so a sold-out or closed offering stays reachable (issue 1372); the
+* `.event-title-link` rule lives in theme-core's event-list.css.
+*/
+function OfferingTitle({ className, path, title }) {
+	return /* @__PURE__ */ jsx("h3", {
+		className,
+		children: path ? /* @__PURE__ */ jsx("a", {
+			className: "event-title-link",
+			href: path,
+			children: title
+		}) : title
+	});
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
 const eventPageSizeValues = [
 	3,
@@ -46087,7 +46612,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,
@@ -55764,7 +56289,7 @@ function EventFacts({ selection, selected, venue, teamMembers, pricing, showCapa
 				children: [/* @__PURE__ */ jsx("div", {
 					className: "rb-label rb-mb-2",
 					children: "Places"
-				}), /* @__PURE__ */ jsxs("p", { children: [selected.capacity, " places"] })]
+				}), /* @__PURE__ */ jsx("p", { children: formatTotalCapacity(selected.capacity) })]
 			}) : null,
 			pricing,
 			selected.bookingScope === "whole_series" ? /* @__PURE__ */ jsxs("div", {
@@ -56608,9 +57133,10 @@ function CourseCompactRow({ course, path }) {
 			}),
 			/* @__PURE__ */ jsxs("div", {
 				className: "event-compact-row-content",
-				children: [/* @__PURE__ */ jsx("h3", {
+				children: [/* @__PURE__ */ jsx(OfferingTitle, {
 					className: "event-compact-row-title",
-					children: course.title
+					path,
+					title: course.title
 				}), /* @__PURE__ */ jsxs("div", {
 					className: "event-compact-row-meta",
 					children: [
@@ -56667,9 +57193,10 @@ function CourseFeatureCard({ course, path, buttonVariant, buttonText }) {
 		children: /* @__PURE__ */ jsxs("div", {
 			className: "card-content rb-flex rb-flex-1 rb-flex-col",
 			children: [
-				/* @__PURE__ */ jsx("h3", {
+				/* @__PURE__ */ jsx(OfferingTitle, {
 					className: "card-title rb-mb-3",
-					children: course.title
+					path,
+					title: course.title
 				}),
 				/* @__PURE__ */ jsxs("div", {
 					className: "rb-mb-2 rb-caption",
@@ -57525,8 +58052,8 @@ const AgendaEventCard = ({ event, showCapacity, onClick }) => {
 	const eventLinkProps = resolveEventLinkProps(event);
 	const categoryColor = event.eventCategory?.color || "rgb(var(--tb-accent))";
 	const price = formatEventPrice(event);
-	const { available, isFull } = getEventAvailability(event);
-	const capacity = showCapacity && available != null ? isFull ? "Full" : `${available} spots left` : null;
+	const capacity = showCapacity ? formatEventRemainingPlaces(event) : null;
+	const isFull = isEventFull(event);
 	const title = event.title;
 	const timeZone = event.timeZone ?? null;
 	const teacherLine = formatEventTeacherLine(event);
@@ -57968,7 +58495,7 @@ function buildTimetableModel(input) {
 		getEndsAt: (event) => event.endsAt,
 		getTimeZone: (event) => event.timeZone ?? "UTC",
 		getColor: (event) => event.eventCategory?.color ?? null,
-		getOrderKey: (event) => `${event.title}${event.id}`
+		getOrderKey: (event) => `${event.title}\u0000${event.id}`
 	});
 	return {
 		hourTicks: [...generic.hourTicks],
@@ -58005,18 +58532,9 @@ function toEventCell(cell) {
 	};
 }
 function formatTimetableCapacity(event) {
-	const { available, isFull } = getEventAvailability(event);
-	if (available == null) return {
-		label: null,
-		isFull: false
-	};
-	if (isFull) return {
-		label: "Full",
-		isFull: true
-	};
 	return {
-		label: `${available} spots left`,
-		isFull: false
+		label: formatEventRemainingPlaces(event, { compact: true }),
+		isFull: isEventFull(event)
 	};
 }
 function formatEventTimeRange(event) {
@@ -58492,7 +59010,7 @@ function EventRegistrationSSR({ blockId, subject, children, ...sourceProps }) {
 		className: `event-registration ${className ?? ""}`.trim(),
 		"data-block": "event-registration",
 		"data-rb-island-required": "true",
-		"data-rb-island-error-message": "Booking options failed to load. Please refresh the page.",
+		"data-rb-island-error-message": "We couldn’t load the booking options for this event. Please refresh this page and try again. If this keeps happening, contact the organiser for help.",
 		"data-rb-island-error-class": "event-registration__hydration-error",
 		...getIslandRootProps("event-registration", blockId),
 		children: [
@@ -64363,6 +64881,32 @@ function isSiteStyleTransitionStyleGroup(value) {
 function boundaryMapForAdjacentBlockIds(boundaries) {
 	return new Map(boundaries.map((boundary) => [boundaryKey(boundary.previousBlockId, boundary.nextBlockId), boundary]));
 }
+/** Keep a surviving block's outgoing treatment when omitted blocks change its neighbor. */
+function boundariesForSurvivingBlocks(boundaries, blocks) {
+	const outgoing = new Map(boundaries.map((boundary) => [boundary.previousBlockId, boundary]));
+	const incoming = new Map(boundaries.map((boundary) => [boundary.nextBlockId, boundary]));
+	return blocks.flatMap((block, index) => {
+		const next = blocks[index + 1];
+		if (!block.id || !next?.id) return [];
+		const boundary = outgoing.get(block.id);
+		if (!boundary) return [];
+		if (boundary.nextBlockId === next.id) return [boundary];
+		const destination = incoming.get(next.id);
+		return [retargetCompiledBoundaryRuntimeForContentAdjacency({
+			...boundary,
+			boundaryId: `boundary:${block.id}:${next.id}`,
+			nextBlockId: next.id,
+			to: destination?.to ?? boundary.to,
+			cssVars: {
+				...boundary.cssVars,
+				to: destination?.cssVars.to ?? boundary.cssVars.to
+			}
+		}, {
+			currentContent: block.content,
+			nextContent: next.content
+		})];
+	});
+}
 function boundaryBetweenBlocks(previousBlock, nextBlock, boundaries) {
 	const previousBlockId = previousBlock?.id ?? null;
 	const nextBlockId = nextBlock?.id ?? null;
@@ -64454,41 +64998,179 @@ function toPresentationPage(page) {
 	};
 }
 //#endregion
+//#region ../blocks/src/pageRendererBlockSupport.tsx
+/**
+* Support for rendering one block section: what a block that cannot render
+* leaves behind, how an override is found, and the props both override paths
+* hand to a component. `PageRenderer` owns the page-level composition; this
+* module owns the pieces it reaches for per block.
+*/
+function fallback(message) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "rb-p-6 rb-caption",
+		style: textColorStyle("mutedText"),
+		children: message
+	});
+}
+/**
+* A page with nothing to show. Authoring surfaces get the diagnostic; a public
+* page renders nothing at all rather than telling a visitor about the outline.
+*/
+function emptyPageNotice(audience) {
+	if (audience === "public") return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "rb-p-6 rb-caption",
+		style: textColorStyle("mutedText"),
+		children: "No blocks found."
+	});
+}
+/**
+* A public page dropped a block, so nothing in the rendered HTML says the
+* content is missing. Say it in the logs instead.
+*/
+function warnOmittedFromPublicPage(input) {
+	try {
+		console.warn("[blocks:PageRenderer] omitted a non-renderable block from a public page", {
+			blockId: input.block.id ?? null,
+			blockKind: input.block.kind,
+			outcome: input.outcome,
+			...input.admissionError ? { error: input.admissionError } : {}
+		});
+	} catch {}
+}
+function shouldDebugCustomBlocks() {
+	try {
+		return globalThis.process?.env?.DEBUG_CUSTOM_BLOCKS === "1";
+	} catch {
+		return false;
+	}
+}
+/**
+* Look up a block override component by block kind.
+* Supports both full ("block.hero") and short ("hero") keys.
+*/
+function getBlockOverride(blockKind, overrides) {
+	if (!overrides) return void 0;
+	if (overrides[blockKind]) return overrides[blockKind];
+	const shortKind = blockKind.replace(/^block\./, "");
+	if (overrides[shortKind]) return overrides[shortKind];
+}
+/**
+* Resolves block content based on stage priority.
+* For draft/preview: draftContent takes priority over content.
+* For published: content is the source of truth.
+* Returns empty object if no content exists (validator will handle placeholders if needed).
+*/
+function getRenderableContent(block, previewStage = "published") {
+	const source = previewStage === "preview" && block.draftContent ? block.draftContent : block.content ?? {};
+	if (!isObjectRecord$1(source)) return {};
+	return source;
+}
+function resolvePageRendererImageResolveContext(dataContext) {
+	const input = dataContext?.imageResolveContext;
+	return buildResolveImageUrlContext({
+		siteId: input?.siteId ?? dataContext?.siteId,
+		supabaseUrl: input?.supabaseUrl ?? dataContext?.supabaseUrl,
+		mediaAssetIndex: input?.mediaAssetIndex,
+		mediaAssets: input?.mediaAssets ?? dataContext?.mediaAssets
+	});
+}
+/**
+* The RSC-safe props every override component receives, whether the block
+* resolved a manifest or is being rendered from an override alone.
+*/
+function buildBlockOverrideProps(input) {
+	return {
+		content: input.content,
+		...overrideThemeProps(input.themeResources),
+		...blockOverrideContextProps(input.dataContext),
+		data: input.data,
+		imageResolveContext: input.imageResolveContext,
+		blockId: input.block.id ?? null,
+		blockKind: input.block.kind
+	};
+}
+/** The render-context half of the override props, absent context included. */
+function blockOverrideContextProps(dataContext) {
+	const context = dataContext ?? {};
+	return {
+		siteId: context.siteId,
+		apiBaseUrl: context.apiBaseUrl,
+		bookingTimeZone: context.bookingTimeZone,
+		portalToken: context.portalToken ?? null,
+		previewToken: context.previewToken ?? null,
+		stage: context.previewStage,
+		occurrenceContext: context.occurrenceContext ?? null,
+		entrySubrouteContext: context.entrySubrouteContext ?? null,
+		contentEntry: context.contentEntry ?? null,
+		pageSurface: context.pageSurface ?? null,
+		subject: context.subject ?? null,
+		supabaseUrl: context.supabaseUrl
+	};
+}
+const blockComponentCache = /* @__PURE__ */ new WeakMap();
+const DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS = 25;
+let cachedPerfSlowBlockRenderThresholdMs = null;
+function getPerfSlowBlockRenderThresholdMs() {
+	if (cachedPerfSlowBlockRenderThresholdMs !== null) return cachedPerfSlowBlockRenderThresholdMs;
+	const raw = globalThis.process?.env?.DEBUG_PERF_BLOCK_MS;
+	const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+	cachedPerfSlowBlockRenderThresholdMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS;
+	return cachedPerfSlowBlockRenderThresholdMs;
+}
+function getCachedBlockComponent(manifest) {
+	const cached = blockComponentCache.get(manifest);
+	if (cached) return cached;
+	const created = makeDefaultBlockComponent({ manifest });
+	blockComponentCache.set(manifest, created);
+	return created;
+}
+//#endregion
 //#region ../blocks/src/PageRenderer.tsx
 function PageRenderer$1(props) {
 	const page = React$1.useMemo(() => toPresentationPage(props.page), [props.page]);
 	return /* @__PURE__ */ jsx(PageRendererCore, {
 		...props,
-		page
+		page,
+		audience: "public"
 	});
 }
 function PageRendererCore(props) {
-	const { page, runtimeBoundaries, dataContext, wrapBlock, wrapBoundary, registry } = props;
+	const { page, audience, runtimeBoundaries, dataContext, wrapBlock, wrapBoundary, registry } = props;
 	const imageResolveContext = React$1.useMemo(() => resolvePageRendererImageResolveContext(dataContext), [
 		dataContext?.imageResolveContext,
 		dataContext?.mediaAssets,
 		dataContext?.siteId,
 		dataContext?.supabaseUrl
 	]);
-	const boundaryByAdjacentBlockIds = React$1.useMemo(() => boundaryMapForAdjacentBlockIds(runtimeBoundaries ?? []), [runtimeBoundaries]);
 	const usesRuntimeBoundaries = runtimeBoundaries !== void 0;
 	const themeResources = React$1.useMemo(() => resolvePageThemeResources(props), [
 		props.rendering,
 		props.theme,
 		props.themeTokens
 	]);
-	if (!page || page.blocks.length === 0) return /* @__PURE__ */ jsx("div", {
-		className: "rb-p-6 rb-caption",
-		style: textColorStyle("mutedText"),
-		children: "No blocks found."
-	});
 	const resolvedRegistry = registry ?? getDefaultComponentRegistry();
 	setContextResolveImageUrlContext(imageResolveContext);
-	return /* @__PURE__ */ jsx("div", { children: page.blocks.map((block, index) => {
-		const blockPosition = pageBlockPosition(index, page.blocks.length);
-		const blockKey = block.id ?? `${block.kind}-${index}`;
-		const previousBlock = page.blocks[index - 1] ?? null;
-		const nextBlock = page.blocks[index + 1] ?? null;
+	const sections = usePageSections(props, {
+		page,
+		themeResources,
+		imageResolveContext,
+		registry: resolvedRegistry
+	});
+	const boundaryByAdjacentBlockIds = React$1.useMemo(() => boundaryMapForAdjacentBlockIds(boundariesForSurvivingBlocks(runtimeBoundaries ?? [], sections.map(({ block }) => ({
+		...block,
+		content: getRenderableContent(block, dataContext?.previewStage)
+	})))), [
+		runtimeBoundaries,
+		sections,
+		dataContext?.previewStage
+	]);
+	if (sections.length === 0) return emptyPageNotice(audience);
+	return /* @__PURE__ */ jsx("div", { children: sections.map((section, index) => {
+		const { block, blockKey, node } = section;
+		const blockPosition = pageBlockPosition(index, sections.length);
+		const previousBlock = sections[index - 1]?.block ?? null;
+		const nextBlock = sections[index + 1]?.block ?? null;
 		const boundaryBefore = boundaryBetweenBlocks(previousBlock, block, boundaryByAdjacentBlockIds);
 		const boundaryAfter = boundaryBetweenBlocks(block, nextBlock, boundaryByAdjacentBlockIds);
 		const boundaryElement = renderBoundaryAfterBlock({
@@ -64503,19 +65185,7 @@ function PageRendererCore(props) {
 		const managesOwnWrapper = definition?.manifest.behaviours?.managesOwnWrapper;
 		const renderableContent = getRenderableContent(block, dataContext?.previewStage);
 		const variantKey = definition?.manifest ? resolveVariantKey(definition.manifest, renderableContent) : null;
-		const shouldUseWrapper = !managesOwnWrapper || Boolean(wrapBlock);
-		const blockSectionProps = buildBlockSectionProps({
-			props,
-			themeResources,
-			block,
-			blockKey,
-			imageResolveContext,
-			registry: resolvedRegistry
-		});
-		if (!shouldUseWrapper) {
-			const rendered = /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps }, `${blockKey}:block`);
-			return boundaryElement ? /* @__PURE__ */ jsxs(React$1.Fragment, { children: [rendered, boundaryElement] }, blockKey) : rendered;
-		}
+		if (!(!managesOwnWrapper || Boolean(wrapBlock))) return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [node, boundaryElement] }, blockKey);
 		const wrapperClassName = [`block-${cleanKind}`, wrapBlock ? "group relative" : null].filter(Boolean).join(" ");
 		const styleGroup = typeof renderableContent.styleGroup === "string" ? renderableContent.styleGroup : void 0;
 		const blockLook = typeof renderableContent.blockLook === "string" ? renderableContent.blockLook : void 0;
@@ -64540,7 +65210,7 @@ function PageRendererCore(props) {
 			"data-site-style-boundary-after": boundaryAfter?.metrics.size,
 			"data-style-group": styleGroup,
 			style: blockStyle,
-			children: /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps })
+			children: node
 		}, blockKey);
 		if (boundaryElement) return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [blockElement, boundaryElement] }, blockKey);
 		if (usesRuntimeBoundaries || !isSiteStyleTransitionStyleGroup(styleGroup)) return blockElement;
@@ -64553,18 +65223,69 @@ function PageRendererCore(props) {
 		})] }, blockKey);
 	}) });
 }
-function resolvePageRendererImageResolveContext(dataContext) {
-	const input = dataContext?.imageResolveContext;
-	return buildResolveImageUrlContext({
-		siteId: input?.siteId ?? dataContext?.siteId,
-		supabaseUrl: input?.supabaseUrl ?? dataContext?.supabaseUrl,
-		mediaAssetIndex: input?.mediaAssetIndex,
-		mediaAssets: input?.mediaAssets ?? dataContext?.mediaAssets
+/**
+* Memoised so that a re-render with unchanged inputs reuses the same section
+* elements and React can skip the block subtrees, exactly as the per-block memo
+* did before public pages started resolving their bodies up front.
+*/
+function usePageSections(props, input) {
+	const { page, themeResources, imageResolveContext, registry } = input;
+	return React$1.useMemo(() => admitPageSections({
+		props,
+		blocks: page?.blocks ?? [],
+		audience: props.audience,
+		themeResources,
+		imageResolveContext,
+		registry
+	}), [
+		page,
+		props.audience,
+		themeResources,
+		imageResolveContext,
+		registry,
+		props.dataContext,
+		props.routeMap,
+		props.wrapBlock,
+		props.blockOverrides,
+		props.sdkConfig,
+		props.customBlocks,
+		props.previewAuthoring
+	]);
+}
+/**
+* Resolves each block's rendered body before the page decides what to wrap.
+*
+* On a public page the body is resolved eagerly so a block that cannot render
+* is dropped along with its wrapper, its data attributes, its boundary reserve
+* space and its style-group sibling — the section body is the single source of
+* truth for whether the block is on the page (issue 1378). Authoring surfaces
+* keep the memoised component so the editor's render-loop guards still hold.
+*/
+function admitPageSections(input) {
+	const sections = [];
+	input.blocks.forEach((block, index) => {
+		const blockKey = block.id ?? `${block.kind}-${index}`;
+		const blockSectionProps = buildBlockSectionProps({
+			props: input.props,
+			themeResources: input.themeResources,
+			block,
+			blockKey,
+			imageResolveContext: input.imageResolveContext,
+			registry: input.registry
+		});
+		const node = input.audience === "public" ? renderBlockSection(blockSectionProps) : /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps }, `${blockKey}:block`);
+		if (node === null || node === void 0) return;
+		sections.push({
+			block,
+			blockKey,
+			node
+		});
 	});
+	return sections;
 }
-const resolveBookingTimeZone = (dataContext) => dataContext?.bookingTimeZone;
 function buildBlockSectionProps(input) {
 	return {
+		audience: input.props.audience,
 		themeResources: input.themeResources,
 		block: input.block,
 		dataContext: input.props.dataContext,
@@ -64580,40 +65301,24 @@ function buildBlockSectionProps(input) {
 	};
 }
 /**
-* Look up a block override component by block kind.
-* Supports both full ("block.hero") and short ("hero") keys.
-*/
-function getBlockOverride(blockKind, overrides) {
-	if (!overrides) return void 0;
-	if (overrides[blockKind]) return overrides[blockKind];
-	const shortKind = blockKind.replace(/^block\./, "");
-	if (overrides[shortKind]) return overrides[shortKind];
-}
-const blockComponentCache = /* @__PURE__ */ new WeakMap();
-const DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS = 25;
-let cachedPerfSlowBlockRenderThresholdMs = null;
-function getPerfSlowBlockRenderThresholdMs() {
-	if (cachedPerfSlowBlockRenderThresholdMs !== null) return cachedPerfSlowBlockRenderThresholdMs;
-	const raw = globalThis.process?.env?.DEBUG_PERF_BLOCK_MS;
-	const parsed = raw ? Number.parseInt(raw, 10) : NaN;
-	cachedPerfSlowBlockRenderThresholdMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS;
-	return cachedPerfSlowBlockRenderThresholdMs;
-}
-function getCachedBlockComponent(manifest) {
-	const cached = blockComponentCache.get(manifest);
-	if (cached) return cached;
-	const created = makeDefaultBlockComponent({ manifest });
-	blockComponentCache.set(manifest, created);
-	return created;
-}
-/**
 * Memoized block section component.
 *
 * Custom memoization prevents render loops during editing by explicitly checking
 * referential equality of all props that affect rendering. Standard React.memo
 * wouldn't catch all the render triggers from the editor store.
 */
-const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources, block, dataContext, registry, routeMap, wrapBlock, blockOverrides, sdkConfig, customBlocks, imageResolveContext, previewAuthoring }) {
+const MemoBlockSection = React$1.memo(function MemoBlockSection(props) {
+	return renderBlockSection(props);
+}, (prev, next) => {
+	return prev.audience === next.audience && prev.block === next.block && prev.registry === next.registry && prev.dataContext === next.dataContext && prev.themeResources === next.themeResources && prev.routeMap === next.routeMap && prev.block.presentationAdmission === next.block.presentationAdmission && prev.wrapBlock === next.wrapBlock && prev.blockOverrides === next.blockOverrides && prev.sdkConfig === next.sdkConfig && prev.customBlocks === next.customBlocks && prev.imageResolveContext === next.imageResolveContext && prev.previewAuthoring === next.previewAuthoring;
+});
+/**
+* Renders a single block body.
+*
+* Returns `null` when the block cannot render and the audience is `public`;
+* the caller treats that as "this block is not on the page".
+*/
+function renderBlockSection({ audience, themeResources, block, dataContext, registry, routeMap, wrapBlock, blockOverrides, sdkConfig, customBlocks, imageResolveContext, previewAuthoring }) {
 	const perfStart = globalThis.process?.env?.DEBUG_PERF === "1" && typeof window === "undefined" ? Date.now() : 0;
 	const fallbackImageResolveContext = getCurrentResolveImageUrlContext();
 	const resolvedImageResolveContext = imageResolveContext ?? fallbackImageResolveContext;
@@ -64633,19 +65338,30 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 		} catch {}
 		return node;
 	}
-	if (block.presentationAdmission.kind === "invalid") {
-		try {
-			if (globalThis.process?.env?.NODE_ENV !== "production") console.warn("[blocks:PageRenderer] block admission failed", {
-				blockId: block.id ?? null,
-				blockKind: block.kind,
-				error: block.presentationAdmission.error
-			});
-		} catch {}
-		return finish(fallback(`Invalid content for block kind "${block.kind}".`), {
-			outcome: "invalidContent",
-			override: false
+	/**
+	* The one place that decides what a block that cannot render leaves behind.
+	* A public page gets nothing (and a log line, since dropping content on a
+	* 200 is otherwise invisible); authoring surfaces get the diagnostic.
+	*/
+	function diagnostic(message, detail) {
+		if (audience !== "public") return fallback(message);
+		warnOmittedFromPublicPage({
+			block,
+			...detail
 		});
+		return null;
 	}
+	function withBlockWrapper(node) {
+		if (node === null) return null;
+		return wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, node) }) : /* @__PURE__ */ jsx(Fragment, { children: node });
+	}
+	if (block.presentationAdmission.kind === "invalid") return finish(diagnostic(`Invalid content for block kind "${block.kind}".`, {
+		outcome: "invalidContent",
+		admissionError: block.presentationAdmission.error
+	}), {
+		outcome: "invalidContent",
+		override: false
+	});
 	const OverrideComponent = getBlockOverride(block.kind, blockOverrides);
 	requireBlockOverride(themeResources, OverrideComponent, block.kind);
 	let definition = getBlockDefinition(block.kind);
@@ -64658,25 +65374,14 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 	}).findManifest(block.kind)?.descriptor.definition;
 	if (!definition) {
 		if (OverrideComponent) {
-			const rendered = /* @__PURE__ */ jsx(OverrideComponent, {
+			const rendered = /* @__PURE__ */ jsx(OverrideComponent, { ...buildBlockOverrideProps({
+				block,
 				content: getRenderableContent(block, dataContext?.previewStage),
-				...overrideThemeProps(themeResources),
 				data: void 0,
-				siteId: dataContext?.siteId,
-				apiBaseUrl: dataContext?.apiBaseUrl,
-				portalToken: dataContext?.portalToken ?? null,
-				previewToken: dataContext?.previewToken ?? null,
-				stage: dataContext?.previewStage,
-				occurrenceContext: dataContext?.occurrenceContext ?? null,
-				entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
-				contentEntry: dataContext?.contentEntry ?? null,
-				pageSurface: dataContext?.pageSurface ?? null,
-				subject: dataContext?.subject ?? null,
-				supabaseUrl: dataContext?.supabaseUrl,
-				imageResolveContext: resolvedImageResolveContext,
-				blockId: block.id ?? null,
-				blockKind: block.kind
-			});
+				themeResources,
+				dataContext,
+				imageResolveContext: resolvedImageResolveContext
+			}) });
 			return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment, { children: rendered }), {
 				outcome: "overrideWithoutDefinition",
 				override: true,
@@ -64692,8 +65397,7 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 				dbCustomBlocksCount: customBlocks?.length ?? 0
 			});
 		} catch {}
-		const rendered = fallback(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". The custom block definition was not found (missing manifest).` : `No renderer available for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment, { children: rendered }), {
+		return finish(withBlockWrapper(diagnostic(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". The custom block definition was not found (missing manifest).` : `No renderer available for block kind "${block.kind}".`, { outcome: "missingDefinition" })), {
 			outcome: "missingDefinition",
 			override: false
 		});
@@ -64708,8 +65412,7 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 				manifestKeys: Object.keys(definition.manifest ?? {}).sort()
 			});
 		} catch {}
-		const rendered = fallback(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". This custom block has no layout/variants, so it must be rendered via blockOverrides["${block.kind}"].` : `No renderer available for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment, { children: rendered }), {
+		return finish(withBlockWrapper(diagnostic(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". This custom block has no layout/variants, so it must be rendered via blockOverrides["${block.kind}"].` : `No renderer available for block kind "${block.kind}".`, { outcome: "missingLayout" })), {
 			outcome: "missingLayout",
 			override: false
 		});
@@ -64719,39 +65422,24 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 	if (block.presentationAdmission.kind === "editor") {
 		const draft = validateManifestDraft(compileManifestContentContract(definition.manifest), content);
 		if (draft.kind === "previewable") data = draft.data;
-		else {
-			const rendered = fallback(`Unable to render block kind "${block.kind}".`);
-			return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment, { children: rendered }), {
-				outcome: "invalidPlaceholder",
-				override: false
-			});
-		}
+		else return finish(withBlockWrapper(diagnostic(`Unable to render block kind "${block.kind}".`, { outcome: "invalidPlaceholder" })), {
+			outcome: "invalidPlaceholder",
+			override: false
+		});
 	}
 	try {
 		const routes = routeMap ?? dataContext?.routes;
 		const hydratedContent = routes ? hydrateManifestLinks(definition.manifest, data, routes, dataContext?.pagesByIdentifier, dataContext?.entriesByIdentifier) : data;
 		const resolved = resolveBlockData$1(block.id, definition.dataLoaders, dataContext, routes);
 		const hasResolvedData = !!resolved && typeof resolved === "object" && Object.keys(resolved).length > 0;
-		const baseProps = {
+		const baseProps = buildBlockOverrideProps({
+			block,
 			content: hydratedContent,
-			...overrideThemeProps(themeResources),
 			data: resolved,
-			siteId: dataContext?.siteId,
-			apiBaseUrl: dataContext?.apiBaseUrl,
-			portalToken: dataContext?.portalToken ?? null,
-			previewToken: dataContext?.previewToken ?? null,
-			stage: dataContext?.previewStage,
-			occurrenceContext: dataContext?.occurrenceContext ?? null,
-			entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
-			contentEntry: dataContext?.contentEntry ?? null,
-			pageSurface: dataContext?.pageSurface ?? null,
-			subject: dataContext?.subject ?? null,
-			supabaseUrl: dataContext?.supabaseUrl,
-			imageResolveContext: resolvedImageResolveContext,
-			blockId: block.id ?? null,
-			blockKind: block.kind
-		};
-		baseProps.bookingTimeZone = resolveBookingTimeZone(dataContext);
+			themeResources,
+			dataContext,
+			imageResolveContext: resolvedImageResolveContext
+		});
 		let rendered;
 		if (OverrideComponent) rendered = /* @__PURE__ */ jsx(OverrideComponent, { ...baseProps });
 		else {
@@ -64798,39 +65486,11 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 			hasResolvedData
 		});
 	} catch {
-		const rendered = block.presentationAdmission.kind === "editor" ? fallback(`Unable to render block kind "${block.kind}".`) : fallback(`Invalid content for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment, { children: rendered }), {
+		return finish(withBlockWrapper(diagnostic(block.presentationAdmission.kind === "editor" ? `Unable to render block kind "${block.kind}".` : `Invalid content for block kind "${block.kind}".`, { outcome: "exception" })), {
 			outcome: "exception",
 			override: false
 		});
 	}
-}, (prev, next) => {
-	return prev.block === next.block && prev.registry === next.registry && prev.dataContext === next.dataContext && prev.themeResources === next.themeResources && prev.routeMap === next.routeMap && prev.block.presentationAdmission === next.block.presentationAdmission && prev.wrapBlock === next.wrapBlock && prev.blockOverrides === next.blockOverrides && prev.sdkConfig === next.sdkConfig && prev.customBlocks === next.customBlocks && prev.imageResolveContext === next.imageResolveContext && prev.previewAuthoring === next.previewAuthoring;
-});
-function fallback(message) {
-	return /* @__PURE__ */ jsx("div", {
-		className: "rb-p-6 rb-caption",
-		style: textColorStyle("mutedText"),
-		children: message
-	});
-}
-function shouldDebugCustomBlocks() {
-	try {
-		return globalThis.process?.env?.DEBUG_CUSTOM_BLOCKS === "1";
-	} catch {
-		return false;
-	}
-}
-/**
-* Resolves block content based on stage priority.
-* For draft/preview: draftContent takes priority over content.
-* For published: content is the source of truth.
-* Returns empty object if no content exists (validator will handle placeholders if needed).
-*/
-function getRenderableContent(block, previewStage = "published") {
-	const source = previewStage === "preview" && block.draftContent ? block.draftContent : block.content ?? {};
-	if (!isObjectRecord$1(source)) return {};
-	return source;
 }
 //#endregion
 //#region ../blocks/src/structure/schema.ts
@@ -74804,6 +75464,21 @@ const containerResponsiveThemeCss = `/*
   outline-offset: 2px;
 }
 
+/* Event titles always link to the event page, so a card or row whose CTA is
+   hidden (sold out, closed) is never a dead end (issue 1372). The link inherits
+   the heading's colour and only reveals itself on hover or keyboard focus.
+   Shared by EventCard, EventCompactRow and the offerings-preview course cards via \`.event-title-link\`. */
+:where(.theme-scope) .event-title-link {
+  color: inherit;
+  text-decoration: none;
+}
+
+:where(.theme-scope) .event-title-link:hover,
+:where(.theme-scope) .event-title-link:focus-visible {
+  text-decoration: underline;
+  text-underline-offset: 0.12em;
+}
+
 /* =============================================================================
  * Block: Carousel Navigation (Phase 3 client component migration)
  * =============================================================================
@@ -80151,6 +80826,50 @@ z$1.object({
 	title: z$1.string(),
 	slug: z$1.string().min(1)
 });
+z$1.object({
+	signedUrl: z$1.string().url(),
+	token: z$1.string().min(1),
+	storagePath: z$1.string().min(1)
+}).strict();
+const backupManifestSchema = z$1.object({
+	siteId: z$1.string().min(1),
+	siteSlug: z$1.string().min(1),
+	siteTitle: z$1.string(),
+	exportedAt: z$1.string().min(1),
+	tableCount: z$1.number().int().nonnegative(),
+	totalRecords: z$1.number().int().nonnegative(),
+	pageCount: z$1.number().int().nonnegative(),
+	blockCount: z$1.number().int().nonnegative(),
+	contentEntryCount: z$1.number().int().nonnegative(),
+	formCount: z$1.number().int().nonnegative(),
+	navigationMenuCount: z$1.number().int().nonnegative(),
+	mediaCount: z$1.number().int().nonnegative(),
+	mediaBytes: z$1.number().int().nonnegative()
+}).strict();
+z$1.object({
+	ok: z$1.literal(true),
+	manifest: backupManifestSchema,
+	storagePath: z$1.string().min(1)
+}).strict();
+z$1.object({
+	ok: z$1.literal(true),
+	siteId: brandedIdSchema(parseSiteId, "site id"),
+	slug: z$1.string().min(1),
+	title: z$1.string(),
+	counts: z$1.record(z$1.string(), z$1.object({
+		created: z$1.number().int().nonnegative(),
+		updated: z$1.number().int().nonnegative(),
+		skipped: z$1.number().int().nonnegative(),
+		failed: z$1.number().int().nonnegative()
+	}).strict()),
+	warnings: z$1.array(z$1.string()),
+	errors: z$1.array(z$1.object({
+		table: z$1.string(),
+		id: z$1.string(),
+		error: z$1.string()
+	}).strict())
+}).strict();
+z$1.object({ deleted: z$1.boolean() }).strict();
 const apiKeyIdSchema = brandedIdSchema(parseApiKeyId, "API key id");
 const standardKeyIdsSchema = z$1.object({
 	live: apiKeyIdSchema.optional(),
@@ -83942,9 +84661,7 @@ function admitMaterializedSdkTemplateBlockContent(input) {
 	const baseContent = sanitizeSdkRuntimeBlockContent(input.block.blockKind, input.block.content ?? {});
 	const bindings = input.block.bindings ?? {};
 	const materialized = input.block.scope === "entry" && Object.keys(bindings).length > 0 ? applyBindingsToContent(baseContent, bindings, input.bindingContext) : baseContent;
-	const contract = compileManifestContentContract(input.manifestOrFields);
-	const stored = admitStoredManifestContent(contract, materialized);
-	return stored.ok ? deriveRenderableManifestContent(contract, stored.value, (content) => content) : stored;
+	return admitTransportedRenderableManifestContent(compileManifestContentContract(input.manifestOrFields), materialized);
 }
 function createTemplateRenderTarget(source, templateId) {
 	switch (source.kind) {
@@ -84076,13 +84793,7 @@ function admitEntrySlotBlock(block, customBlocks) {
 	if (transportedAdmission) return invalidRenderableBlock(base, transportedAdmission.error);
 	const manifest = resolveSdkBlockManifest(block.kind, customBlocks);
 	if (manifest === null) return invalidRenderableBlock(base, { kind: "manifest_unavailable" });
-	const contract = compileManifestContentContract(manifest);
-	const stored = admitStoredManifestContent(contract, block.content ?? {});
-	if (!stored.ok) return invalidRenderableBlock(base, {
-		kind: "invalid_manifest_content",
-		error: stored.error
-	});
-	const renderable = deriveRenderableManifestContent(contract, stored.value, (content) => content);
+	const renderable = admitTransportedRenderableManifestContent(compileManifestContentContract(manifest), block.content ?? {});
 	return renderable.ok ? {
 		...base,
 		admission: {
@@ -85783,7 +86494,7 @@ var CircuitOpenError = class extends Error {
 * 1. This constant
 * 2. The "version" field in package.json
 */
-const SDK_VERSION = "0.136.0";
+const SDK_VERSION = "0.137.0";
 //#endregion
 //#region src/next/content-load-failure.ts
 const SdkContentLoadError = RiverbankContentLoadError;