@riverbankcms/sdk 0.135.1 → 0.136.0

package/dist/client/hooks.mjs

@@ -1200,6 +1200,13 @@ const PUBLIC_WHOLE_SERIES_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 //#endregion
 //#region ../api/src/publicEventEndpointDefinitions.ts
 const PUBLIC_EVENT_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
+	resolvePublicEventCheckoutReturn: {
+		path: "/public/sites/{siteId}/events/checkout-return",
+		method: "POST",
+		tags: [TAG_TEMPLATES.publicEvents, "event-checkout"],
+		auth: "public",
+		responseKind: "json"
+	},
 	getPublicEventRegistrationOptions: {
 		path: "/public/sites/{siteId}/events/registration-options",
 		method: "POST",
@@ -1709,7 +1716,7 @@ const parseUserId = (value) => parseUuidBrand(value, unsafeAsUserId);
 const parseEventSeriesId = (value) => parseUuidBrand(value, unsafeAsEventSeriesId);
 //#endregion
 //#region ../core/src/assert-never.ts
-function assertNever$2(value, message = "Unexpected variant") {
+function assertNever$3(value, message = "Unexpected variant") {
 	throw new Error(`${message}: ${String(value)}`);
 }
 //#endregion
@@ -1798,7 +1805,7 @@ function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
 	};
 }
 function parseEventPageSurfaceSubject(value) {
-	if (!isRecord$10(value)) return err({ kind: "notObject" });
+	if (!isRecord$14(value)) return err({ kind: "notObject" });
 	switch (value.kind) {
 		case "eventSeries": {
 			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
@@ -1843,7 +1850,7 @@ function parseEventPageSurfaceSubject(value) {
 		});
 	}
 }
-function isRecord$10(value) {
+function isRecord$14(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -1931,6 +1938,9 @@ function getZonedDateTimeParts(date, timeZone) {
 function formatDateKey(date) {
 	return `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`;
 }
+function toBookingTimeZone(timeZone) {
+	return getSafeTimeZone(timeZone);
+}
 function parseUtcIsoDateTimeString(value) {
 	const normalized = value.trim();
 	const hasUtcSuffix = normalized.endsWith("Z");
@@ -2438,7 +2448,7 @@ const entryLinkSchema$1 = z.object({
 	contentType: z.string().min(1),
 	identifier: z.string().min(1)
 }).passthrough();
-z.union([
+const linkSchema = z.union([
 	internalLinkSchema,
 	externalLinkSchema$1,
 	customLinkSchema$1,
@@ -8889,7 +8899,7 @@ function asDesignSystemTemplateId(value) {
 function makeBoundaryId(previousBlockId, nextBlockId) {
 	return asDesignBoundaryId(`boundary:${encodeURIComponent(previousBlockId)}:${encodeURIComponent(nextBlockId)}`);
 }
-function assertNever$1(value, message = "Unhandled Theme V2 variant") {
+function assertNever$2(value, message = "Unhandled Theme V2 variant") {
 	throw new Error(`${message}: ${String(value)}`);
 }
 function brandNonEmptyString(value, label) {
@@ -9146,12 +9156,8 @@ const legacyHeaderVariantValues = Object.keys(legacyHeaderVariants);
 * `@riverbankcms/api` is `z.input<typeof themeSchema>`, so a widened input here
 * would leak straight into a public type.
 *
-* Not every read of a persisted theme goes through the schema:
-* `resolveRuntimeTheme` in
-* `apps/dashboard/src/server/services/sites/runtimeSiteResponse.ts` returns the
-* raw database JSON asserted as `Theme` with no parse, so a theme still
-* carrying a legacy spelling reaches the theme editor un-aliased. That gap
-* predates this alias and is harmless while persisted usage is zero.
+* Persisted runtime themes are admitted through `parseThemeForPersistence`
+* before reaching consumers, so legacy spellings normalize at that boundary.
 */
 const headerVariantWithLegacyAliasSchema = z.enum([...headerVariantValues, ...legacyHeaderVariantValues]).transform((value) => value in legacyHeaderVariants ? legacyHeaderVariants[value] : value);
 const BREAKPOINT_LG = 1024;
@@ -9265,7 +9271,7 @@ const boxBackgroundSchema = z.discriminatedUnion("type", [
 	})
 ]);
 function normalizeAuthoringOpacity(value) {
-	if (!isRecord$9(value)) return value;
+	if (!isRecord$13(value)) return value;
 	return {
 		...value,
 		opacity: normalizeOpacity(value.opacity)
@@ -9274,7 +9280,7 @@ function normalizeAuthoringOpacity(value) {
 function normalizeOpacity(value) {
 	return typeof value === "number" && value > 1 && value <= 100 ? value / 100 : value;
 }
-function isRecord$9(value) {
+function isRecord$13(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -9610,7 +9616,6 @@ const navFontWeight = z.enum([
 	"bold"
 ]);
 const headerMaxWidth = z.enum(["container", "full"]);
-const headerBarFrame = z.enum(["full-bleed", "inset-shell"]);
 const headerBorderSchema = componentBorderSchema.extend({ position: z.enum([
 	"bottom",
 	"top",
@@ -9639,12 +9644,6 @@ const headerLogoTextSchema = z.object({
 	]).optional(),
 	hideOnShrink: z.boolean().optional()
 }).optional();
-const navEffectsSchema = z.object({
-	underlineGradient: z.boolean().default(false),
-	glow: z.boolean().default(false),
-	glowColor: z.string().optional(),
-	neumorphic: z.boolean().default(false)
-}).optional();
 const dropdownStyleSchema = z.object({
 	background: themeColorTokenSchema.default("surface"),
 	textColor: themeColorTokenSchema.default("text"),
@@ -9736,9 +9735,7 @@ const headerSchema = z.object({
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
 	maxWidth: headerMaxWidth,
-	barFrame: headerBarFrame.optional(),
 	scrollTreatment: headerScrollTreatmentSchema,
-	logoOverride: mediaSchema.nullable().optional(),
 	background: headerBackgroundSchema.default({
 		type: "color",
 		color: "surface"
@@ -9750,13 +9747,11 @@ const headerSchema = z.object({
 	navFontRole: z.enum(["body", "heading"]).optional(),
 	navTextSize: navLinkStyleSchema.shape.textSize,
 	interactionPalette: headerInteractionPaletteSchema.optional(),
-	navPlacement: z.enum(["end", "center"]).optional(),
 	container: headerContainerSchema,
 	border: headerBorderSchema,
 	shadow: componentShadowSchema.optional(),
 	logo: logoStyleSchema,
 	logoText: headerLogoTextSchema,
-	navEffects: navEffectsSchema,
 	navContainer: navContainerSchema,
 	navLinkStyle: navLinkStyleSchema.optional(),
 	ctaGap: headerCtaGapSchema.optional(),
@@ -11851,27 +11846,6 @@ function asHeaderStyleId(value) {
 	return value;
 }
 //#endregion
-//#region ../theme-core/src/site-styles/headerInteractionPalette.ts
-const clearSplitInteractionPalette = defineLookOptionGroup({
-	id: "interaction-palette",
-	label: "Hover colour",
-	defaultOptionId: "accent",
-	options: [
-		{
-			id: "accent",
-			label: "Accent"
-		},
-		{
-			id: "primary",
-			label: "Primary"
-		},
-		{
-			id: "secondary",
-			label: "Secondary"
-		}
-	]
-});
-//#endregion
 //#region ../theme-core/src/site-styles/headerLayoutCatalog.ts
 const titleOnlyLogoAccommodation = {
 	pattern: "title-only",
@@ -12031,43 +12005,37 @@ const headerStyleCatalog = defineExactCatalog()([
 		id: asHeaderStyleId("minimal"),
 		label: "Minimal",
 		description: "Quiet surface with simple color-change navigation.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("fine-line"),
 		label: "Seamless",
 		description: "Borderless surface with underline hover for a quieter page transition.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("soft-bar"),
 		label: "Soft Bar",
 		description: "Soft tinted surface with gentle pill hover states.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("pill-nav"),
 		label: "Pill Nav",
 		description: "A calm pill navigation rail over a neutral header.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("brand-bar"),
 		label: "Brand Bar",
 		description: "Solid brand surface with high-contrast navigation.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "brand-caps"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("brand-underline"),
 		label: "Brand Underline",
 		description: "Brand surface with underline-grow navigation.",
-		supportedLayoutIds: supportedLayouts(["classic"]),
-		navTypography: "brand-caps"
+		supportedLayoutIds: supportedLayouts(["classic"])
 	},
 	{
 		id: asHeaderStyleId("brand-pill"),
@@ -12077,73 +12045,78 @@ const headerStyleCatalog = defineExactCatalog()([
 			"classic",
 			"centered",
 			"floating"
-		]),
-		navTypography: "brand-caps"
+		])
 	},
 	{
 		id: asHeaderStyleId("brand-capsule"),
 		label: "Brand Capsule",
 		description: "Solid brand chrome designed as a floating capsule, with quiet-caps nav, a soft pill active state, and an inverted CTA pill.",
-		supportedLayoutIds: supportedLayouts(["classic"]),
-		navTypography: "quiet-caps"
+		supportedLayoutIds: supportedLayouts(["classic"])
 	},
 	{
 		id: asHeaderStyleId("serif-line"),
 		label: "Serif Line",
 		description: "Typographic logo treatment with understated underline navigation.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "heading"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("flat-tabs"),
 		label: "Flat Tabs",
 		description: "Flat block hover and active states with a Swiss utility feel.",
-		supportedLayoutIds: supportedLayouts(["classic", "centered"]),
-		navTypography: "quiet-caps"
+		supportedLayoutIds: supportedLayouts(["classic", "centered"])
 	},
 	{
 		id: asHeaderStyleId("glass"),
 		label: "Glass",
 		description: "Translucent chrome with frosted navigation backing.",
-		supportedLayoutIds: supportedLayouts(["floating"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["floating"])
 	},
 	{
 		id: asHeaderStyleId("minimal-surface"),
 		label: "Clear Split",
 		description: "Floating logo with transparent navigation and no shared shell.",
-		supportedLayoutIds: supportedLayouts(["floating"]),
-		navTypography: "plain",
-		openingForegroundTarget: "all",
-		scrollTreatment: "contrast-glass",
-		interactionPalette: clearSplitInteractionPalette
+		supportedLayoutIds: supportedLayouts(["floating"])
 	},
 	{
 		id: asHeaderStyleId("soft-shell"),
 		label: "Soft Shell",
 		description: "Floating rounded shell with soft pill navigation states.",
-		supportedLayoutIds: supportedLayouts(["floating"]),
-		navTypography: "plain"
+		supportedLayoutIds: supportedLayouts(["floating"])
 	},
 	{
 		id: asHeaderStyleId("split-glass"),
 		label: "Split Glass",
 		description: "Logo floats independently while the navigation sits in a glass rail.",
-		supportedLayoutIds: supportedLayouts(["floating"]),
-		navTypography: "quiet-caps",
-		openingForegroundTarget: "brand-only"
+		supportedLayoutIds: supportedLayouts(["floating"])
 	},
 	{
 		id: asHeaderStyleId("split-pill"),
 		label: "Split Pill",
 		description: "Logo floats independently with a soft pill-backed navigation rail.",
-		supportedLayoutIds: supportedLayouts(["floating"]),
-		navTypography: "heading",
-		openingForegroundTarget: "brand-only"
+		supportedLayoutIds: supportedLayouts(["floating"])
 	}
 ]);
 new Map(headerLayoutCatalog.map((layout) => [layout.id, layout]));
 new Map(headerStyleCatalog.map((style) => [style.id, style]));
+defineLookOptionGroup({
+	id: "interaction-palette",
+	label: "Hover colour",
+	defaultOptionId: "accent",
+	options: [
+		{
+			id: "accent",
+			label: "Accent"
+		},
+		{
+			id: "primary",
+			label: "Primary"
+		},
+		{
+			id: "secondary",
+			label: "Secondary"
+		}
+	]
+});
 //#endregion
 //#region ../theme-core/src/site-styles/footerLooks.ts
 function asFooterLookId(value) {
@@ -14829,7 +14802,7 @@ function planSiteChromePlacement(positioning) {
 			headerRootClassName: "rb-fixed rb-top-0 rb-left-0 rb-right-0",
 			standaloneShellClassName: "fixed left-0 right-0 top-0 z-40 w-full"
 		};
-		default: return assertNever$1(positioning);
+		default: return assertNever$2(positioning);
 	}
 }
 //#endregion
@@ -14896,14 +14869,9 @@ function formatKeyAsLabel(key) {
 	return key.replace(/([A-Z])/g, " $1").replace(/[-_]/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
 //#endregion
-//#region ../blocks/src/system/manifest/registry.ts
-const REGISTRY_SYMBOL$1 = Symbol.for("@riverbankcms/blocks/manifest-registry");
-const isBlocksTestRuntime$1 = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.RIVERBANK_BLOCKS_TEST === "1";
-const globalScope$1 = globalThis;
-const manifestStore = isBlocksTestRuntime$1 ? /* @__PURE__ */ new Map() : globalScope$1[REGISTRY_SYMBOL$1] ?? (globalScope$1[REGISTRY_SYMBOL$1] = /* @__PURE__ */ new Map());
-function registerManifest(manifest) {
-	manifestStore.set(manifest.name, manifest);
-	return manifest;
+//#region ../media-core/src/typeGuards.ts
+function isRecord$12(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 //#endregion
 //#region ../media-core/src/transformRect.ts
@@ -14997,6 +14965,37 @@ function rotateNormalizedPoint(point, rotation) {
 	}
 }
 //#endregion
+//#region ../media-core/src/mediaRefNormalizer.ts
+function looksLikeUuid(value) {
+	return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+/**
+* Strip environment-specific keys from a CMS media object.
+* @mutates Mutates the passed object in-place.
+*/
+function deleteEnvSpecificKeys(obj) {
+	delete obj.assetId;
+	delete obj.storageBucket;
+	delete obj.storagePath;
+	delete obj.src;
+	delete obj.mimeType;
+	if (looksLikeUuid(obj.id)) delete obj.id;
+}
+//#endregion
+//#region ../media-core/src/richTextImageCollector.ts
+function walkAndCollectImageAttrs(value, out, location = "") {
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => walkAndCollectImageAttrs(item, out, `${location}[${index}]`));
+		return;
+	}
+	if (!isRecord$12(value)) return;
+	if (value.type === "image" && isRecord$12(value.attrs)) out.push({
+		attrs: value.attrs,
+		location: location ? `${location}.attrs` : "attrs"
+	});
+	for (const [key, child] of Object.entries(value)) walkAndCollectImageAttrs(child, out, location ? `${location}.${key}` : key);
+}
+//#endregion
 //#region ../blocks/src/system/node/schema.ts
 const transformStepSchema = z.object({
 	id: z.string().min(1, "Transform requires an identifier"),
@@ -15644,6 +15643,14 @@ function parseFieldDefinition(input) {
 function parseFieldDefinitions(input) {
 	return fieldSchema.array().parse(input);
 }
+/**
+* Normalize legacy select fields into the closed source union before any consumer
+* branches on source semantics. Runtime-backed definitions must be explicit;
+* legacy static definitions normalize to `kind: "static"`.
+*/
+function normalizeSelectSource(field) {
+	return field.source ?? { kind: "static" };
+}
 function expectParsedSelectField(field) {
 	if (field.type !== "select") throw new Error(`Expected select field, received ${field.type}`);
 	return field;
@@ -15802,6 +15809,1932 @@ z.object({
 	tags: z.array(z.string()).optional(),
 	icon: z.string().optional()
 });
+const inlineTextMarkSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("strong") }),
+	z.object({ kind: z.literal("emphasis") }),
+	z.object({
+		kind: z.literal("accent"),
+		tone: z.enum([
+			"accent",
+			"brand",
+			"contrast"
+		])
+	}),
+	z.object({
+		kind: z.literal("highlight"),
+		tone: z.enum([
+			"soft",
+			"accent",
+			"brand"
+		])
+	})
+]);
+const inlineTextRunSchema = z.object({
+	text: z.string(),
+	marks: z.array(inlineTextMarkSchema).optional()
+});
+z.array(inlineTextRunSchema);
+const MARK_ORDER = {
+	strong: 0,
+	emphasis: 1,
+	accent: 2,
+	highlight: 3
+};
+function plainTextToInlineText(value) {
+	return normalizeInlineText(value.length > 0 ? [{ text: value }] : []);
+}
+function inlineTextToPlainText(value) {
+	return value.map((run) => run.text).join("");
+}
+function parseInlineTextFromUnknown(value) {
+	if (!Array.isArray(value)) return {
+		ok: false,
+		error: { kind: "not-array" }
+	};
+	const runs = [];
+	for (let index = 0; index < value.length; index += 1) {
+		const parsed = inlineTextRunSchema.safeParse(value[index]);
+		if (!parsed.success) return {
+			ok: false,
+			error: {
+				kind: "invalid-run",
+				index
+			}
+		};
+		runs.push(parsed.data);
+	}
+	return {
+		ok: true,
+		value: normalizeInlineText(runs)
+	};
+}
+function normalizeInlineText(value) {
+	const normalized = [];
+	for (const run of value) {
+		if (run.text.length === 0) continue;
+		const marks = normalizeInlineTextMarks(run.marks ?? []);
+		const nextRun = marks.length > 0 ? {
+			text: run.text,
+			marks
+		} : { text: run.text };
+		const previous = normalized[normalized.length - 1];
+		if (previous && inlineTextMarksEqual(previous.marks ?? [], nextRun.marks ?? [])) {
+			normalized[normalized.length - 1] = previous.marks && previous.marks.length > 0 ? {
+				text: previous.text + nextRun.text,
+				marks: previous.marks
+			} : { text: previous.text + nextRun.text };
+			continue;
+		}
+		normalized.push(nextRun);
+	}
+	return normalized;
+}
+function normalizeInlineTextMarks(marks) {
+	let strong = null;
+	let emphasis = null;
+	let accent = null;
+	let highlight = null;
+	for (const mark of marks) switch (mark.kind) {
+		case "strong":
+			strong = { kind: "strong" };
+			break;
+		case "emphasis":
+			emphasis = { kind: "emphasis" };
+			break;
+		case "accent":
+			accent = {
+				kind: "accent",
+				tone: mark.tone
+			};
+			break;
+		case "highlight":
+			highlight = {
+				kind: "highlight",
+				tone: mark.tone
+			};
+			break;
+	}
+	return [
+		strong,
+		emphasis,
+		accent,
+		highlight
+	].filter((mark) => mark !== null).sort((left, right) => MARK_ORDER[left.kind] - MARK_ORDER[right.kind]);
+}
+function inlineTextMarksEqual(left, right) {
+	const normalizedLeft = normalizeInlineTextMarks(left);
+	const normalizedRight = normalizeInlineTextMarks(right);
+	if (normalizedLeft.length !== normalizedRight.length) return false;
+	return normalizedLeft.every((mark, index) => inlineTextMarkEqual(mark, normalizedRight[index]));
+}
+function inlineTextMarkEqual(left, right) {
+	if (!right || left.kind !== right.kind) return false;
+	switch (left.kind) {
+		case "strong":
+		case "emphasis": return true;
+		case "accent": return right.kind === "accent" && left.tone === right.tone;
+		case "highlight": return right.kind === "highlight" && left.tone === right.tone;
+	}
+}
+//#endregion
+//#region ../blocks/src/system/icons/ids.ts
+const GENERATED_ICON_SET_ID_PATTERN = /^generated-icon-set:[a-z0-9][a-z0-9:_-]{0,107}$/u;
+const GENERATED_ICON_ASSET_ID_PATTERN = /^generated-icon-asset:[a-z0-9][a-z0-9:_-]{0,105}$/u;
+const SITE_ICON_STYLE_GUIDE_VERSION_ID_PATTERN = /^site-icon-style-guide:[a-f0-9]{16}$/u;
+function normalizeString(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function unsafeAsGeneratedIconSetId(value) {
+	return value;
+}
+function unsafeAsGeneratedIconAssetId(value) {
+	return value;
+}
+function unsafeAsSiteIconStyleGuideVersionId(value) {
+	return value;
+}
+function parseGeneratedIconSetId(value) {
+	const normalized = normalizeString(value);
+	return normalized !== null && GENERATED_ICON_SET_ID_PATTERN.test(normalized) ? unsafeAsGeneratedIconSetId(normalized) : null;
+}
+function parseGeneratedIconAssetId(value) {
+	const normalized = normalizeString(value);
+	return normalized !== null && GENERATED_ICON_ASSET_ID_PATTERN.test(normalized) ? unsafeAsGeneratedIconAssetId(normalized) : null;
+}
+function parseSiteIconStyleGuideVersionId(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return SITE_ICON_STYLE_GUIDE_VERSION_ID_PATTERN.test(normalized) ? unsafeAsSiteIconStyleGuideVersionId(normalized) : null;
+}
+//#endregion
+//#region ../blocks/src/system/icons/semantic.ts
+const SEMANTIC_ICON_IDS = [
+	"protection-trust",
+	"confidentiality",
+	"care-support",
+	"partnership",
+	"warmth",
+	"community",
+	"personal-guidance",
+	"conversation",
+	"friendly-welcome",
+	"insight-learning",
+	"natural-wellbeing",
+	"growth",
+	"gentle-care",
+	"special-touch",
+	"ideas",
+	"direction",
+	"focus",
+	"quality",
+	"highlight",
+	"verified-quality",
+	"learning",
+	"training",
+	"programmes-dates",
+	"place",
+	"products",
+	"packages",
+	"time",
+	"practical-service",
+	"at-home",
+	"worldwide",
+	"professional-service"
+];
+const featurePreset = ["feature"];
+[
+	{
+		id: "protection-trust",
+		label: "Protection and trust",
+		tags: [
+			"safe",
+			"safety",
+			"security",
+			"trust",
+			"privacy",
+			"confidence"
+		],
+		domains: [
+			"wellbeing",
+			"services",
+			"technology"
+		],
+		tone: ["trustworthy", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "confidentiality",
+		label: "Confidentiality",
+		tags: [
+			"confidential",
+			"privacy",
+			"secure",
+			"protected",
+			"private"
+		],
+		domains: [
+			"wellbeing",
+			"coaching",
+			"services",
+			"technology"
+		],
+		tone: ["trustworthy", "calm"],
+		presets: featurePreset
+	},
+	{
+		id: "care-support",
+		label: "Care and support",
+		tags: [
+			"care",
+			"support",
+			"therapy",
+			"kindness",
+			"help",
+			"compassion"
+		],
+		domains: [
+			"wellbeing",
+			"coaching",
+			"community"
+		],
+		tone: ["warm", "human"],
+		presets: featurePreset
+	},
+	{
+		id: "partnership",
+		label: "Partnership",
+		tags: [
+			"partnership",
+			"together",
+			"support",
+			"relationship",
+			"collaboration"
+		],
+		domains: [
+			"coaching",
+			"community",
+			"services"
+		],
+		tone: [
+			"warm",
+			"human",
+			"trustworthy"
+		],
+		presets: featurePreset
+	},
+	{
+		id: "warmth",
+		label: "Warmth",
+		tags: [
+			"heart",
+			"warmth",
+			"care",
+			"love",
+			"wellbeing",
+			"personal"
+		],
+		domains: [
+			"wellbeing",
+			"community",
+			"hospitality"
+		],
+		tone: ["warm", "human"],
+		presets: featurePreset
+	},
+	{
+		id: "community",
+		label: "Community",
+		tags: [
+			"community",
+			"group",
+			"people",
+			"team",
+			"members",
+			"belonging"
+		],
+		domains: [
+			"community",
+			"education",
+			"events"
+		],
+		tone: ["human", "warm"],
+		presets: featurePreset
+	},
+	{
+		id: "personal-guidance",
+		label: "Personal guidance",
+		tags: [
+			"guidance",
+			"personal",
+			"coach",
+			"expert",
+			"one to one",
+			"trusted"
+		],
+		domains: [
+			"coaching",
+			"services",
+			"education"
+		],
+		tone: ["trustworthy", "human"],
+		presets: featurePreset
+	},
+	{
+		id: "conversation",
+		label: "Conversation",
+		tags: [
+			"conversation",
+			"talk",
+			"chat",
+			"communication",
+			"support"
+		],
+		domains: [
+			"coaching",
+			"community",
+			"services"
+		],
+		tone: ["human", "warm"],
+		presets: featurePreset
+	},
+	{
+		id: "friendly-welcome",
+		label: "Friendly welcome",
+		tags: [
+			"friendly",
+			"welcome",
+			"positive",
+			"happy",
+			"approachable"
+		],
+		domains: [
+			"hospitality",
+			"community",
+			"services"
+		],
+		tone: [
+			"warm",
+			"playful",
+			"human"
+		],
+		presets: featurePreset
+	},
+	{
+		id: "insight-learning",
+		label: "Insight and learning",
+		tags: [
+			"mind",
+			"insight",
+			"learning",
+			"clarity",
+			"thinking",
+			"therapy"
+		],
+		domains: [
+			"wellbeing",
+			"coaching",
+			"education"
+		],
+		tone: ["calm", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "natural-wellbeing",
+		label: "Natural wellbeing",
+		tags: [
+			"natural",
+			"wellbeing",
+			"growth",
+			"eco",
+			"calm",
+			"organic"
+		],
+		domains: [
+			"wellbeing",
+			"hospitality",
+			"creative"
+		],
+		tone: ["calm", "warm"],
+		presets: featurePreset
+	},
+	{
+		id: "growth",
+		label: "Growth",
+		tags: [
+			"growth",
+			"new",
+			"progress",
+			"development",
+			"nurture"
+		],
+		domains: [
+			"wellbeing",
+			"coaching",
+			"education",
+			"community"
+		],
+		tone: ["warm", "calm"],
+		presets: featurePreset
+	},
+	{
+		id: "gentle-care",
+		label: "Gentle care",
+		tags: [
+			"gentle",
+			"soft",
+			"care",
+			"wellbeing",
+			"beauty",
+			"calm"
+		],
+		domains: [
+			"wellbeing",
+			"creative",
+			"hospitality"
+		],
+		tone: [
+			"warm",
+			"calm",
+			"premium"
+		],
+		presets: featurePreset
+	},
+	{
+		id: "special-touch",
+		label: "Special touch",
+		tags: [
+			"special",
+			"sparkle",
+			"magic",
+			"polish",
+			"delight",
+			"creative"
+		],
+		domains: [
+			"creative",
+			"commerce",
+			"hospitality"
+		],
+		tone: ["playful", "premium"],
+		presets: featurePreset
+	},
+	{
+		id: "ideas",
+		label: "Ideas",
+		tags: [
+			"idea",
+			"innovation",
+			"clarity",
+			"creative",
+			"strategy"
+		],
+		domains: [
+			"coaching",
+			"education",
+			"creative",
+			"technology"
+		],
+		tone: ["practical", "playful"],
+		presets: featurePreset
+	},
+	{
+		id: "direction",
+		label: "Direction",
+		tags: [
+			"direction",
+			"navigation",
+			"path",
+			"journey",
+			"guidance"
+		],
+		domains: [
+			"coaching",
+			"education",
+			"services"
+		],
+		tone: ["trustworthy", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "focus",
+		label: "Focus",
+		tags: [
+			"focus",
+			"goal",
+			"outcome",
+			"aim",
+			"strategy"
+		],
+		domains: [
+			"coaching",
+			"services",
+			"technology"
+		],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "quality",
+		label: "Quality",
+		tags: [
+			"quality",
+			"award",
+			"standard",
+			"achievement",
+			"premium"
+		],
+		domains: [
+			"services",
+			"education",
+			"commerce"
+		],
+		tone: ["premium", "trustworthy"],
+		presets: featurePreset
+	},
+	{
+		id: "highlight",
+		label: "Highlight",
+		tags: [
+			"highlight",
+			"featured",
+			"favorite",
+			"quality",
+			"special"
+		],
+		domains: [
+			"creative",
+			"commerce",
+			"services"
+		],
+		tone: ["playful", "premium"],
+		presets: featurePreset
+	},
+	{
+		id: "verified-quality",
+		label: "Verified quality",
+		tags: [
+			"verified",
+			"quality",
+			"approved",
+			"trusted",
+			"check"
+		],
+		domains: [
+			"services",
+			"commerce",
+			"education"
+		],
+		tone: ["trustworthy", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "learning",
+		label: "Learning",
+		tags: [
+			"learning",
+			"book",
+			"course",
+			"knowledge",
+			"education"
+		],
+		domains: [
+			"education",
+			"coaching",
+			"community"
+		],
+		tone: ["calm", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "training",
+		label: "Training",
+		tags: [
+			"training",
+			"course",
+			"qualification",
+			"school",
+			"education"
+		],
+		domains: ["education", "coaching"],
+		tone: ["trustworthy", "practical"],
+		presets: featurePreset
+	},
+	{
+		id: "programmes-dates",
+		label: "Programmes and dates",
+		tags: [
+			"calendar",
+			"dates",
+			"schedule",
+			"events",
+			"programme",
+			"classes"
+		],
+		domains: [
+			"events",
+			"education",
+			"community"
+		],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "place",
+		label: "Place",
+		tags: [
+			"place",
+			"location",
+			"local",
+			"venue",
+			"destination"
+		],
+		domains: [
+			"events",
+			"hospitality",
+			"services"
+		],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "products",
+		label: "Products",
+		tags: [
+			"products",
+			"shop",
+			"store",
+			"retail",
+			"commerce"
+		],
+		domains: ["commerce"],
+		tone: ["practical", "premium"],
+		presets: featurePreset
+	},
+	{
+		id: "packages",
+		label: "Packages",
+		tags: [
+			"package",
+			"bundle",
+			"delivery",
+			"offer",
+			"product"
+		],
+		domains: ["commerce", "services"],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "time",
+		label: "Time",
+		tags: [
+			"time",
+			"duration",
+			"schedule",
+			"availability",
+			"appointment"
+		],
+		domains: [
+			"events",
+			"services",
+			"wellbeing"
+		],
+		tone: ["practical", "calm"],
+		presets: featurePreset
+	},
+	{
+		id: "practical-service",
+		label: "Practical service",
+		tags: [
+			"service",
+			"repair",
+			"setup",
+			"practical",
+			"tools",
+			"support"
+		],
+		domains: ["services", "technology"],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "at-home",
+		label: "At home",
+		tags: [
+			"home",
+			"domestic",
+			"comfort",
+			"local",
+			"space"
+		],
+		domains: [
+			"hospitality",
+			"services",
+			"community"
+		],
+		tone: ["warm", "calm"],
+		presets: featurePreset
+	},
+	{
+		id: "worldwide",
+		label: "Worldwide",
+		tags: [
+			"global",
+			"online",
+			"worldwide",
+			"remote",
+			"international"
+		],
+		domains: [
+			"technology",
+			"education",
+			"services"
+		],
+		tone: ["practical"],
+		presets: featurePreset
+	},
+	{
+		id: "professional-service",
+		label: "Professional service",
+		tags: [
+			"business",
+			"professional",
+			"consulting",
+			"service",
+			"work"
+		],
+		domains: [
+			"services",
+			"technology",
+			"coaching"
+		],
+		tone: ["practical", "trustworthy"],
+		presets: featurePreset
+	}
+].map(({ id, label }) => ({
+	id,
+	label
+}));
+function isSemanticIconId(value) {
+	return typeof value === "string" && SEMANTIC_ICON_IDS.includes(value);
+}
+//#endregion
+//#region ../blocks/src/system/icons/value.ts
+const NO_BLOCK_ICON_VALUE = { kind: "none" };
+function isRecord$11(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseBlockIconValue(value) {
+	if (isSemanticIconId(value)) return {
+		kind: "semantic",
+		iconId: value
+	};
+	if (!isRecord$11(value)) return NO_BLOCK_ICON_VALUE;
+	switch (value.kind) {
+		case "none": return NO_BLOCK_ICON_VALUE;
+		case "semantic": return isSemanticIconId(value.iconId) ? {
+			kind: "semantic",
+			iconId: value.iconId
+		} : NO_BLOCK_ICON_VALUE;
+		case "generated": {
+			const setId = parseGeneratedIconSetId(value.setId);
+			const assetId = parseGeneratedIconAssetId(value.assetId);
+			const styleGuideVersionId = parseSiteIconStyleGuideVersionId(value.styleGuideVersionId);
+			if (setId !== null && assetId !== null && styleGuideVersionId !== null) return {
+				kind: "generated",
+				setId,
+				assetId,
+				styleGuideVersionId
+			};
+			return NO_BLOCK_ICON_VALUE;
+		}
+		default: return NO_BLOCK_ICON_VALUE;
+	}
+}
+//#endregion
+//#region ../blocks/src/lib/typeGuards.ts
+/**
+* Strict record guard: excludes null, primitives, and arrays.
+*/
+function isRecord$10(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Non-null object guard: includes arrays for behavior parity with legacy helpers.
+*
+* NOTE: This intentionally narrows to UnknownRecord for compatibility with existing
+* callsites even though arrays pass at runtime. Follow-up cleanup should replace
+* this API with a more precise predicate type and migrate consumers.
+*/
+function isObjectRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region ../blocks/src/system/manifest/richTextSchema.ts
+/**
+* Shared Rich Text Schema
+*
+* This module provides a single source of truth for TipTap rich text validation
+* across both the block-form editor and the block rendering system.
+*
+* Rich-text fields use one canonical root shape:
+* `{ type: 'doc', content: [...] }`.
+*/
+/**
+* TipTap document node schema (recursive structure)
+*
+* Supports the full TipTap document structure including:
+* - type: Node type (e.g., 'doc', 'paragraph', 'text')
+* - content: Nested array of child nodes
+* - text: Text content for text nodes
+* - attrs: Node attributes (e.g., alignment, color)
+* - marks: Text formatting marks (e.g., bold, italic)
+*/
+const TipTapMarkSchema = z.object({
+	type: z.string().min(1),
+	attrs: z.record(z.string(), z.unknown()).optional()
+}).strict();
+const TipTapNodeSchema = z.lazy(() => z.object({
+	type: z.string().min(1),
+	content: z.array(TipTapNodeSchema).optional(),
+	text: z.string().optional(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	marks: z.array(TipTapMarkSchema).optional()
+}).strict().superRefine((node, ctx) => {
+	if (node.type === "doc") ctx.addIssue({
+		code: "custom",
+		path: ["type"],
+		message: "Document nodes are only valid at the rich-text root"
+	});
+	if (node.type === "text") {
+		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "Text nodes require a non-empty text value"
+		});
+		if (node.content !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["content"],
+			message: "Text nodes cannot contain child nodes"
+		});
+		return;
+	}
+	if (node.text !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["text"],
+		message: "Only text nodes can contain a text value"
+	});
+}));
+/**
+* Canonical schema for a TipTap rich-text document root.
+*
+* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
+* `content` is required (possibly empty). This is the shape every producer
+* (dummy content, editor output, migrations) must emit, and the shape every
+* non-legacy consumer can rely on.
+*
+*/
+const RichTextDocSchema = z.object({
+	type: z.literal("doc"),
+	content: z.array(TipTapNodeSchema)
+}).strict();
+/**
+* Type guard for {@link RichTextDoc}.
+*
+* Returns `true` only for the canonical unwrapped form. The shared structural
+* contract lives in `@riverbankcms/core`; parity tests keep its dependency-free
+* guard aligned with this detailed Zod validator.
+*/
+function isRichTextDoc(value) {
+	return RichTextDocSchema.safeParse(value).success;
+}
+//#endregion
+//#region ../blocks/src/lib/media.ts
+const PUBLIC_DOWNLOAD_MEDIA_TYPES = [
+	"document",
+	"spreadsheet",
+	"archive",
+	"audio"
+];
+//#endregion
+//#region ../blocks/src/system/manifest/fieldValidation/writeCanonicalization.ts
+function allGroupChildPlans(plan) {
+	return plan.childSelection.kind === "all" ? plan.childSelection.fields : plan.childSelection.tabs.flatMap((tab) => tab.fields);
+}
+function selectedGroupChildPlans(plan, value) {
+	if (plan.childSelection.kind === "all") return plan.childSelection.fields;
+	if (!isPlainObject$3(value)) return [];
+	const selectedType = value[plan.childSelection.activeTabField];
+	return plan.childSelection.tabs.find((tab) => tab.typeId === selectedType)?.fields ?? [];
+}
+function canonicalizeObjectForWrite(plans, value) {
+	if (!isPlainObject$3(value)) return value;
+	const canonical = { ...value };
+	for (const plan of plans) {
+		if (!(plan.fieldId in canonical)) continue;
+		canonical[plan.fieldId] = canonicalizeFieldValue(plan, canonical[plan.fieldId]);
+	}
+	return omitUndefined(canonical);
+}
+function canonicalizeFieldValue(plan, value) {
+	switch (plan.kind) {
+		case "media": return canonicalizeMedia(value);
+		case "group": return plan.childSelection.kind === "discriminatedTabs" ? canonicalizeDiscriminatedGroup(plan, value) : canonicalizeObjectForWrite(plan.childSelection.fields, value);
+		case "repeater": return canonicalizeRepeater(plan, value);
+		case "string":
+		case "number":
+		case "boolean":
+		case "richText":
+		case "inlineText":
+		case "link":
+		case "select":
+		case "passthrough": return value;
+	}
+}
+function canonicalizeMedia(value) {
+	if (!isPlainObject$3(value)) return value;
+	const canonical = { ...value };
+	if (mediaIdentifierSchema.safeParse(canonical.identifier).success) deleteEnvSpecificKeys(canonical);
+	return canonical;
+}
+function canonicalizeRepeater(plan, value) {
+	if (!isUnknownArray$1(value)) return value;
+	return value.map((item) => {
+		if (!isPlainObject$3(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$3(value) || plan.childSelection.kind !== "discriminatedTabs") return value;
+	const selection = plan.childSelection;
+	const selectedPlans = selectedGroupChildPlans(plan, value);
+	const selectedIds = rootFieldIds(selectedPlans);
+	const allChildIds = rootFieldIds(allGroupChildPlans(plan));
+	const canonical = omitUndefined(canonicalizeObjectForWrite(selectedPlans, Object.fromEntries(Object.entries(value).filter(([key]) => key === selection.activeTabField || selectedIds.has(key) || !allChildIds.has(key)))));
+	if (plan.valueContract !== "boxBackground") return canonical;
+	const parsed = boxBackgroundSchema.safeParse(canonical);
+	return parsed.success ? parsed.data : canonical;
+}
+function rootFieldIds(plans) {
+	return new Set(plans.map((child) => child.fieldId.split(".")[0] ?? child.fieldId));
+}
+function omitUndefined(value) {
+	if (isUnknownArray$1(value)) return value.map(omitUndefined);
+	if (!isPlainObject$3(value)) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0).map(([key, field]) => [key, omitUndefined(field)]));
+}
+function isPlainObject$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray$1(value) {
+	return Array.isArray(value);
+}
+//#endregion
+//#region ../blocks/src/system/manifest/fieldValidation/index.ts
+const TEL_RE = /^[+()0-9\s-]{3,}$/;
+const SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
+const ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
+const DATE_PATTERN = /^(?<year>[1-9]\d{3})-(?<month>\d{2})-(?<day>\d{2})$/;
+const TIME_PATTERN = /^(?<hours>[01]\d|2[0-3]):(?<minutes>[0-5]\d)$/;
+const DATETIME_PATTERN = /^(?<date>[1-9]\d{3}-\d{2}-\d{2})T(?<time>(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d)(?:\.\d+)?(?<offset>Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+function assertNever$1(value) {
+	throw new Error(`Unhandled field validation variant: ${JSON.stringify(value)}`);
+}
+function validationContext(options = {}) {
+	const isDraft = options.mode === "draft";
+	return {
+		allowNull: options.allowNull ?? true,
+		allowIncomplete: isDraft || (options.allowIncomplete ?? false)
+	};
+}
+function strictValidationContext(options = {}) {
+	return {
+		...validationContext(options),
+		allowNull: options.allowNull ?? false
+	};
+}
+function formatFieldPath(path) {
+	return path.map((segment) => String(segment)).join(".");
+}
+function toZodIssuePath(path) {
+	return [...path];
+}
+function parseFieldPathKey(key) {
+	if (!key) return [];
+	return key.split(".").map((segment) => {
+		const numeric = Number(segment);
+		return Number.isInteger(numeric) && String(numeric) === segment ? numeric : segment;
+	});
+}
+function fieldIssueToMessage(issue) {
+	switch (issue.kind) {
+		case "required": return "This field is required";
+		case "wrongType": return `${issue.label} needs ${issue.expected}`;
+		case "tooLong": return `Use ${issue.maximum} characters or fewer`;
+		case "invalidEmail": return "Enter a valid email address";
+		case "invalidPhone": return "Enter a valid phone number";
+		case "invalidPattern": return "Check the format and try again";
+		case "invalidUrl": return "Enter a valid web address";
+		case "invalidDate": return "Choose a valid date";
+		case "invalidTime": return "Choose a valid time";
+		case "invalidDateTime": return "Choose a valid date and time";
+		case "invalidNumber": return `${issue.label} needs a number`;
+		case "tooSmall": return `${issue.label} must be ${issue.minimum} or more`;
+		case "tooLarge": return `${issue.label} must be ${issue.maximum} or less`;
+		case "invalidSlug": return `${issue.label} can only use lowercase letters, numbers, and dashes`;
+		case "invalidOption": return `Choose one of the available options for ${issue.label}`;
+		case "tooFewItems": return `${issue.label} must have at least ${issue.minimum} ${pluralize(issue.itemLabel, issue.minimum)}`;
+		case "tooManyItems": return `${issue.label} must have at most ${issue.maximum} ${pluralize(issue.itemLabel, issue.maximum)}`;
+		case "invalidRichText": return `${issue.label} must be valid rich text`;
+		case "invalidInlineText": return `${issue.label} must be valid styled text`;
+		case "invalidMedia": return `${issue.label} must be a media object with an identifier`;
+		case "invalidBoxBackground": return `${issue.label} must use a valid background type and matching fields`;
+		case "invalidLink": return `${issue.label} must be a valid link`;
+		case "invalidReference": return `${issue.label} must reference a valid item`;
+		default: return assertNever$1(issue);
+	}
+}
+function pluralize(label, count) {
+	if (count === 1) return label;
+	return label.endsWith("s") ? label : `${label}s`;
+}
+function valueContractForField(field) {
+	return field.ui?.valueContract === "boxBackground" ? { valueContract: "boxBackground" } : {};
+}
+function deriveTabGroupValidationPlan(field, path, required) {
+	return {
+		...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+		...valueContractForField(field),
+		childSelection: field.activeTabField ? {
+			kind: "discriminatedTabs",
+			activeTabField: field.activeTabField,
+			tabs: field.tabs.map((tab) => ({
+				typeId: tab.id,
+				fields: deriveNestedFieldPlans(tab.fields, path)
+			}))
+		} : {
+			kind: "all",
+			fields: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path))
+		}
+	};
+}
+function deriveFieldValidationPlan(field, path = [field.id]) {
+	const required = Boolean(field.required);
+	switch (field.type) {
+		case "text": {
+			const inputType = field.ui?.inputType;
+			if (inputType === "number") {
+				const constraints = commonConstraints(required, { kind: "numberType" });
+				if (typeof field.ui?.min === "number") constraints.push({
+					kind: "numberMin",
+					minimum: field.ui.min
+				});
+				if (typeof field.ui?.max === "number") constraints.push({
+					kind: "numberMax",
+					maximum: field.ui.max
+				});
+				return makePlan("number", "number", field, path, required, constraints);
+			}
+			const constraints = commonConstraints(required, { kind: field.ui?.widget === "iconPicker" ? "blockIconValue" : "textType" });
+			if (inputType === "email") constraints.push({ kind: "emailFormat" });
+			if (inputType === "tel") constraints.push({ kind: "phoneFormat" });
+			if (field.ui?.pattern) constraints.push({
+				kind: "patternFormat",
+				pattern: field.ui.pattern
+			});
+			if (typeof field.maxLength === "number") constraints.push({
+				kind: "maxLength",
+				maximum: field.maxLength
+			});
+			return makePlan("string", "string", field, path, required, constraints);
+		}
+		case "number": {
+			const constraints = commonConstraints(required, { kind: "numberType" });
+			if (typeof field.min === "number") constraints.push({
+				kind: "numberMin",
+				minimum: field.min
+			});
+			if (typeof field.max === "number") constraints.push({
+				kind: "numberMax",
+				maximum: field.max
+			});
+			return makePlan("number", "number", field, path, required, constraints);
+		}
+		case "slug": {
+			const constraints = commonConstraints(required, { kind: "textType" }, { kind: "slugFormat" });
+			if (typeof field.maxLength === "number") constraints.push({
+				kind: "maxLength",
+				maximum: field.maxLength
+			});
+			return makePlan("string", "string", field, path, required, constraints);
+		}
+		case "url": return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }, {
+			kind: "urlFormat",
+			allowRelative: Boolean(field.allowRelative)
+		}));
+		case "reference": return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "referenceText" }));
+		case "date": return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }, { kind: "dateFormat" }));
+		case "time": return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }, { kind: "timeFormat" }));
+		case "datetime": return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }, { kind: "datetimeFormat" }));
+		case "select": return makePlan("select", "select", field, path, required, commonConstraints(required, {
+			kind: "selectOption",
+			source: resolveSelectConstraintSource(field),
+			multiple: Boolean(field.multiple)
+		}));
+		case "richText": return makePlan("richText", "object", field, path, required, commonConstraints(required, { kind: "richTextDoc" }));
+		case "inlineText": {
+			const constraints = commonConstraints(required, { kind: "inlineText" });
+			if (typeof field.maxLength === "number") constraints.push({
+				kind: "maxPlainTextLength",
+				maximum: field.maxLength
+			});
+			return {
+				...makePlan("inlineText", "array", field, path, required, constraints),
+				...field.plainTextField ? { plainTextFallbackPath: parseFieldPathKey(field.plainTextField) } : {}
+			};
+		}
+		case "media":
+		case "file": return {
+			...makePlan("media", "object", field, path, required, commonConstraints(required, { kind: "mediaObject" })),
+			allowedMediaTypes: field.type === "media" ? field.mediaKinds ?? DEFAULT_MEDIA_FIELD_KINDS : field.fileKinds ?? PUBLIC_FILE_FIELD_KINDS
+		};
+		case "link": return makePlan("link", "object", field, path, required, commonConstraints(required, { kind: "linkObject" }));
+		case "boolean": return makePlan("boolean", "boolean", field, path, required, requiredConstraints(required));
+		case "repeater": return {
+			...makePlan("repeater", "array", field, path, required, commonConstraints(required, { kind: "arrayType" })),
+			...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path, 0]) } : { repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path, 0]) },
+			constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
+		};
+		case "group":
+		case "modal": return {
+			...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+			childSelection: {
+				kind: "all",
+				fields: deriveNestedFieldPlans(field.schema?.fields ?? [], path)
+			},
+			allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
+		};
+		case "tabGroup": return deriveTabGroupValidationPlan(field, path, required);
+		case "presetOrCustom":
+		case "contentTypeSelect":
+		case "entryPicker": return makePlan("passthrough", "unknown", field, path, false, []);
+		default: return assertNever$1(field);
+	}
+}
+function deriveFieldValidationPlans(fields, parentPath = []) {
+	return fields.map((field) => deriveFieldValidationPlan(field, [...parentPath, field.id]));
+}
+function commonConstraints(required, ...specific) {
+	return required ? [{ kind: "required" }, ...specific] : [...specific];
+}
+function requiredConstraints(required) {
+	return required ? [{ kind: "required" }] : [];
+}
+function makePlan(kind, valueKind, field, path, required, constraints) {
+	return {
+		kind,
+		valueKind,
+		fieldId: field.id,
+		label: field.label,
+		fieldType: field.type,
+		path,
+		required,
+		visibility: fieldVisibility(field),
+		constraints
+	};
+}
+function fieldVisibility(field) {
+	if (field.ui?.hidden) return { kind: "hidden" };
+	if (field.visibleRoles && field.visibleRoles.length > 0) return {
+		kind: "roleRestricted",
+		roles: field.visibleRoles
+	};
+	return { kind: "visible" };
+}
+function withRepeaterItemConstraints(field, constraints) {
+	const next = [...constraints];
+	if (typeof field.minItems === "number") next.push({
+		kind: "minItems",
+		minimum: field.minItems
+	});
+	if (typeof field.maxItems === "number") next.push({
+		kind: "maxItems",
+		maximum: field.maxItems
+	});
+	return next;
+}
+function deriveRepeatedItemVariants(field, parentPath) {
+	return Object.entries(field.itemTypes ?? {}).map(([typeId, itemType]) => ({
+		typeId,
+		fields: deriveNestedFieldPlans(getFlattenedRepeaterFields(itemType.fields), parentPath)
+	}));
+}
+function deriveNestedFieldPlans(fields, parentPath) {
+	return deriveFieldValidationPlans(fields, parentPath);
+}
+function getRepeaterFields(field) {
+	return getFlattenedRepeaterFields(field.polymorphic && field.itemTypes ? Object.values(field.itemTypes).flatMap((itemType) => itemType.fields) : field.schema?.fields ?? []);
+}
+function getFlattenedRepeaterFields(fields) {
+	return fields.flatMap((child) => {
+		if (child.type === "group" && child.ui?.flattenInRepeater) return child.schema?.fields ?? [];
+		return child;
+	});
+}
+function resolveSelectConstraintSource(field) {
+	const source = normalizeSelectSource(field);
+	switch (source.kind) {
+		case "static": return {
+			kind: "static",
+			values: field.options.map((option) => option.value)
+		};
+		case "site":
+		case "sdk": return {
+			kind: "runtime",
+			source: source.kind
+		};
+		default: return assertNever$1(source);
+	}
+}
+function normalizeStoredContentValues(plans, content, options = {}) {
+	if (!content || typeof content !== "object" || Array.isArray(content)) return {};
+	const planMap = new Map(plans.map((plan) => [plan.fieldId, plan]));
+	const normalized = {};
+	const ctx = validationContext(options);
+	for (const [key, value] of Object.entries(content)) {
+		const plan = planMap.get(key);
+		normalized[key] = plan ? normalizeStoredFieldValueWithContext(plan, value, ctx) : value;
+	}
+	normalizeInlineTextFallbacks(plans, normalized, ctx);
+	return normalized;
+}
+/**
+* Produces the portable representation accepted by content persistence.
+* Runtime-hydrated media fields are stripped only when a canonical identifier
+* is already present; unresolved environment-specific references remain
+* invalid and must be handled by the site-scoped media write normalizer first.
+*/
+function normalizeManifestContentForWrite(plans, content, options = {}) {
+	return canonicalizeObjectForWrite(plans, normalizeStoredContentValues(plans, content, options));
+}
+function normalizeStoredFieldValueWithContext(plan, value, ctx) {
+	if (value === null && !plan.required) return;
+	switch (plan.kind) {
+		case "group": return normalizeStoredObjectChildren(selectedGroupChildPlans(plan, value), value, childValidationContext(plan, ctx));
+		case "repeater": return normalizeStoredRepeaterItems(plan, value, ctx);
+		case "string":
+		case "number":
+		case "boolean":
+		case "richText":
+		case "inlineText":
+		case "media":
+		case "link":
+		case "select":
+		case "passthrough": return normalizeFieldValue(plan, value, ctx);
+		default: return assertNever$1(plan);
+	}
+}
+function normalizeStoredObjectChildren(children, value, ctx) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const normalized = { ...value };
+	for (const child of children) normalized[child.fieldId] = normalizeStoredFieldValueWithContext(child, normalized[child.fieldId], ctx);
+	normalizeInlineTextFallbacks(children, normalized, ctx);
+	return normalized;
+}
+function normalizeStoredRepeaterItems(plan, value, ctx) {
+	if (!isUnknownArray(value)) return value;
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+		const itemRecord = item;
+		const fields = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+		if (!fields) return item;
+		return normalizeStoredObjectChildren(fields, itemRecord, ctx);
+	});
+}
+function normalizeFieldValue(plan, value, ctx) {
+	switch (plan.kind) {
+		case "number": return normalizeNumberInput(value, ctx.allowNull);
+		case "string": return acceptsOptionalBlankAsMissing(plan, value) ? void 0 : value;
+		case "group": return normalizeObjectChildren(selectedGroupChildPlans(plan, value), value, childValidationContext(plan, ctx));
+		case "repeater": return normalizeRepeaterItems(plan, value, ctx);
+		case "boolean":
+		case "richText":
+		case "inlineText":
+		case "link":
+		case "select":
+		case "passthrough": return value;
+		case "media": return value;
+		default: return assertNever$1(plan);
+	}
+}
+function normalizeObjectChildren(children, value, ctx) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const normalized = { ...value };
+	for (const child of children) normalized[child.fieldId] = normalizeFieldValue(child, normalized[child.fieldId], ctx);
+	normalizeInlineTextFallbacks(children, normalized, ctx);
+	return normalized;
+}
+function normalizeInlineTextFallbacks(plans, values, ctx) {
+	for (const plan of plans) {
+		if (plan.kind !== "inlineText" || !plan.plainTextFallbackPath) continue;
+		if (!isMissingForPlan(plan, values[plan.fieldId]) && !(ctx.allowIncomplete && !parseInlineTextFromUnknown(values[plan.fieldId]).ok)) continue;
+		const fallback = getAtFieldPath(values, plan.plainTextFallbackPath);
+		if (typeof fallback !== "string" || fallback.trim().length === 0) continue;
+		values[plan.fieldId] = normalizeFieldValue(plan, plainTextToInlineText(fallback), ctx);
+	}
+}
+function getAtFieldPath(source, path) {
+	return path.reduce((current, segment) => {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return void 0;
+		return current[String(segment)];
+	}, source);
+}
+function normalizeRepeaterItems(plan, value, ctx) {
+	if (!isUnknownArray(value)) return value;
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+		const itemRecord = item;
+		const fields = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+		if (!fields) return item;
+		return normalizeObjectChildren(fields, itemRecord, ctx);
+	});
+}
+function normalizeNumberInput(value, _allowNull) {
+	if (value === "") return void 0;
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	return value;
+}
+function acceptsOptionalBlankAsMissing(plan, value) {
+	if (plan.required || typeof value !== "string" || value.trim() !== "") return false;
+	return plan.constraints.some((constraint) => constraint.kind === "urlFormat" || constraint.kind === "slugFormat" || constraint.kind === "emailFormat" || constraint.kind === "phoneFormat" || constraint.kind === "patternFormat");
+}
+function validateNormalizedFieldValue(plan, value, ctx) {
+	if (value === null && (ctx.allowNull || acceptsOptionalNullValue(plan))) return [];
+	if (isMissingForPlan(plan, value)) return shouldRequireValue(plan, value, ctx) ? [requiredIssue(plan, value)] : [];
+	switch (plan.kind) {
+		case "string": return validateStringPlan(plan, value);
+		case "number": return validateNumberPlan(plan, value);
+		case "boolean": return typeof value === "boolean" ? [] : [issue(plan, "wrongType", { expected: "a true/false value" })];
+		case "select": return validateSelectPlan(plan, value);
+		case "richText": return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
+		case "inlineText": return validateInlineTextPlan(plan, value);
+		case "media": return isPlainObject$2(value) && mediaIdentifierSchema.safeParse(value.identifier).success && (value.type === void 0 || typeof value.type === "string" && plan.allowedMediaTypes.includes(value.type)) ? [] : [issue(plan, "invalidMedia")];
+		case "link": return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
+		case "repeater": return validateRepeaterPlan(plan, value, ctx);
+		case "group": return validateGroupPlan(plan, value, ctx);
+		case "passthrough": return [];
+		default: return assertNever$1(plan);
+	}
+}
+function shouldRequireValue(plan, value, ctx) {
+	if (!plan.required || ctx.allowIncomplete) return false;
+	if (value === null && ctx.allowNull) return false;
+	return true;
+}
+function acceptsOptionalNullValue(plan) {
+	return !plan.required && (plan.kind === "media" || plan.kind === "number");
+}
+function isMissingForPlan(plan, value) {
+	if (value === void 0) return true;
+	if (value === null) return plan.required;
+	if (typeof value === "string" && value.trim() === "") return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	return false;
+}
+function validateStringPlan(plan, value) {
+	if (plan.constraints.some((constraint) => constraint.kind === "blockIconValue")) return plan.constraints.flatMap((constraint) => validateStringConstraint(plan, constraint, value));
+	if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
+	return plan.constraints.flatMap((constraint) => validateStringConstraint(plan, constraint, value));
+}
+function validateStringConstraint(plan, constraint, value) {
+	switch (constraint.kind) {
+		case "required": return [];
+		case "textType":
+		case "referenceText": return typeof value === "string" ? [] : [issue(plan, "wrongType", { expected: "text" })];
+		case "blockIconValue": return isValidIconPickerValue(value) ? [] : [issue(plan, "wrongType", { expected: "text or icon" })];
+		case "maxLength": return typeof value === "string" && value.length > constraint.maximum ? [issue(plan, "tooLong", { maximum: constraint.maximum })] : [];
+		case "emailFormat": return typeof value === "string" && isCanonicalEmailValue(value) ? [] : [issue(plan, "invalidEmail")];
+		case "phoneFormat": return typeof value === "string" && isCanonicalPhoneValue(value) ? [] : [issue(plan, "invalidPhone")];
+		case "patternFormat": {
+			if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
+			const re = compilePattern(constraint.pattern);
+			return re && !re.test(value) ? [issue(plan, "invalidPattern")] : [];
+		}
+		case "urlFormat": return typeof value === "string" && isCanonicalUrlValue(value, { allowRelative: constraint.allowRelative }) ? [] : [issue(plan, "invalidUrl")];
+		case "dateFormat": return typeof value === "string" && isValidDateString(value) ? [] : [issue(plan, "invalidDate")];
+		case "timeFormat": return typeof value === "string" && isValidTimeString(value) ? [] : [issue(plan, "invalidTime")];
+		case "datetimeFormat": return typeof value === "string" && isValidDateTimeInstantString(value) ? [] : [issue(plan, "invalidDateTime")];
+		case "slugFormat": return typeof value === "string" && SLUG_PATTERN.test(value) ? [] : [issue(plan, "invalidSlug")];
+		default: return assertNever$1(constraint);
+	}
+}
+function isValidIconPickerValue(value) {
+	if (typeof value === "string") return true;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	if (value.kind === "none") return true;
+	return parseBlockIconValue(value).kind !== "none";
+}
+function validateNumberPlan(plan, value) {
+	if (!isValidNumber(value)) return [issue(plan, "invalidNumber")];
+	return plan.constraints.flatMap((constraint) => validateNumberConstraint(plan, constraint, Number(value)));
+}
+function validateNumberConstraint(plan, constraint, value) {
+	switch (constraint.kind) {
+		case "required":
+		case "numberType": return [];
+		case "numberMin": return value < constraint.minimum ? [issue(plan, "tooSmall", { minimum: constraint.minimum })] : [];
+		case "numberMax": return value > constraint.maximum ? [issue(plan, "tooLarge", { maximum: constraint.maximum })] : [];
+		default: return assertNever$1(constraint);
+	}
+}
+function validateSelectPlan(plan, value) {
+	const constraint = plan.constraints.find((candidate) => candidate.kind === "selectOption");
+	if (!constraint || constraint.source.kind === "runtime") return [];
+	return isValidSelectValue(value, constraint.source.values, constraint.multiple) ? [] : [issue(plan, "invalidOption")];
+}
+function validateRepeaterPlan(plan, value, ctx) {
+	if (!Array.isArray(value)) return [issue(plan, "wrongType", { expected: "a list" })];
+	return [...plan.constraints.flatMap((constraint) => {
+		switch (constraint.kind) {
+			case "required":
+			case "arrayType": return [];
+			case "minItems": return value.length < constraint.minimum ? [issue(plan, "tooFewItems", {
+				minimum: constraint.minimum,
+				itemLabel: "item"
+			})] : [];
+			case "maxItems": return value.length > constraint.maximum ? [issue(plan, "tooManyItems", {
+				maximum: constraint.maximum,
+				itemLabel: "item"
+			})] : [];
+			default: return assertNever$1(constraint);
+		}
+	}), ...value.flatMap((item, index) => validateRepeaterItem(plan, item, index, ctx))];
+}
+function validateRepeaterItem(plan, item, index, ctx) {
+	if (!isPlainObject$2(item)) return [{
+		kind: "wrongType",
+		path: [...plan.path, index],
+		fieldId: plan.fieldId,
+		label: plan.label,
+		expected: "an object"
+	}];
+	const itemType = item._type;
+	const variant = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((candidate) => candidate.typeId === itemType) : void 0;
+	if (plan.repeatedItemVariants && !variant) return [{
+		kind: "invalidOption",
+		path: [
+			...plan.path,
+			index,
+			"_type"
+		],
+		fieldId: "_type",
+		label: `${plan.label} item type`
+	}];
+	const fields = variant?.fields ?? plan.repeatedItemPlan;
+	if (!fields) return [];
+	return fields.flatMap((childPlan) => {
+		return validateNormalizedFieldValue(materializeRepeaterItemPlan(childPlan, plan.path, index), item[childPlan.fieldId], ctx);
+	});
+}
+function validateGroupPlan(plan, value, ctx) {
+	if (!isPlainObject$2(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 [{
+			kind: "invalidOption",
+			path: [...plan.path, plan.childSelection.activeTabField],
+			fieldId: plan.childSelection.activeTabField,
+			label: `${plan.label} type`
+		}];
+	}
+	const childCtx = childValidationContext(plan, ctx);
+	const childIssues = selectedGroupChildPlans(plan, value).flatMap((childPlan) => validateNormalizedFieldValue(childPlan, value[childPlan.fieldId], childCtx));
+	if (childIssues.length > 0) return childIssues;
+	if (plan.valueContract === "boxBackground" && !boxBackgroundSchema.safeParse(value).success) return [issue(plan, "invalidBoxBackground")];
+	return [];
+}
+function childValidationContext(plan, ctx) {
+	return plan.allowNullChildren ? {
+		...ctx,
+		allowNull: true
+	} : ctx;
+}
+function materializeRepeaterItemPlan(plan, parentPath, index) {
+	return rebaseFieldPlanPath(plan, [...parentPath, 0], [...parentPath, index]);
+}
+function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
+	const path = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
+	switch (plan.kind) {
+		case "group": return {
+			...plan,
+			path,
+			childSelection: plan.childSelection.kind === "all" ? {
+				kind: "all",
+				fields: plan.childSelection.fields.map((childPlan) => rebaseFieldPlanPath(childPlan, fromPrefix, toPrefix))
+			} : {
+				...plan.childSelection,
+				tabs: plan.childSelection.tabs.map((tab) => ({
+					...tab,
+					fields: tab.fields.map((childPlan) => rebaseFieldPlanPath(childPlan, fromPrefix, toPrefix))
+				}))
+			}
+		};
+		case "repeater": return {
+			...plan,
+			path,
+			...plan.repeatedItemVariants ? { repeatedItemVariants: plan.repeatedItemVariants.map((variant) => ({
+				...variant,
+				fields: variant.fields.map((fieldPlan) => rebaseFieldPlanPath(fieldPlan, fromPrefix, toPrefix))
+			})) } : {},
+			...plan.repeatedItemPlan ? { repeatedItemPlan: plan.repeatedItemPlan.map((fieldPlan) => rebaseFieldPlanPath(fieldPlan, fromPrefix, toPrefix)) } : {}
+		};
+		case "string":
+		case "number":
+		case "boolean":
+		case "richText":
+		case "inlineText":
+		case "media":
+		case "link":
+		case "select":
+		case "passthrough": return {
+			...plan,
+			path
+		};
+		default: return assertNever$1(plan);
+	}
+}
+function validateInlineTextPlan(plan, value) {
+	const parsed = parseInlineTextFromUnknown(value);
+	if (!parsed.ok) return [issue(plan, "invalidInlineText")];
+	const text = inlineTextToPlainText(parsed.value);
+	const lengthIssue = plan.constraints.find((constraint) => constraint.kind === "maxPlainTextLength");
+	if (lengthIssue && text.length > lengthIssue.maximum) return [issue(plan, "tooLong", { maximum: lengthIssue.maximum })];
+	return [];
+}
+function rebaseFieldPath(path, fromPrefix, toPrefix) {
+	if (!startsWithFieldPath(path, fromPrefix)) throw new Error(`Cannot rebase field path ${formatFieldPath(path)} from ${formatFieldPath(fromPrefix)}`);
+	return [...toPrefix, ...path.slice(fromPrefix.length)];
+}
+function startsWithFieldPath(path, prefix) {
+	return prefix.every((segment, index) => path[index] === segment);
+}
+function issue(plan, kind, extra) {
+	return {
+		kind,
+		path: plan.path,
+		fieldId: plan.fieldId,
+		label: plan.label,
+		...extra ?? {}
+	};
+}
+function requiredIssue(plan, value) {
+	if (typeof value === "string") return issue(plan, "required", { emptyOrigin: "string" });
+	if (Array.isArray(value)) return issue(plan, "required", { emptyOrigin: "array" });
+	return issue(plan, "required");
+}
+function fieldPlanToZod(plan, options = {}) {
+	const ctx = validationContext(options);
+	return z.any().transform((value) => normalizeFieldValue(plan, value, ctx)).superRefine((value, zodCtx) => {
+		for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
+	});
+}
+function fieldPresenceForPlan(plan) {
+	return plan.required ? { kind: "required" } : { kind: "optional" };
+}
+function fieldPlanToObjectPropertyZod(plan, options = {}) {
+	const schema = fieldPlanToZod(plan, options);
+	const presence = fieldPresenceForPlan(plan);
+	switch (presence.kind) {
+		case "required": return schema;
+		case "optional": return schema.optional();
+		default: return assertNever$1(presence);
+	}
+}
+/** Validate stored field values without applying editor/write normalization. */
+function fieldPlanToStoredObjectPropertyZod(plan) {
+	const ctx = strictValidationContext({ allowNull: false });
+	const schema = z.any().superRefine((value, zodCtx) => {
+		for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
+	});
+	return plan.required ? schema : schema.optional();
+}
+function addFieldIssueToZodContext(zodCtx, validationIssue, rootPath) {
+	const message = fieldIssueToMessage(validationIssue);
+	const path = relativeZodIssuePath(validationIssue.path, rootPath);
+	const issuePath = path.length > 0 ? { path: toZodIssuePath(path) } : {};
+	switch (validationIssue.kind) {
+		case "required":
+			if (validationIssue.emptyOrigin) {
+				zodCtx.addIssue({
+					...issuePath,
+					code: "too_small",
+					origin: validationIssue.emptyOrigin,
+					minimum: 1,
+					inclusive: true,
+					message
+				});
+				return;
+			}
+			zodCtx.addIssue({
+				...issuePath,
+				code: "invalid_type",
+				expected: "nonoptional",
+				message
+			});
+			return;
+		case "tooLong":
+			zodCtx.addIssue({
+				...issuePath,
+				code: "too_big",
+				origin: "string",
+				maximum: validationIssue.maximum,
+				inclusive: true,
+				message
+			});
+			return;
+		case "invalidOption":
+			zodCtx.addIssue({
+				...issuePath,
+				code: "invalid_value",
+				values: [],
+				message
+			});
+			return;
+		case "wrongType":
+		case "invalidEmail":
+		case "invalidPhone":
+		case "invalidPattern":
+		case "invalidUrl":
+		case "invalidDate":
+		case "invalidTime":
+		case "invalidDateTime":
+		case "invalidNumber":
+		case "tooSmall":
+		case "tooLarge":
+		case "invalidSlug":
+		case "tooFewItems":
+		case "tooManyItems":
+		case "invalidRichText":
+		case "invalidInlineText":
+		case "invalidMedia":
+		case "invalidBoxBackground":
+		case "invalidLink":
+		case "invalidReference":
+			zodCtx.addIssue({
+				...issuePath,
+				code: "custom",
+				message
+			});
+			return;
+		default: assertNever$1(validationIssue);
+	}
+}
+function relativeZodIssuePath(path, rootPath) {
+	return startsWithFieldPath(path, rootPath) ? path.slice(rootPath.length) : path;
+}
+function compilePattern(pattern) {
+	try {
+		return new RegExp(pattern);
+	} catch {
+		return null;
+	}
+}
+function isValidNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isCanonicalEmailValue(value) {
+	return z.email().safeParse(value).success;
+}
+function isCanonicalPhoneValue(value) {
+	return TEL_RE.test(value);
+}
+function isCanonicalUrlValue(value, options = {}) {
+	if (!value) return false;
+	if (options.allowRelative === true && value.startsWith("/")) return true;
+	try {
+		const parsed = new URL(value);
+		return ALLOWED_URL_PROTOCOLS.includes(parsed.protocol);
+	} catch {
+		return false;
+	}
+}
+function isValidDateString(value) {
+	const match = DATE_PATTERN.exec(value);
+	if (!match?.groups) return false;
+	return isValidCalendarDate(Number(match.groups.year), Number(match.groups.month), Number(match.groups.day));
+}
+function isValidTimeString(value) {
+	return TIME_PATTERN.test(value);
+}
+function isValidDateTimeInstantString(value) {
+	const match = DATETIME_PATTERN.exec(value);
+	if (!match?.groups) return false;
+	const datePart = match.groups.date;
+	if (!datePart || !isValidDateString(datePart)) return false;
+	return !Number.isNaN(Date.parse(value));
+}
+function isValidCalendarDate(year, month, day) {
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return false;
+	if (year < 1 || month < 1 || month > 12) return false;
+	return day >= 1 && day <= daysInMonth(year, month);
+}
+function daysInMonth(year, month) {
+	switch (month) {
+		case 2: return isLeapYear(year) ? 29 : 28;
+		case 4:
+		case 6:
+		case 9:
+		case 11: return 30;
+		case 1:
+		case 3:
+		case 5:
+		case 7:
+		case 8:
+		case 10:
+		case 12: return 31;
+		default: return 0;
+	}
+}
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function isValidSelectValue(value, values, multiple) {
+	if (multiple) return Array.isArray(value) && value.every((item) => typeof item === "string" && values.includes(item));
+	return typeof value === "string" && values.includes(value);
+}
+function isEmptyValue(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string" && value.trim() === "") return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	if (isEmptyRichTextDoc(value)) return true;
+	return false;
+}
+function isPlainObject$2(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function isValidRichTextDoc(value) {
+	return isRichTextDoc(value);
+}
+function isEmptyRichTextDoc(value) {
+	if (!isPlainObject$2(value)) return false;
+	if (value.type !== "doc") return false;
+	const content = value.content;
+	if (!Array.isArray(content) || content.length === 0) return true;
+	if (content.length !== 1) return false;
+	const first = content[0];
+	return first?.type === "paragraph" && (!Array.isArray(first.content) || first.content.length === 0);
+}
+//#endregion
+//#region ../blocks/src/system/manifest/registry.ts
+const REGISTRY_SYMBOL$1 = Symbol.for("@riverbankcms/blocks/manifest-registry");
+const isBlocksTestRuntime$1 = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.RIVERBANK_BLOCKS_TEST === "1";
+const globalScope$1 = globalThis;
+const manifestStore = isBlocksTestRuntime$1 ? /* @__PURE__ */ new Map() : globalScope$1[REGISTRY_SYMBOL$1] ?? (globalScope$1[REGISTRY_SYMBOL$1] = /* @__PURE__ */ new Map());
+function registerManifest(manifest) {
+	manifestStore.set(manifest.name, manifest);
+	return manifest;
+}
+//#endregion
+//#region ../blocks/src/system/manifest/validation.ts
+const compiledManifestContentContract = Symbol("compiledManifestContentContract");
+/**
+* Preprocess content by converting empty values to undefined.
+* Used in draft mode to allow required fields to be temporarily empty.
+*/
+function preprocessEmptyValues(content) {
+	if (!content || typeof content !== "object" || Array.isArray(content)) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(content)) result[key] = isEmptyValue(value) ? void 0 : value;
+	return result;
+}
+/**
+* Compiles editor-facing manifest structure into the presentation-independent
+* validation contract used by every manifest-content trust transition.
+*/
+function compileManifestContentContract(manifestOrFields) {
+	const plans = derivePlansFromManifestOrFields(manifestOrFields);
+	const strictOptions = { allowNull: false };
+	const strictStoredSchema = deriveStrictStoredZodFromPlans(plans);
+	return Object.freeze({ [compiledManifestContentContract]: Object.freeze({
+		plans,
+		strictStoredSchema,
+		writeSchema: deriveNormalizedContentZodFromPlans(plans, strictOptions, normalizeManifestContentForWrite).transform((value) => canonicalizeObjectForWrite(plans, value)),
+		draftSchema: deriveNormalizedContentZodFromPlans(plans, {
+			allowNull: true,
+			allowIncomplete: true,
+			mode: "draft"
+		}, normalizeStoredContentValues),
+		renderSchema: strictStoredSchema,
+		findNonPortableMediaPaths: (content) => findNonPortableMediaPaths(plans, content)
+	}) });
+}
+/**
+* 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.
+*/
+function admitTransportedRenderableManifestContent(contract, content) {
+	const parsed = contract[compiledManifestContentContract].renderSchema.safeParse(content);
+	return parsed.success ? {
+		ok: true,
+		value: content
+	} : {
+		ok: false,
+		error: zodAdmissionError(parsed.error)
+	};
+}
+function deriveNormalizedContentZodFromPlans(plans, options, normalize) {
+	const isDraft = options.mode === "draft";
+	const baseSchema = deriveContentZodFromPlans(plans, options);
+	if (isDraft) return z.preprocess((content) => preprocessEmptyValues(normalize(plans, content, options)), baseSchema);
+	return z.preprocess((content) => normalize(plans, content, options), baseSchema);
+}
+function deriveContentZodFromPlans(plans, options) {
+	const shape = {};
+	for (const plan of plans) shape[plan.fieldId] = fieldPlanToObjectPropertyZod(plan, options);
+	return z.object(shape).catchall(z.unknown()).passthrough();
+}
+function deriveStrictStoredZodFromPlans(plans) {
+	const shape = {};
+	for (const plan of plans) shape[plan.fieldId] = fieldPlanToStoredObjectPropertyZod(plan);
+	return z.object(shape).catchall(z.unknown()).passthrough();
+}
+function derivePlansFromManifestOrFields(manifestOrFields) {
+	return deriveFieldValidationPlans(Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? []);
+}
+function zodAdmissionError(error) {
+	return {
+		kind: "invalid_shape",
+		issues: zodAdmissionIssues(error)
+	};
+}
+function zodAdmissionIssues(error) {
+	return error.issues.map((issue) => ({
+		code: issue.code,
+		path: issue.path.map((segment) => typeof segment === "number" ? segment : String(segment)),
+		message: issue.message
+	}));
+}
+function findNonPortableMediaPaths(plans, content) {
+	const paths = /* @__PURE__ */ new Set();
+	collectNonPortablePlannedMedia(plans, content, [], paths);
+	return [...paths].sort();
+}
+function collectNonPortablePlannedMedia(plans, content, parentPath, paths) {
+	if (!isPlainRecord(content)) return;
+	for (const plan of plans) {
+		if (!(plan.fieldId in content)) continue;
+		const value = content[plan.fieldId];
+		const path = [...parentPath, plan.fieldId];
+		switch (plan.kind) {
+			case "media":
+				if (isPlainRecord(value) && hasEnvironmentSpecificMediaField(value)) paths.add(formatFieldPath(path));
+				break;
+			case "richText":
+				collectNonPortableRichTextImages(value, path, paths);
+				break;
+			case "group":
+				collectNonPortablePlannedMedia(selectedGroupChildPlans(plan, value), value, path, paths);
+				break;
+			case "repeater":
+				collectNonPortableRepeaterMedia(plan, value, path, paths);
+				break;
+			case "string":
+			case "number":
+			case "boolean":
+			case "inlineText":
+			case "link":
+			case "select":
+			case "passthrough": break;
+		}
+	}
+}
+function collectNonPortableRepeaterMedia(plan, value, path, paths) {
+	if (!Array.isArray(value)) return;
+	value.forEach((item, index) => {
+		if (!isPlainRecord(item)) return;
+		const childPlans = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
+		if (childPlans) collectNonPortablePlannedMedia(childPlans, item, [...path, index], paths);
+	});
+}
+function collectNonPortableRichTextImages(value, path, paths) {
+	const images = [];
+	walkAndCollectImageAttrs(value, images);
+	const prefix = formatFieldPath(path);
+	for (const reference of images) if (hasEnvironmentSpecificMediaField(reference.attrs)) paths.add(reference.location ? `${prefix}.${reference.location}` : prefix);
+}
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasEnvironmentSpecificMediaField(value) {
+	return "assetId" in value || "storageBucket" in value || "storagePath" in value || "src" in value || "mimeType" in value || looksLikeUuid(value.id);
+}
 //#endregion
 //#region ../blocks/src/system/designCapabilities.ts
 function declareBlockDesignCapability(capability) {
@@ -23536,26 +25469,6 @@ const headerLogoTextVisibleTransform = {
 		return resolveHeaderBrandDisplay(asPartialObject(value)) !== "logo-only";
 	}
 };
-/**
-* Selects which classic-layout nav row should render.
-*
-* - `'inline'`  → classic variant with the historical logo-left / nav-right row
-* - `'centered'`→ classic variant with a centred (flex-1) nav and a right CTA
-* - `'other'`   → not a classic variant (centered/floating handle it)
-*
-* Consumed by the site-header block's `$when` gates so the two classic rows are
-* mutually exclusive without introducing a new top-level header variant.
-*/
-const classicNavModeTransform = {
-	id: "layout.classicNavMode",
-	kind: "formatter",
-	summary: "Resolve which classic-layout nav row to render",
-	run: (value) => {
-		const header = asPartialObject(value);
-		if (header?.variant !== "classic") return "other";
-		return header?.navPlacement === "center" ? "centered" : "inline";
-	}
-};
 const maxWidthClassTransform = {
 	id: "layout.maxWidthClass",
 	kind: "string",
@@ -23661,7 +25574,6 @@ const headerRootClassTransform = {
 		if (isHeaderScrollRuntimeEnabled(content)) classes.push(config.shrink);
 		const variant = header?.variant;
 		if (variant && headerVariantValues.includes(variant)) classes.push(`header-variant-${variant}`);
-		if (header?.barFrame === "inset-shell" && variant === "classic") classes.push("header-bar-frame-inset-shell");
 		return joinClasses(classes);
 	}
 };
@@ -23869,7 +25781,6 @@ const layoutTransforms = [
 	headerLogoClassTransform,
 	headerLogoMediaClassTransform,
 	headerLogoTextVisibleTransform,
-	classicNavModeTransform,
 	footerRootClassTransform,
 	headerRootStyleTransform,
 	headerSectionBackgroundTransform,
@@ -23945,40 +25856,22 @@ const mediaTransforms = [{
 	}
 }];
 //#endregion
-//#region ../blocks/src/lib/typeGuards.ts
-/**
-* Strict record guard: excludes null, primitives, and arrays.
-*/
-function isRecord$8(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Non-null object guard: includes arrays for behavior parity with legacy helpers.
-*
-* NOTE: This intentionally narrows to UnknownRecord for compatibility with existing
-* callsites even though arrays pass at runtime. Follow-up cleanup should replace
-* this API with a more precise predicate type and migrate consumers.
-*/
-function isObjectRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-//#endregion
 //#region ../blocks/src/system/transforms/registry/content.ts
 const supportedRichTextTokenSchema = z.enum(["year", "site_name"]);
 const interpolateRichTextTokensOptionsSchema = z.object({ tokens: z.array(supportedRichTextTokenSchema).default(["year", "site_name"]) });
 const richTextTokenPattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
 function getSiteName(context) {
 	const viewModel = context.viewModel;
-	if (!isRecord$8(viewModel)) return null;
+	if (!isRecord$10(viewModel)) return null;
 	const site = viewModel.site;
-	if (isRecord$8(site) && typeof site.title === "string") {
+	if (isRecord$10(site) && typeof site.title === "string") {
 		const title = site.title.trim();
 		return title.length > 0 ? title : null;
 	}
 	const root = viewModel.$root;
-	if (isRecord$8(root)) {
+	if (isRecord$10(root)) {
 		const rootSite = root.site;
-		if (isRecord$8(rootSite) && typeof rootSite.title === "string") {
+		if (isRecord$10(rootSite) && typeof rootSite.title === "string") {
 			const title = rootSite.title.trim();
 			if (title.length > 0) return title;
 		}
@@ -24000,7 +25893,7 @@ function replaceTokenText(input, allowedTokens, tokenValues) {
 	});
 }
 function visitRichTextNode(node, allowedTokens, tokenValues) {
-	if (!isRecord$8(node)) return node;
+	if (!isRecord$10(node)) return node;
 	let changed = false;
 	const nextNode = { ...node };
 	if (nextNode.type === "text" && typeof nextNode.text === "string") {
@@ -24021,7 +25914,7 @@ function visitRichTextNode(node, allowedTokens, tokenValues) {
 	return changed ? nextNode : node;
 }
 function interpolateRichTextTokens(value, options, context) {
-	if (!isRecord$8(value)) return value;
+	if (!isRecord$10(value)) return value;
 	return visitRichTextNode(value, new Set(options.tokens), {
 		year: String((/* @__PURE__ */ new Date()).getFullYear()),
 		site_name: getSiteName(context)
@@ -24269,18 +26162,7 @@ const classicLayout = inline({
 	logoRow,
 	createNavRow(`rb-ml-auto ${desktopOnlyDisplay("flex")} rb-gap-6`),
 	headerCta
-], whenTransformed("$root.theme.header", "layout.classicNavMode", "inline"));
-const classicCenteredNavLayout = inline({
-	className: bindProp("$root.theme.header.maxWidth", {
-		transforms: pipe(tx("layout.maxWidthClass", { base: `rb-header-layout ${desktopOnlyDisplay("flex")} rb-w-full rb-items-center rb-gap-6` })),
-		fallback: `rb-container rb-header-layout ${desktopOnlyDisplay("flex")} rb-w-full rb-items-center rb-gap-6`
-	}),
-	align: "center"
-}, [
-	logoRow,
-	createNavRow(`rb-flex-1 rb-justify-center ${desktopOnlyDisplay("flex")} rb-gap-6`, "center"),
-	headerCta
-], whenTransformed("$root.theme.header", "layout.classicNavMode", "centered"));
+], when("$root.theme.header.variant", { equals: "classic" }));
 const centeredLayout = stack({
 	gap: "md",
 	align: "center",
@@ -24345,7 +26227,6 @@ const siteHeaderBlockDefinition = { manifest: createBlockManifest({
 	}, [
 		mobileHeaderBar,
 		classicLayout,
-		classicCenteredNavLayout,
 		centeredLayout,
 		floatingLayout,
 		mobileOverlay
@@ -26299,83 +28180,6 @@ const weeklySlotAvailabilityBlockDefinition = {
 	} }
 };
 //#endregion
-//#region ../blocks/src/lib/media.ts
-const PUBLIC_DOWNLOAD_MEDIA_TYPES = [
-	"document",
-	"spreadsheet",
-	"archive",
-	"audio"
-];
-//#endregion
-//#region ../blocks/src/system/manifest/richTextSchema.ts
-/**
-* Shared Rich Text Schema
-*
-* This module provides a single source of truth for TipTap rich text validation
-* across both the block-form editor and the block rendering system.
-*
-* Rich-text fields use one canonical root shape:
-* `{ type: 'doc', content: [...] }`.
-*/
-/**
-* TipTap document node schema (recursive structure)
-*
-* Supports the full TipTap document structure including:
-* - type: Node type (e.g., 'doc', 'paragraph', 'text')
-* - content: Nested array of child nodes
-* - text: Text content for text nodes
-* - attrs: Node attributes (e.g., alignment, color)
-* - marks: Text formatting marks (e.g., bold, italic)
-*/
-const TipTapMarkSchema = z.object({
-	type: z.string().min(1),
-	attrs: z.record(z.string(), z.unknown()).optional()
-}).strict();
-const TipTapNodeSchema = z.lazy(() => z.object({
-	type: z.string().min(1),
-	content: z.array(TipTapNodeSchema).optional(),
-	text: z.string().optional(),
-	attrs: z.record(z.string(), z.unknown()).optional(),
-	marks: z.array(TipTapMarkSchema).optional()
-}).strict().superRefine((node, ctx) => {
-	if (node.type === "doc") ctx.addIssue({
-		code: "custom",
-		path: ["type"],
-		message: "Document nodes are only valid at the rich-text root"
-	});
-	if (node.type === "text") {
-		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
-			code: "custom",
-			path: ["text"],
-			message: "Text nodes require a non-empty text value"
-		});
-		if (node.content !== void 0) ctx.addIssue({
-			code: "custom",
-			path: ["content"],
-			message: "Text nodes cannot contain child nodes"
-		});
-		return;
-	}
-	if (node.text !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["text"],
-		message: "Only text nodes can contain a text value"
-	});
-}));
-/**
-* Canonical schema for a TipTap rich-text document root.
-*
-* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
-* `content` is required (possibly empty). This is the shape every producer
-* (dummy content, editor output, migrations) must emit, and the shape every
-* non-legacy consumer can rely on.
-*
-*/
-const RichTextDocSchema = z.object({
-	type: z.literal("doc"),
-	content: z.array(TipTapNodeSchema)
-}).strict();
-//#endregion
 //#region ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
 const bookingDepositRefundPolicySchema$1 = z.enum(["refundable", "non_refundable"]);
 const bookingInstalmentPlanSchema$1 = z.union([
@@ -27371,11 +29175,11 @@ function planEventRegistrationScope(input) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/shared/destination.ts
-function isRecord$7(value) {
+function isRecord$9(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRuntimeEventDestination(value) {
-	if (!isRecord$7(value) || typeof value.kind !== "string") return false;
+	if (!isRecord$9(value) || typeof value.kind !== "string") return false;
 	if (value.kind === "native") return (value.mode === "cms-managed" || value.mode === "system-managed") && typeof value.path === "string";
 	return value.kind === "external" && typeof value.url === "string" && typeof value.label === "string";
 }
@@ -27438,15 +29242,15 @@ function resolveRuntimeEventPricing(event) {
 function readCurrency(value) {
 	return typeof value === "string" && value.trim().length > 0 ? value : DEFAULT_EVENT_CURRENCY;
 }
-function isRecord$6(value) {
+function isRecord$8(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPublicEventPricing(value) {
-	if (!isRecord$6(value) || typeof value.kind !== "string") return false;
+	if (!isRecord$8(value) || typeof value.kind !== "string") return false;
 	return value.kind === "drop_in" || value.kind === "free_registration" || value.kind === "single_paid" || value.kind === "sliding_scale" || value.kind === "ticket_types" || value.kind === "whole_series" || value.kind === "external";
 }
 function isPublicEventTicketType(value) {
-	return isRecord$6(value) && typeof value.id === "string";
+	return isRecord$8(value) && typeof value.id === "string";
 }
 function readTicketTypePriceDisplay(value, currency) {
 	const display = readLegacyPriceDisplay(value, currency);
@@ -27456,7 +29260,7 @@ function readTicketTypePriceDisplay(value, currency) {
 	} : display;
 }
 function readLegacyPriceDisplay(value, currency) {
-	if (!isRecord$6(value) || typeof value.kind !== "string") return {
+	if (!isRecord$8(value) || typeof value.kind !== "string") return {
 		kind: "unavailable",
 		currency
 	};
@@ -27508,7 +29312,7 @@ function readLegacyPriceDisplay(value, currency) {
 			kind: "unavailable",
 			currency: displayCurrency
 		};
-		case "whole_series": return isRecord$6(value.display) ? {
+		case "whole_series": return isRecord$8(value.display) ? {
 			kind: "whole_series",
 			display: readCoursePriceDisplay(value.display, displayCurrency)
 		} : {
@@ -27969,14 +29773,14 @@ const eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
 	}
 });
 function normalizeEventRegistrationEventInput(value) {
-	if (!isRecord$5(value)) return value;
+	if (!isRecord$7(value)) return value;
 	return {
 		...value,
 		destination: resolveRuntimeEventDestination(value),
 		pricing: resolveRuntimeEventPricing(value)
 	};
 }
-function isRecord$5(value) {
+function isRecord$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const eventRegistrationBlockDefinition = {
@@ -28750,7 +30554,8 @@ const eventCollectionSourceSchemaShape = {
 	buttonVariant: eventButtonVariantSchema.optional(),
 	buttonText: z.string().optional(),
 	emptyMessage: z.string().optional(),
-	className: z.string().optional()
+	className: z.string().optional(),
+	bookingTimeZone: z.string().optional()
 };
 const eventCollectionDisplaySchemaShape = {
 	events: z.array(publicEventSchema),
@@ -28785,7 +30590,15 @@ const eventCollectionHydrationSchema = z.object({
 	prefetchedEvents: z.boolean(),
 	eventSurface: eventSurfaceScopeSchema$1,
 	filterEventPresets: z.string().nullable(),
-	scheduleScope: eventScheduleScopeSchema$1
+	scheduleScope: eventScheduleScopeSchema$1,
+	calendarContext: z.object({
+		timeZone: z.string().transform(toBookingTimeZone),
+		initialToday: z.object({
+			year: z.number().int(),
+			month: z.number().int().min(1).max(12),
+			day: z.number().int().min(1).max(31)
+		})
+	})
 });
 function buildEventCollectionDisplay(source) {
 	return {
@@ -28830,14 +30643,19 @@ function buildEventCollectionPresentationDisplay(source) {
 		emptyMessage: source.emptyMessage ?? "No upcoming events scheduled."
 	};
 }
-function buildEventCollectionHydration(source) {
+function buildEventCollectionHydration(source, now = /* @__PURE__ */ new Date()) {
+	const timeZone = toBookingTimeZone(source.bookingTimeZone);
 	return {
 		siteId: source.siteId,
 		stage: source.stage,
 		prefetchedEvents: source.events != null,
 		eventSurface: normalizeEventSurfaceScope(source.eventSurface),
 		filterEventPresets: normalizeEventSurfacePresetsCsv(source.filterEventPresets),
-		scheduleScope: normalizeEventScheduleScope(source.scheduleScope)
+		scheduleScope: normalizeEventScheduleScope(source.scheduleScope),
+		calendarContext: {
+			timeZone,
+			initialToday: getLocalScheduleDate(now, timeZone)
+		}
 	};
 }
 //#endregion
@@ -30828,7 +32646,7 @@ function inferLegacyOfferingsPreviewGroupOrder(overrides) {
 	return keys.length >= 2 ? keys : [];
 }
 function normalizeOfferingsPreviewContentForWrite(value) {
-	if (!isRecord$4(value)) return null;
+	if (!isRecord$6(value)) return null;
 	const groupOrderValue = value.groupOrder;
 	if (Array.isArray(groupOrderValue)) {
 		const normalized = normalizeOfferingsPreviewGroupOrder(groupOrderValue);
@@ -30841,7 +32659,7 @@ function normalizeOfferingsPreviewContentForWrite(value) {
 		...value,
 		groupOrder: []
 	};
-	const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord$4) : []);
+	const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord$6) : []);
 	return legacyOrder.length > 0 ? {
 		...value,
 		groupOrder: legacyOrder
@@ -30855,7 +32673,7 @@ function uniqueOfferingsPreviewSourceKeys(values) {
 	}
 	return keys;
 }
-function isRecord$4(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -31233,7 +33051,7 @@ function isOfferingsPreviewItemLimit(value) {
 	return value === "1" || value === "2" || value === "3" || value === "4" || value === "5" || value === "6" || value === null;
 }
 function normalizeOfferingsPreviewGroupOverride(value) {
-	if (!isRecord$3(value)) return [];
+	if (!isRecord$5(value)) return [];
 	const override = {};
 	if (isOfferingsPreviewSourceKey(value.sourceKey) || value.sourceKey === null) override.sourceKey = value.sourceKey;
 	if (typeof value.title === "string" || value.title === null) override.title = value.title;
@@ -31256,7 +33074,7 @@ function normalizeSectionStylesContent(value) {
 }
 function normalizeBoxStylesContent(value) {
 	if (value === null) return null;
-	if (!isRecord$3(value)) return void 0;
+	if (!isRecord$5(value)) return void 0;
 	const { background: _background, ...rest } = value;
 	const background = parseBackgroundContent(value.background);
 	return {
@@ -31264,7 +33082,7 @@ function normalizeBoxStylesContent(value) {
 		...background ? { background } : {}
 	};
 }
-function isRecord$3(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const embedManifest = createBlockManifest({
@@ -34485,6 +36303,23 @@ function deriveNewsletterSignupRuntimeSource(values) {
 		tags: parseTrimmedString(normalized.tags)
 	};
 }
+function sanitizeNewsletterSignupPublicContent(content) {
+	if (!isRecord$4(content)) return content;
+	const provider = parseNewsletterSignupDestinationProvider(content.destinationProvider) ?? getProviderFromExplicitDestination(content.destination);
+	const { destination: _destination, destinationProvider: _destinationProvider, mailchimpAudienceId: _mailchimpAudienceId, mailchimpTags: _mailchimpTags, listId, tags, ...publicContent } = content;
+	const mutablePublicContent = { ...publicContent };
+	if (provider !== "mailchimp") {
+		if ("listId" in content) mutablePublicContent.listId = listId;
+		if ("tags" in content) mutablePublicContent.tags = tags;
+	}
+	return mutablePublicContent;
+}
+function getProviderFromExplicitDestination(destination) {
+	if (!isRecord$4(destination) || typeof destination.tag !== "string") return null;
+	if (destination.tag === "riverbank_list") return "riverbank";
+	if (destination.tag === "mailchimp_audience") return "mailchimp";
+	return null;
+}
 const BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
 const SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
 function parseTrimmedString(value) {
@@ -34492,6 +36327,9 @@ function parseTrimmedString(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
 }
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null;
+}
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 /**
@@ -34727,7 +36565,7 @@ function projectNewsletterFormHydrationTarget(source) {
 			tag: "legacy-direct-list",
 			listId: source.listId
 		};
-		default: return assertNever$2(source);
+		default: return assertNever$3(source);
 	}
 }
 function parseRequiredNewsletterSignupBlockId(value) {
@@ -36905,7 +38743,7 @@ function isNonProductionEnv() {
 //#region ../blocks/src/system/data/linkedContentEntries.ts
 const LINKED_CONTENT_ENTRY_META_KEY = "__rbLinkedContentEntry";
 function coerceLinkedContentEntriesPayload(payload) {
-	if (!isRecord$2(payload)) return payload;
+	if (!isRecord$3(payload)) return payload;
 	const response = payload;
 	if (!Array.isArray(response.entries)) return payload;
 	const contentType = parsePublicContentTypeMeta(response.contentType);
@@ -36913,12 +38751,12 @@ function coerceLinkedContentEntriesPayload(payload) {
 	return response.entries.map((entry) => enrichLinkedContentEntry(entry, contentType));
 }
 function enrichLinkedContentEntry(entry, contentType) {
-	if (!isRecord$2(entry)) return entry;
+	if (!isRecord$3(entry)) return entry;
 	const entryId = typeof entry.id === "string" ? entry.id : null;
 	if (!entryId) return entry;
 	const title = typeof entry.title === "string" && entry.title.trim().length > 0 ? entry.title : entryId;
 	const optimisticHash = typeof entry.optimisticHash === "string" && entry.optimisticHash.length > 0 ? entry.optimisticHash : null;
-	const content = isRecord$2(entry.content) ? entry.content : {};
+	const content = isRecord$3(entry.content) ? entry.content : {};
 	const meta = {
 		kind: "linked-content-entry",
 		entryId,
@@ -37001,7 +38839,7 @@ function resolveLinkedContentEditSupport(contentType) {
 			kind: "unsupported-domain-backed",
 			reason: metadata.reason
 		};
-		default: return assertNever$2(metadata);
+		default: return assertNever$3(metadata);
 	}
 }
 function contentTypeKeyToLabel(key) {
@@ -37011,7 +38849,7 @@ function capitalize(value) {
 	return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
 }
 function parsePublicContentTypeMeta(value) {
-	if (!isRecord$2(value)) return null;
+	if (!isRecord$3(value)) return null;
 	if (typeof value.key !== "string" || value.key.trim().length === 0) return null;
 	return {
 		key: value.key,
@@ -37021,7 +38859,7 @@ function parsePublicContentTypeMeta(value) {
 	};
 }
 function parsePublicContentTypeLinkedEntryEditing(value) {
-	if (!isRecord$2(value) || typeof value.kind !== "string") return null;
+	if (!isRecord$3(value) || typeof value.kind !== "string") return null;
 	switch (value.kind) {
 		case "generic": return { kind: "generic" };
 		case "unsupported-domain-backed": return {
@@ -37032,7 +38870,7 @@ function parsePublicContentTypeLinkedEntryEditing(value) {
 	}
 }
 function parsePublicContentTypeFieldMeta(value) {
-	if (!isRecord$2(value)) return [];
+	if (!isRecord$3(value)) return [];
 	if (typeof value.id !== "string" || typeof value.type !== "string") return [];
 	return [{
 		id: value.id,
@@ -37046,7 +38884,7 @@ function parseStringArray(value) {
 	if (!Array.isArray(value)) return null;
 	return value.filter((item) => typeof item === "string");
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -37067,10 +38905,10 @@ function normalizeDataLoaders(def) {
 */
 function normalizeContent(block) {
 	const source = block.draftContent ?? block.content ?? block.publishedContent ?? {};
-	if (!isObjectRecord(source)) return {};
+	if (!isObjectRecord$1(source)) return {};
 	if ("data" in source) {
 		const data = source.data;
-		if (isObjectRecord(data)) return data;
+		if (isObjectRecord$1(data)) return data;
 		if (data === null || data === void 0) return {};
 	}
 	return source;
@@ -37253,7 +39091,7 @@ const SUPPORTED_LOADER_ENDPOINTS$1 = [
 //#endregion
 //#region ../blocks/src/system/data/normalizeLoaderParams.ts
 function toStringParams(value) {
-	if (!isObjectRecord(value)) return {};
+	if (!isObjectRecord$1(value)) return {};
 	const out = {};
 	for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
 	return out;
@@ -37851,7 +39689,7 @@ function describeSiteVerticalConfigIssue(issue) {
 		case "duplicate_preset_id":
 		case "duplicate_canonical_behaviour":
 		case "future_preset_selected": return issue.code;
-		default: return assertNever$2(issue);
+		default: return assertNever$3(issue);
 	}
 }
 const VerticalIdSchema = z.string().trim().transform((value, ctx) => {
@@ -37892,7 +39730,7 @@ z.object({
 });
 //#endregion
 //#region ../api/src/utils/isRecord.ts
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -38141,7 +39979,7 @@ function sanitizeMarks(marks) {
 	if (!Array.isArray(marks) || marks.length === 0) return;
 	const sanitized = marks.flatMap((mark) => {
 		if (mark.type === "bold" || mark.type === "strong" || mark.type === "italic" || mark.type === "em") return [{ type: mark.type }];
-		if (mark.type === "link" && isRecord$1(mark.attrs) && typeof mark.attrs.href === "string") {
+		if (mark.type === "link" && isRecord$2(mark.attrs) && typeof mark.attrs.href === "string") {
 			const attrs = { href: mark.attrs.href };
 			if (typeof mark.attrs.target === "string" && mark.attrs.target.trim().length > 0) attrs.target = mark.attrs.target;
 			if (typeof mark.attrs.rel === "string" && mark.attrs.rel.trim().length > 0) attrs.rel = mark.attrs.rel;
@@ -38336,7 +40174,7 @@ const ENTRY_REF_KEYS = [
 	"entryId",
 	"slug"
 ];
-function isRecord(value) {
+function isRecord$1(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function extractManualEntryRef(item) {
@@ -38344,7 +40182,7 @@ function extractManualEntryRef(item) {
 		const trimmed = item.trim();
 		return trimmed.length > 0 ? trimmed : null;
 	}
-	if (!isRecord(item)) return null;
+	if (!isRecord$1(item)) return null;
 	for (const key of ENTRY_REF_KEYS) {
 		const raw = item[key];
 		if (typeof raw === "string" && raw.trim().length > 0) return raw.trim();
@@ -38649,6 +40487,126 @@ function requireSdkTheme(theme, siteId, reason = "cms_theme_absent") {
 	return theme;
 }
 //#endregion
+//#region src/rendering/helpers/siteCustomBlocks.ts
+/**
+* Prefer the DB-backed custom block manifest list (`site.customBlocks`) when available,
+* but fall back to SDK config custom blocks (`site.sdkConfig.customBlocks`) for SDK-mode sites.
+*
+* This avoids subtle DX bugs where one source is populated but the renderer/prefetch layer
+* is looking at the other.
+*/
+function resolveSiteCustomBlocks(site) {
+	const dbBlocks = site.customBlocks;
+	if (Array.isArray(dbBlocks) && dbBlocks.length > 0) return dbBlocks;
+	const sdkBlocks = site.sdkConfig?.customBlocks;
+	if (Array.isArray(sdkBlocks) && sdkBlocks.length > 0) return sdkBlocks;
+}
+//#endregion
+//#region src/rendering/helpers/pageRuntimeSupport.ts
+function convertPageResponseBlock(block) {
+	if (!isRecord(block)) throw new Error("Invalid block format in page API response");
+	if (typeof block.id !== "string" && block.id !== null) throw new Error(`Invalid block id in page: expected string or null, got ${typeof block.id}`);
+	if (typeof block.kind !== "string") throw new Error(`Invalid block kind in page: expected string, got ${typeof block.kind}`);
+	if (typeof block.purpose !== "string") throw new Error(`Invalid block purpose in page: expected string, got ${typeof block.purpose}`);
+	const admission = readInvalidBlockAdmission(block.admission);
+	return {
+		id: block.id,
+		kind: block.kind,
+		purpose: block.purpose,
+		content: sanitizeSdkRuntimeBlockContent(block.kind, readContentRecord(block.content) ?? {}),
+		draftContent: sanitizeNullableSdkRuntimeBlockContent(block.kind, readNestedContentRecord(block.draftContent)),
+		...admission ? { admission } : {}
+	};
+}
+function readInvalidBlockAdmission(value) {
+	if (!isRecord(value) || value.kind !== "invalid" || !isRecord(value.error)) return null;
+	if (value.error.kind !== "invalid_manifest_content" && value.error.kind !== "manifest_unavailable") return null;
+	return value;
+}
+function buildPageOutline(input) {
+	return {
+		name: input.name,
+		path: input.path ?? input.fallbackPath,
+		purpose: input.purpose,
+		blocks: input.blocks.map(convertPageResponseBlock)
+	};
+}
+function buildRenderablePageOutline(input) {
+	const page = buildPageOutline(input);
+	return {
+		...page,
+		blocks: page.blocks.map((block) => admitSdkRuntimePageBlock(block, input.customBlocks))
+	};
+}
+function projectRenderablePageOutline(page) {
+	return {
+		...page,
+		blocks: page.blocks.flatMap((block) => block.admission.kind === "renderable" ? [{
+			id: block.id,
+			kind: block.kind,
+			purpose: block.purpose,
+			content: block.admission.content,
+			...block.bindings ? { bindings: block.bindings } : {}
+		}] : [])
+	};
+}
+function admitSdkRuntimePageBlock(block, customBlocks) {
+	const base = {
+		id: block.id,
+		kind: block.kind,
+		purpose: block.purpose,
+		...block.bindings ? { bindings: block.bindings } : {}
+	};
+	const transportedAdmission = readInvalidBlockAdmission(block.admission);
+	if (transportedAdmission) return invalidRenderableBlock(base, transportedAdmission.error);
+	const manifest = resolveSdkBlockManifest(block.kind, customBlocks);
+	if (!manifest) return invalidRenderableBlock(base, { kind: "manifest_unavailable" });
+	const content = block.content ?? {};
+	const renderable = admitTransportedRenderableManifestContent(compileManifestContentContract(manifest), content);
+	if (!renderable.ok) return invalidRenderableBlock(base, {
+		kind: "invalid_manifest_content",
+		error: renderable.error
+	});
+	return {
+		...base,
+		admission: {
+			kind: "renderable",
+			content: renderable.value
+		}
+	};
+}
+function resolveSdkBlockManifest(blockKind, customBlocks) {
+	const customBlock = customBlocks?.find((candidate) => candidate.id === blockKind);
+	return customBlock ? parseFieldDefinitions(customBlock.fields) : getBlockDefinition(blockKind)?.manifest ?? null;
+}
+function invalidRenderableBlock(block, error) {
+	return {
+		...block,
+		admission: {
+			kind: "invalid",
+			error
+		}
+	};
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readContentRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+function readNestedContentRecord(value) {
+	if (!isRecord(value)) return null;
+	return readContentRecord(value.data) ?? null;
+}
+function sanitizeSdkRuntimeBlockContent(blockKind, content) {
+	if (blockKind !== "block.newsletter-signup") return content;
+	const sanitized = sanitizeNewsletterSignupPublicContent(content);
+	return isRecord(sanitized) ? sanitized : {};
+}
+function sanitizeNullableSdkRuntimeBlockContent(blockKind, content) {
+	return content ? sanitizeSdkRuntimeBlockContent(blockKind, content) : null;
+}
+//#endregion
 //#region src/rendering/hooks/usePage.ts
 /**
 * Client-side React hook to fetch page data.
@@ -38748,24 +40706,15 @@ function usePage(params) {
 				const { page: pageData } = pageResponse;
 				const canonicalPagePath = pageData.path ?? path;
 				const mediaAssets = Array.isArray(pageResponse.mediaAssets) && pageResponse.mediaAssets.length > 0 ? toMediaAssetSidecar(pageResponse.mediaAssets) : void 0;
-				const blocks = pageData.blocks.map((block) => {
-					if (!block || typeof block !== "object") throw new Error("Invalid block format in API response");
-					if (typeof block.id !== "string" && block.id !== null) throw new Error(`Invalid block id: expected string or null, got ${typeof block.id}`);
-					if (typeof block.kind !== "string") throw new Error(`Invalid block kind: expected string, got ${typeof block.kind}`);
-					if (typeof block.purpose !== "string") throw new Error(`Invalid block purpose: expected string, got ${typeof block.purpose}`);
-					return {
-						id: block.id,
-						kind: block.kind,
-						purpose: block.purpose
-					};
-				});
-				const pageOutline = {
+				const pageOutline = buildRenderablePageOutline({
 					name: pageData.name,
 					path: canonicalPagePath,
+					fallbackPath: path,
 					purpose: pageData.purpose,
-					blocks
-				};
-				const resolvedData = await prefetchBlockData(pageOutline, {
+					blocks: pageData.blocks,
+					customBlocks: resolveSiteCustomBlocks(site)
+				});
+				const resolvedData = await prefetchBlockData(projectRenderablePageOutline(pageOutline), {
 					siteId,
 					pageId: pageId ?? pageData.id,
 					previewStage: preview ? "preview" : "published"