@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/{SdkPreviewModeRuntime-CnWmj-2B.mjs → SdkPreviewModeRuntime-Tda6qw4z.mjs}

@@ -1,7 +1,7 @@
 "use client";
-import { $i as SelectItem, $n as ImageResolveContextProvider, $r as runTransforms, $t as createSnapshotFromPageRecord, Aa as Button, Ai as asDesignBlockId, An as getResponsiveScopeSpec, At as useEditor, Ba as X, Bi as SdkConfigProvider, Bn as resolveEntryRouteTarget, Br as sectionTransitionVariantForBoundaryOptionId, Bt as useEditorUiStoreInstance, Cn as useMediaEditorOptional, Cr as componentRuntimeRulesForTheme, Ct as MediaField, Di as parseThemeForPersistence, Dn as containerResponsiveThemeCss, Dr as surfaceResolutionContextFromTheme, Dt as RichTextField, En as ThemeScope, Et as useRichTextImagePicker, Fa as unsafeAsEditorBlockValues, Fn as getDefaultComponentRegistry, Fr as parseGradientPresetId, Ft as prepareBlockEditorManifest, G as beginAutosaveBatch, Gi as unmapValueFromSelect, Gn as SITE_CHROME_VISIBLE_HEADER_SELECTOR, Gr as ctaButton, Gt as pushHistoryEntry, Hi as hasEmptyOption, Hn as resolveRouteTarget, Hr as backgroundAppearanceQuickColorTokenNames, Ht as canRedoHistory, Ia as assertNever$2, Ii as ORDINARY_TEXT_MIN_CONTRAST_RATIO, In as LINKED_CONTENT_ENTRY_META_KEY, It as stripTopLevelRoutingUi, J as enqueueTransaction, Ja as RotateCcw, Jn as visibleHeaderClearancePx, Jr as eventCalendarListLayoutOptions, Jt as unsafeAsLinkedContentEntryId, K as confirmAutosaveBatch, Ki as FieldFrame, Kn as SITE_OVERLAY_HEADER_CLEARANCE_CSS_VAR, Kr as bindingSchema, Kt as redoHistory, La as expectParsedBrandedId, Li as BlockApiProvider, Ln as coerceLinkedContentEntriesPayload, Lr as defaultSectionTransitionVariantForFamily, Lt as getBlockManifestFromSdkConfig, Ma as cn, Mn as createCustomBlockRegistry, Mr as GRADIENT_PRESETS, Mt as LinkWidgetProvider, Na as parseFooterModuleId, Ni as textColorStyle, Nn as makeDefaultBlockComponent, Nr as GRADIENT_PRESET_IDS, Oi as isThemeV2NormalEditorRawStyleFieldName, On as buildThemeRuntime, Ot as RichTextWidgetProvider, Pa as unsafeAsEditorBlockId, Pn as readBlockComposition, Pr as getGradientPreset, Pt as hideThemeV2RawStyleFields, Q as resolvePreviewSidebarTab, Qi as SelectContent, Qn as clientComponentRegistry, Qr as parseBackgroundContent, Qt as createRoutingHelpers, Ra as parseMediaAssetId, Ri as getFieldIntent, Rn as getLinkedContentEntryMeta, Rr as sectionTransitionFamilies, Sn as MediaEditorContextProvider, Sr as planPageDesignLayoutLookCompatibility, St as FileField, Tn as isSupportedLoaderEndpoint, Tr as designRuntimeRulesForTheme, Tt as ReferenceWidgetProvider, Ui as mapCurrentValueForSelect, Un as getBlockDefinition, Ur as parseBackgroundAppearanceColorToken, Ut as canUndoHistory, Va as Upload, Vi as useSdkConfig, Vn as resolvePageRouteTarget, Vr as backgroundAppearanceColorTokenNames, Vt as useOptionalEditorUiStoreInstance, Wi as mapOptionValueForSelect, Wn as projectRecurringSchedule, Wr as defaultThemeTokens, Wt as createHistoryState, X as rejectAutosaveBatch, Xn as compileManifestContentContract, Y as idleEditorTransactionQueueState, Yn as resolveVariantKey, Yr as bookingConsentCarrierSchema, Yt as recordsEqual, Zi as Select, Zn as validateManifestDraft, Zr as planSiteChromePlacement, Zt as useDebouncedLatestSave, _ as PREVIEW_DESIGN_SAVE_ERROR_MESSAGE, _a as DialogHeader, _i as getAtPath, _r as formatSiteChromeBackgroundTokenLabel, _t as IconPickerField, ai as isRecord$13, ar as blogFeaturedPostFragment, at as useUISelector, bn as deriveLaunchReadiness, br as retargetCompiledBoundaryRuntimeForContentAdjacency, bt as ButtonVariantField, ci as isInlineTextEmpty, cr as formCopyFragment, da as TabsList, di as buildResolveImageUrlContext, dn as FormRenderer, dr as ctaCopyFragment, dt as createSiteOptionWidgetAdapters, ea as SelectTrigger, ei as parseBlockIconValue, en as BUILT_IN_REFERENCE_KINDS, er as richTextFragment, et as renderSiteChromeBlock, f as PreviewDesignCoordinatorProvider, fa as TabsTrigger, fi as getCurrentResolveImageUrlContext, fn as evaluateVisibility, fr as heroCtaRowFragment, ft as SiteOptionPickerField, g as PREVIEW_DESIGN_LOAD_ERROR_MESSAGE, ga as DialogFooter, gi as attachRenderableMediaAssetFields, gn as getPageDesignEditorState, gr as defineFragment, gt as InlineTextField, h as usePreviewThemeOverlay, ha as DialogDescription, hi as SECTION_BACKGROUND_MIN_SOURCE_WIDTH, hn as applyPageDesignEditorAction, hr as bodyCopyFragment, ht as OfferingsPreviewWidgetProvider, i as usePreviewDesignHistoryOrder, ii as isObjectRecord, ir as faqHeadingFragment, ji as assertNever$1, jn as escapeStyleContent, jr as gradientToCss, jt as LinkField, ki as pageDesignEditorBackgroundOverrideOwner, kn as DEFAULT_THEME_RESPONSIVE_MODE, kt as EditorProvider, la as Tabs, li as Text$1, ln as createManifestFormAdapter, lr as testimonialsCarouselFragment, lt as useEntryEditorController, m as PreviewThemeOverlayProvider, ma as DialogContent, mi as setContextResolveImageUrlContext, mn as MediaEditor, mr as heroCopyFragment, mt as OfferingsPreviewGroupOrderField, n as useSiteChromeCustomizeOptional, ni as parseGeneratedIconSetId, nn as parseReferenceKind, no as Image, nr as cardFragment, nt as PreviewInlineTextEditor, oi as coerceInlineTextWithFallback, on as PaletteProvider, oo as ChevronRight, or as singleButtonFragment, ot as EditableBlockProvider, pa as Dialog, pi as resolveImageUrlWithContext, pn as createStoreBackend, pr as ctaRowFragment, pt as SiteOptionWidgetProvider, q as deriveTransactionCapabilities, qi as useField, qn as planSiteOverlayHeaderClearance, qr as eventCalendarListLayoutCompatibleDisplayModeValues, qt as undoHistory, r as PreviewDesignHistoryOrderProvider, ri as renderInlineText, ro as GripVertical, rr as faqAccordionFragment, rt as PreviewTextEditor, si as inlineTextToPlainText, sn as usePalette, so as ChevronLeft, sr as formEmbedFragment, st as EntryControllerProvider, t as SiteChromeCustomizeProvider, ta as SelectValue, ti as parseGeneratedIconAssetId, tr as headingFragment, tt as PreviewRichTextEditor, ua as TabsContent, ui as RichText$1, uo as __exportAll, ur as testimonialsHeadingFragment, ut as createSiteOptionApiLoader, v as reportPreviewDesignError, va as DialogTitle, vi as siblingPath, vn as decodePublicProductCategorySelectorQuery, vr as applyCompiledRuntimeFieldsToContent, vt as EntryPickerField, wn as useApiMediaUploader, wt as ReferenceField, xn as AMBIENT_BACKGROUND_ROLES, xr as retargetCompiledRuntimeFieldsForContentAdjacency, xt as ButtonWidgetProvider, yn as DEFAULT_LAUNCH_READINESS_INPUT, yr as compileEditorModelRuntime, yt as EntryPickerWidgetProvider, za as parseSiteId, zi as isHeaderField, zn as defaultTransforms, zr as sectionTransitionFamilyForBoundaryOptionId, zt as useEditorUiStore } from "./SiteChromeCustomizeContext-B6d5zkog.mjs";
-import { i as useOptionalPreviewLayout, t as PreviewQueryProvider } from "./PreviewQueryProvider-wbEpXryy.mjs";
-import { _ as API_ENDPOINTS, a as usePreviewToken, c as createBearerAPIClient, d as unwrapResponse, g as resolveSurfaceDocumentAttributes, h as SURFACE_IDS, i as usePreviewAuthFetch, m as SURFACE_DOCUMENT_DATA_ATTRIBUTE, n as markPreviewAuthExpired, o as isPreviewRuntimeSessionEditable, r as usePreviewAuth, s as ApiRequestError, t as initPreviewAuth } from "./previewAuthStore-DbqBol0V.mjs";
+import { $n as ImageResolveContextProvider, $r as parseGeneratedIconAssetId, $t as createSnapshotFromPageRecord, An as getBlockDefinition, At as useEditor, Ba as assertNever$2, Bn as DEFAULT_THEME_RESPONSIVE_MODE, Br as sectionTransitionFamilyForBoundaryOptionId, Bt as useEditorUiStoreInstance, Ci as pageDesignEditorBackgroundOverrideOwner, Cn as useMediaEditorOptional, Cr as componentRuntimeRulesForTheme, Ct as MediaField, Dn as containerResponsiveThemeCss, Dr as compileTransitionRuntime, Dt as RichTextField, Ei as makeBoundaryId, En as ThemeScope, Et as useRichTextImagePicker, Fn as visibleHeaderClearancePx, Fr as getGradientPreset, Ft as prepareBlockEditorManifest, G as confirmAutosaveBatch, Ga as Upload, Gi as useSdkConfig, Gn as defaultTransforms, Gr as defaultThemeTokens, Gt as pushHistoryEntry, Ha as parseMediaAssetId, Hi as getFieldIntent, Hn as escapeStyleContent, Hr as backgroundAppearanceColorTokenNames, Ht as canRedoHistory, Ia as cn, Ii as parseThemeForPersistence, In as resolveVariantKey, Ir as parseGradientPresetId, It as stripTopLevelRoutingUi, J as idleEditorTransactionQueueState, Ji as mapOptionValueForSelect, Jn as resolveRouteTarget, Jt as unsafeAsLinkedContentEntryId, K as deriveTransactionCapabilities, Ki as hasEmptyOption, Kn as resolveEntryRouteTarget, Kr as ctaButton, Kt as redoHistory, La as parseFooterModuleId, Li as ORDINARY_TEXT_MIN_CONTRAST_RATIO, Ln as compileManifestContentContract, Lt as getBlockManifestFromSdkConfig, Mn as SITE_CHROME_VISIBLE_HEADER_SELECTOR, Mr as gradientToCss, Mt as LinkWidgetProvider, Nn as SITE_OVERLAY_HEADER_CLEARANCE_CSS_VAR, Nr as GRADIENT_PRESETS, On as createCustomBlockRegistry, Or as surfaceResolutionContextFromTheme, Ot as RichTextWidgetProvider, Pa as Button, Pi as textColorStyle, Pn as planSiteOverlayHeaderClearance, Pr as GRADIENT_PRESET_IDS, Pt as hideThemeV2RawStyleFields, Q as resolvePreviewSidebarTab, Qa as RotateCcw, Qn as clientComponentRegistry, Qr as parseBlockIconValue, Qt as createRoutingHelpers, Ra as unsafeAsEditorBlockId, Rn as validateManifestDraft, Rr as defaultSectionTransitionVariantForFamily, Sa as DialogTitle, Si as isThemeV2NormalEditorRawStyleFieldName, Sn as MediaEditorContextProvider, Sr as planPageDesignLayoutLookCompatibility, St as FileField, Ti as assertNever$1, Tn as isSupportedLoaderEndpoint, Tr as designRuntimeRulesForTheme, Tt as ReferenceWidgetProvider, Ua as parseSiteId, Ui as isHeaderField, Un as readBlockComposition, Ur as backgroundAppearanceQuickColorTokenNames, Ut as canUndoHistory, Va as expectParsedBrandedId, Vi as attachRenderableMediaAssetFields, Vn as getResponsiveScopeSpec, Vr as sectionTransitionVariantForBoundaryOptionId, Vt as useOptionalEditorUiStoreInstance, W as beginAutosaveBatch, Wa as X, Wi as SdkConfigProvider, Wn as getDefaultComponentRegistry, Wr as parseBackgroundAppearanceColorToken, Wt as createHistoryState, Xi as FieldFrame, Xn as coerceLinkedContentEntriesPayload, Xr as parseBackgroundContent, Y as rejectAutosaveBatch, Yi as unmapValueFromSelect, Yn as LINKED_CONTENT_ENTRY_META_KEY, Yr as planSiteChromePlacement, Yt as recordsEqual, Zi as useField, Zn as getLinkedContentEntryMeta, Zr as runTransforms, Zt as useDebouncedLatestSave, _ as reportPreviewDesignError, _a as Dialog, _i as eventCalendarListLayoutCompatibleDisplayModeValues, _r as applyCompiledRuntimeFieldsToContent, _t as IconPickerField, aa as SelectValue, ai as isInlineTextEmpty, ar as blogFeaturedPostFragment, at as useUISelector, ba as DialogFooter, bi as isObjectRecord, bn as deriveLaunchReadiness, br as retargetCompiledRuntimeFieldsForContentAdjacency, bt as ButtonVariantField, ci as buildResolveImageUrlContext, cr as formCopyFragment, d as PreviewDesignCoordinatorProvider, di as setContextResolveImageUrlContext, dn as FormRenderer, do as ChevronLeft, dr as ctaCopyFragment, dt as createSiteOptionWidgetAdapters, ei as parseGeneratedIconSetId, en as BUILT_IN_REFERENCE_KINDS, er as richTextFragment, et as renderSiteChromeBlock, fi as SECTION_BACKGROUND_MIN_SOURCE_WIDTH, fn as evaluateVisibility, fr as heroCtaRowFragment, ft as SiteOptionPickerField, g as PREVIEW_DESIGN_SAVE_ERROR_MESSAGE, ga as TabsTrigger, gi as calendarWindowQuerySchema, gn as getPageDesignEditorState, gr as defineFragment, gt as InlineTextField, h as PREVIEW_DESIGN_LOAD_ERROR_MESSAGE, ha as TabsList, hi as BlockApiProvider, hn as applyPageDesignEditorAction, hr as bodyCopyFragment, ht as OfferingsPreviewWidgetProvider, i as usePreviewDesignHistoryOrder, ia as SelectTrigger, ii as inlineTextToPlainText, ir as faqHeadingFragment, jn as projectRecurringSchedule, jt as LinkField, kn as makeDefaultBlockComponent, kt as EditorProvider, li as getCurrentResolveImageUrlContext, ln as createManifestFormAdapter, lr as testimonialsCarouselFragment, lt as useEntryEditorController, m as usePreviewThemeOverlay, ma as TabsContent, mi as siblingPath, mn as MediaEditor, mo as __exportAll, mr as heroCopyFragment, mt as OfferingsPreviewGroupOrderField, n as useSiteChromeCustomizeOptional, na as SelectContent, ni as logger, nn as parseReferenceKind, nr as cardFragment, nt as PreviewInlineTextEditor, oi as Text$1, on as PaletteProvider, oo as Image, or as singleButtonFragment, ot as EditableBlockProvider, p as PreviewThemeOverlayProvider, pa as Tabs, pi as getAtPath, pn as createStoreBackend, pr as ctaRowFragment, pt as SiteOptionWidgetProvider, q as enqueueTransaction, qi as mapCurrentValueForSelect, qn as resolvePageRouteTarget, qr as bindingSchema, qt as undoHistory, r as PreviewDesignHistoryOrderProvider, ra as SelectItem, ri as coerceInlineTextWithFallback, rr as faqAccordionFragment, rt as PreviewTextEditor, si as RichText$1, sn as usePalette, so as GripVertical, sr as formEmbedFragment, st as EntryControllerProvider, t as SiteChromeCustomizeProvider, ta as Select, ti as renderInlineText, tr as headingFragment, tt as PreviewRichTextEditor, ui as resolveImageUrlWithContext, uo as ChevronRight, ur as testimonialsHeadingFragment, ut as createSiteOptionApiLoader, va as DialogContent, vi as eventCalendarListLayoutOptions, vn as decodePublicProductCategorySelectorQuery, vr as compileEditorModelRuntime, vt as EntryPickerField, wi as asDesignBlockId, wn as useApiMediaUploader, wt as ReferenceField, xa as DialogHeader, xi as isRecord$13, xn as AMBIENT_BACKGROUND_ROLES, xr as formatSiteChromeBackgroundTokenLabel, xt as ButtonWidgetProvider, ya as DialogDescription, yi as bookingConsentCarrierSchema, yn as DEFAULT_LAUNCH_READINESS_INPUT, yr as retargetCompiledBoundaryRuntimeForContentAdjacency, yt as EntryPickerWidgetProvider, za as unsafeAsEditorBlockValues, zn as buildThemeRuntime, zr as sectionTransitionFamilies, zt as useEditorUiStore } from "./SiteChromeCustomizeContext-BHFgMjde.mjs";
+import { i as useOptionalPreviewLayout, t as PreviewQueryProvider } from "./PreviewQueryProvider-BguJY1SW.mjs";
+import { _ as API_ENDPOINTS, a as usePreviewToken, c as createBearerAPIClient, d as unwrapResponse, g as resolveSurfaceDocumentAttributes, h as SURFACE_IDS, i as usePreviewAuthFetch, m as SURFACE_DOCUMENT_DATA_ATTRIBUTE, n as markPreviewAuthExpired, o as isPreviewRuntimeSessionEditable, r as usePreviewAuth, s as ApiRequestError, t as initPreviewAuth } from "./previewAuthStore-BkEgnYPP.mjs";
 import * as React$1 from "react";
 import React, { Children, Fragment, cloneElement, createContext, isValidElement, useCallback, useContext, useEffect, useId, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -345,6 +345,473 @@ function getFragmentRegistry() {
 	return fragmentRegistry;
 }
 //#endregion
+//#region ../blocks/src/pageRenderingMode.ts
+var MissingBlockOverrideError = class extends Error {
+	constructor(blockKind) {
+		super(`Override-only rendering requires an override for block kind "${blockKind}".`);
+		this.blockKind = blockKind;
+		this.code = "missing_block_override";
+		this.name = "MissingBlockOverrideError";
+	}
+};
+function isOverrideOnlyResourceInput(props) {
+	return props.rendering?.kind === "overrides-only";
+}
+function resolvePageThemeResources(props) {
+	if (isOverrideOnlyResourceInput(props)) return { kind: "unavailable" };
+	return {
+		kind: "available",
+		tokens: props.themeTokens ?? buildThemeRuntime(props.theme).tokens,
+		config: props.theme
+	};
+}
+function requireBlockOverride(resources, override, blockKind) {
+	if (resources.kind === "unavailable" && !override) throw new MissingBlockOverrideError(blockKind);
+}
+function overrideThemeProps(resources) {
+	return resources.kind === "available" ? {
+		theme: resources.tokens,
+		themeConfig: resources.config
+	} : {};
+}
+function requireThemeResources(resources, blockKind) {
+	if (resources.kind === "unavailable") throw new MissingBlockOverrideError(blockKind);
+	return resources;
+}
+//#endregion
+//#region ../blocks/src/pageRendererBoundaries.tsx
+const boundaryKey = (previousBlockId, nextBlockId) => `${previousBlockId}\u0000${nextBlockId}`;
+function isSiteStyleTransitionStyleGroup(value) {
+	return value?.startsWith("site-style-transition-") === true;
+}
+function boundaryMapForAdjacentBlockIds(boundaries) {
+	return new Map(boundaries.map((boundary) => [boundaryKey(boundary.previousBlockId, boundary.nextBlockId), boundary]));
+}
+function boundaryBetweenBlocks(previousBlock, nextBlock, boundaries) {
+	const previousBlockId = previousBlock?.id ?? null;
+	const nextBlockId = nextBlock?.id ?? null;
+	if (!previousBlockId || !nextBlockId) return null;
+	return boundaries.get(boundaryKey(previousBlockId, nextBlockId)) ?? null;
+}
+function renderBoundaryAfterBlock(input) {
+	const previousBlockId = input.block.id;
+	const nextBlockId = input.nextBlock?.id ?? null;
+	if (!previousBlockId || !nextBlockId) return null;
+	const boundary = input.boundaryByAdjacentBlockIds.get(boundaryKey(previousBlockId, nextBlockId));
+	if (!boundary) return null;
+	const rendered = /* @__PURE__ */ jsx("div", {
+		"aria-hidden": "true",
+		"data-block-boundary": "",
+		"data-boundary-id": boundary.boundaryId,
+		"data-boundary-previous-block-id": boundary.previousBlockId,
+		"data-boundary-next-block-id": boundary.nextBlockId,
+		"data-style-group": boundary.styleGroup,
+		style: boundaryCssVarsStyle(boundary)
+	}, `${input.blockKey}:boundary`);
+	return input.wrapBoundary ? input.wrapBoundary(boundary, rendered) : rendered;
+}
+function boundaryCssVarsStyle(boundary) {
+	return {
+		"--site-style-transition-from": boundary.cssVars.from,
+		"--site-style-transition-to": boundary.cssVars.to
+	};
+}
+function boundaryReserveCssVarsStyle(input) {
+	const before = input.before?.metrics.reserveCss ?? null;
+	const after = input.after?.metrics.reserveCss ?? null;
+	if (!before && !after) return void 0;
+	return {
+		...before ? { "--site-style-boundary-before-reserve": before } : {},
+		...after ? { "--site-style-boundary-after-reserve": after } : {}
+	};
+}
+function transitionCssVarsStyle(content) {
+	const transitionStyles = isObjectRecord(content._transitionStyles) ? content._transitionStyles : null;
+	const cssVars = isObjectRecord(transitionStyles?.cssVars) ? transitionStyles.cssVars : null;
+	const from = typeof cssVars?.from === "string" ? cssVars.from : null;
+	const to = typeof cssVars?.to === "string" ? cssVars.to : null;
+	if (!from && !to) return void 0;
+	return {
+		...from ? { "--site-style-transition-from": from } : {},
+		...to ? { "--site-style-transition-to": to } : {}
+	};
+}
+function mergeStyleObjects(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return {
+		...left,
+		...right
+	};
+}
+function pageBlockPosition(index, blockCount) {
+	if (blockCount <= 1) return "only";
+	if (index === 0) return "first";
+	if (index === blockCount - 1) return "last";
+	return "middle";
+}
+//#endregion
+//#region ../blocks/src/pageRenderAudience.tsx
+/**
+* The single policy for what a non-renderable block looks like.
+*
+* Public visitors never see renderer diagnostics, so every reason omits.
+* Authoring surfaces keep the wording they have always had — the strings below
+* are moved verbatim from the five former `fallback()` call sites.
+*/
+function presentNotRenderableBlock(reason, audience) {
+	if (audience === "public") return null;
+	return diagnostic(authoringMessage(reason));
+}
+function authoringMessage(reason) {
+	switch (reason.kind) {
+		case "invalid-admission": return `Invalid content for block kind "${reason.blockKind}".`;
+		case "missing-definition": return reason.isCustom ? `No renderer available for block kind "${reason.blockKind}". The custom block definition was not found (missing manifest).` : `No renderer available for block kind "${reason.blockKind}".`;
+		case "missing-layout": return reason.isCustom ? `No renderer available for block kind "${reason.blockKind}". This custom block has no layout/variants, so it must be rendered via blockOverrides["${reason.blockKind}"].` : `No renderer available for block kind "${reason.blockKind}".`;
+		case "editor-unpreviewable":
+		case "render-threw": return `Unable to render block kind "${reason.blockKind}".`;
+	}
+}
+/**
+* The empty-page notice. Authoring-only for the same reason as the block
+* diagnostics: "No blocks found." is a message for whoever is building the
+* page, not for whoever is reading it.
+*/
+function presentEmptyPage(audience) {
+	if (audience === "public") return null;
+	return diagnostic("No blocks found.");
+}
+function diagnostic(message) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "rb-p-6 rb-caption",
+		style: textColorStyle("mutedText"),
+		children: message
+	});
+}
+//#endregion
+//#region ../blocks/src/pageRenderDiagnostics.ts
+/**
+* Emits one structured record per omitted block, per server render pass.
+*
+* Server-only by decision D3: public pages are server-rendered, and this is the
+* runtime whose logger transport reaches centralised collection. A browser-side
+* record would not, and re-render/hydration would multiply it. The cost is that
+* an omission only a client navigation can see goes unlogged.
+*
+* Deliberately *not* inside the plan's `useMemo` — React makes no promises about
+* when a memo recomputes, so a log placed there is neither reliable nor bounded.
+*/
+function logOmittedBlocks(plan, dataContext) {
+	if (typeof window !== "undefined") return;
+	if (plan.omitted.length === 0) return;
+	const page = {
+		siteId: dataContext?.siteId ?? null,
+		pageId: dataContext?.pageId ?? null
+	};
+	if (plan.entries.length === 0) {
+		logger.error("blocks.pageRenderer.pageFullyOmitted", {
+			...page,
+			omittedCount: plan.omitted.length,
+			blocks: plan.omitted.map((omission) => ({
+				blockId: omission.blockId,
+				blockKind: omission.blockKind,
+				reason: omission.reason.kind
+			}))
+		});
+		debugOmittedCustomBlocks(plan);
+		return;
+	}
+	for (const omission of plan.omitted) logger.warn("blocks.pageRenderer.blockOmitted", {
+		...page,
+		blockId: omission.blockId,
+		blockKind: omission.blockKind,
+		reason: omission.reason.kind,
+		admissionError: omission.reason.kind === "invalid-admission" ? omission.reason.error.kind : null
+	});
+	debugOmittedCustomBlocks(plan);
+}
+/**
+* Unlike the plan-time omissions this one genuinely can fire per re-render —
+* it is raised where the failure happens, and no once-ness is claimed for it.
+*/
+function logRenderThrew(block, dataContext) {
+	if (typeof window !== "undefined") return;
+	logger.warn("blocks.pageRenderer.blockRenderThrew", {
+		siteId: dataContext?.siteId ?? null,
+		pageId: dataContext?.pageId ?? null,
+		blockId: block.id ?? null,
+		blockKind: block.kind
+	});
+}
+/**
+* Opt-in developer affordance for tracking down custom-block resolution.
+*
+* Driven off the plan's omissions so it stays reachable on **public** renders —
+* "my custom block doesn't show up on the live site" is the exact situation it
+* exists for, and that is the render where the block is now silently absent.
+*/
+function debugOmittedCustomBlocks(plan) {
+	if (!shouldDebugCustomBlocks()) return;
+	for (const omission of plan.omitted) {
+		if (!omission.blockKind.startsWith("custom.")) continue;
+		debugCustomBlockResolution(omission.reason.kind, omission.blockId, omission.blockKind, omission.debug);
+	}
+}
+/** The authoring-side equivalent, where the block stays in the entry list. */
+function debugCustomBlockDiagnostic(reason, block, debug) {
+	if (!block.kind.startsWith("custom.") || !shouldDebugCustomBlocks()) return;
+	debugCustomBlockResolution(reason.kind, block.id ?? null, block.kind, debug);
+}
+function debugCustomBlockResolution(reasonKind, blockId, blockKind, debug) {
+	try {
+		console.warn(reasonKind === "missing-definition" ? "[blocks:PageRenderer] custom block definition missing" : "[blocks:PageRenderer] custom block has no layout/variants and no override", {
+			blockId,
+			blockKind,
+			hasOverride: debug.hasOverride,
+			sdkCustomBlocksCount: debug.sdkCustomBlocksCount,
+			dbCustomBlocksCount: debug.dbCustomBlocksCount,
+			manifestKeys: debug.manifestKeys
+		});
+	} catch {}
+}
+function shouldDebugCustomBlocks() {
+	try {
+		return globalThis.process?.env?.DEBUG_CUSTOM_BLOCKS === "1";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../blocks/src/pageRenderPlan.ts
+/**
+* Decides, once per page render, which blocks can render and what happens to
+* the ones that cannot.
+*
+* Pure. Effects — logging in particular — belong at the call site, because this
+* runs inside a `useMemo` whose recomputation React makes no promises about.
+*/
+function buildPageRenderPlan(input) {
+	const resolveTarget = createRenderTargetResolver(input);
+	const entries = [];
+	const omitted = [];
+	for (const block of input.page.blocks) {
+		const outcome = planBlock(block, getRenderableContent(block, input.previewStage), resolveTarget);
+		if (outcome.kind !== "diagnostic") {
+			entries.push(outcome);
+			continue;
+		}
+		const resolved = resolveTarget(block.kind);
+		const debug = {
+			hasOverride: Boolean(resolved.override),
+			sdkCustomBlocksCount: input.sdkConfig?.customBlocks?.length ?? 0,
+			dbCustomBlocksCount: input.customBlocks?.length ?? 0,
+			manifestKeys: resolved.definition ? Object.keys(resolved.definition.manifest ?? {}).sort() : null
+		};
+		if (input.audience === "public") {
+			omitted.push({
+				blockId: block.id ?? null,
+				blockKind: block.kind,
+				reason: outcome.reason,
+				override: resolved.override,
+				debug
+			});
+			continue;
+		}
+		entries.push({
+			...outcome,
+			debug
+		});
+	}
+	return {
+		entries,
+		omitted,
+		runtimeBoundaries: retargetBoundariesAcrossOmissions({
+			boundaries: input.runtimeBoundaries,
+			originalBlocks: input.page.blocks,
+			survivingBlocks: new Set(entries.map((entry) => entry.block)),
+			previewStage: input.previewStage
+		})
+	};
+}
+/**
+* Mirrors the order of the checks `MemoBlockSection` used to make inline, so no
+* case changes meaning: admission first, then definition/override resolution,
+* then the layout requirement.
+*/
+function planBlock(block, renderableContent, resolveTarget) {
+	const common = {
+		block,
+		renderableContent
+	};
+	if (block.presentationAdmission.kind === "invalid") return {
+		...common,
+		kind: "diagnostic",
+		reason: {
+			kind: "invalid-admission",
+			blockKind: block.kind,
+			error: block.presentationAdmission.error
+		}
+	};
+	const { definition, systemDefinition, override } = resolveTarget(block.kind);
+	const isCustom = block.kind.startsWith("custom.");
+	if (!definition) return override ? {
+		...common,
+		kind: "override-only",
+		override
+	} : {
+		...common,
+		kind: "diagnostic",
+		reason: {
+			kind: "missing-definition",
+			blockKind: block.kind,
+			isCustom
+		}
+	};
+	const manifestHasLayout = Boolean(definition.manifest.layout) || Object.keys(definition.manifest.variants ?? {}).length > 0;
+	if (!override && !manifestHasLayout) return {
+		...common,
+		kind: "diagnostic",
+		reason: {
+			kind: "missing-layout",
+			blockKind: block.kind,
+			isCustom
+		}
+	};
+	return {
+		...common,
+		kind: "renderable",
+		definition,
+		override,
+		variantKey: systemDefinition ? resolveVariantKey(systemDefinition.manifest, renderableContent) ?? null : null,
+		managesOwnWrapper: Boolean(systemDefinition?.manifest.behaviours?.managesOwnWrapper)
+	};
+}
+/**
+* Resolves definition + override once per block kind, and builds the
+* custom-block registry at most once per plan rather than once per custom
+* block, which is what the previous inline path did.
+*/
+function createRenderTargetResolver(input) {
+	const cache = /* @__PURE__ */ new Map();
+	let customRegistry = null;
+	const customRegistryOnce = () => {
+		customRegistry ?? (customRegistry = createCustomBlockRegistry({
+			sdkConfig: input.sdkConfig,
+			customBlocks: (input.customBlocks ?? []).map((manifest) => ({
+				manifest,
+				source: { kind: "managed-database" }
+			}))
+		}));
+		return customRegistry;
+	};
+	return (blockKind) => {
+		const cached = cache.get(blockKind);
+		if (cached) return cached;
+		const systemDefinition = getBlockDefinition(blockKind);
+		const resolved = {
+			definition: systemDefinition ?? (blockKind.startsWith("custom.") ? customRegistryOnce().findManifest(blockKind)?.descriptor.definition : void 0),
+			systemDefinition,
+			override: getBlockOverride(blockKind, input.blockOverrides)
+		};
+		cache.set(blockKind, resolved);
+		return resolved;
+	};
+}
+/**
+* Look up a block override component by block kind.
+* Supports both full ("block.hero") and short ("hero") keys.
+*/
+function getBlockOverride(blockKind, overrides) {
+	if (!overrides) return void 0;
+	if (overrides[blockKind]) return overrides[blockKind];
+	return overrides[blockKind.replace(/^block\./, "")];
+}
+/**
+* Resolves block content based on stage priority.
+* For draft/preview: draftContent takes priority over content.
+* For published: content is the source of truth.
+*/
+function getRenderableContent(block, previewStage = "published") {
+	const source = previewStage === "preview" && block.draftContent ? block.draftContent : block.content ?? {};
+	return isObjectRecord(source) ? source : {};
+}
+/**
+* Re-points section boundaries across omitted blocks.
+*
+* Boundaries are keyed by adjacent block-id *pairs*, so dropping B from
+* [A, B, C] does not merely remove B's boundaries — it removes the boundary
+* between the survivors, because no `A→C` key was ever compiled.
+*
+* Per decision D2 the treatment for a merged gap comes from the boundary
+* entering the omitted run (`A→firstOmitted`), falling back to the one leaving
+* it (`lastOmitted→C`). The destination surface is a separate question: only
+* the exiting boundary knows what C looks like, so the merged boundary ends on
+* that endpoint rather than on the omitted block's. In the exiting-only
+* fallback the origin remains an approximation: `from` is the omitted block's
+* surface, because no compiled boundary carries A's. The hosted path no longer
+* needs this at all (site-renderer admits blocks before compiling boundaries);
+* it remains the safety net for an SDK whose compiled boundaries predate an
+* omission.
+*/
+function retargetBoundariesAcrossOmissions(input) {
+	const { boundaries, originalBlocks, survivingBlocks, previewStage } = input;
+	if (boundaries === void 0) return void 0;
+	if (boundaries.length === 0) return boundaries;
+	if (!originalBlocks.some((block) => !survivingBlocks.has(block))) return boundaries;
+	const byPair = new Map(boundaries.map((boundary) => [pairKey(boundary.previousBlockId, boundary.nextBlockId), boundary]));
+	const retargeted = [];
+	let previousSurvivor = null;
+	let run = [];
+	for (const block of originalBlocks) {
+		if (!survivingBlocks.has(block)) {
+			run.push(block);
+			continue;
+		}
+		if (previousSurvivor?.id && block.id) {
+			const boundary = run.length === 0 ? byPair.get(pairKey(previousSurvivor.id, block.id)) : mergedBoundary({
+				byPair,
+				previousBlock: previousSurvivor,
+				previousBlockId: previousSurvivor.id,
+				nextBlock: block,
+				nextBlockId: block.id,
+				run,
+				previewStage
+			});
+			if (boundary) retargeted.push(boundary);
+		}
+		previousSurvivor = block;
+		run = [];
+	}
+	return retargeted;
+}
+function mergedBoundary(input) {
+	const { byPair, previousBlock, previousBlockId, nextBlock, nextBlockId, run, previewStage } = input;
+	const firstOmittedId = run[0]?.id;
+	const lastOmittedId = run[run.length - 1]?.id;
+	const entering = firstOmittedId ? byPair.get(pairKey(previousBlockId, firstOmittedId)) : void 0;
+	const exiting = lastOmittedId ? byPair.get(pairKey(lastOmittedId, nextBlockId)) : void 0;
+	const donor = entering ?? exiting;
+	if (!donor) return void 0;
+	const transition = compileTransitionRuntime({
+		treatment: donor.treatment,
+		from: donor.from,
+		to: exiting?.to ?? donor.to
+	});
+	return retargetCompiledBoundaryRuntimeForContentAdjacency({
+		...donor,
+		boundaryId: makeBoundaryId(asDesignBlockId(previousBlockId), asDesignBlockId(nextBlockId)),
+		previousBlockId,
+		nextBlockId,
+		from: transition.from,
+		to: transition.to,
+		cssVars: transition.cssVars
+	}, {
+		currentContent: getRenderableContent(previousBlock, previewStage),
+		nextContent: getRenderableContent(nextBlock, previewStage)
+	});
+}
+const pairKey = boundaryKey;
+//#endregion
 //#region ../blocks/src/system/manifest/hydrateLinks.ts
 /**
 * Hydrates link objects within block content using the provided route map. Returns
@@ -467,112 +934,202 @@ function resolveBlockData(blockId, dataLoaders, dataContext, routes) {
 	return dataLoaders && typeof dataLoaders === "object" && Object.keys(dataLoaders).length > 0 ? {} : void 0;
 }
 //#endregion
-//#region ../blocks/src/pageRenderingMode.ts
-var MissingBlockOverrideError = class extends Error {
-	constructor(blockKind) {
-		super(`Override-only rendering requires an override for block kind "${blockKind}".`);
-		this.blockKind = blockKind;
-		this.code = "missing_block_override";
-		this.name = "MissingBlockOverrideError";
+//#region ../blocks/src/pageRenderPreparation.ts
+/**
+* Stage two of the render plan.
+*
+* `buildPageRenderPlan` decides everything knowable from the page and the block
+* registries. This pass decides everything knowable once the *render* inputs are
+* in scope — routes, resolved data, theme resources — which is where content
+* parsing, link hydration and data resolution can throw.
+*
+* Why a second stage rather than folding `render-threw` into `buildPageRenderPlan`
+* with the other three reasons: the work that throws reads `dataContext`,
+* `routeMap` and `themeResources`, none of which are plan inputs. Adding them
+* would make every plan entry a fresh object on every render whose `dataContext`
+* identity changed, and entry identity is exactly what `MemoBlockSection`'s
+* comparator uses to skip a block subtree. So the decision moves as early as its
+* inputs allow — before any wrapper markup exists — and no earlier.
+*
+* Pure, and memoised by the caller. Failures come back as data so the logging
+* stays at the edge (decision D3), matching `buildPageRenderPlan`.
+*/
+function preparePageRender(input) {
+	const entries = [];
+	const constructionFailures = [];
+	for (const entry of input.plan.entries) {
+		const prepared = prepareEntry(entry, input);
+		if (prepared.kind === "render-threw") constructionFailures.push(entry);
+		entries.push({
+			entry,
+			prepared
+		});
 	}
-};
-function isOverrideOnlyResourceInput(props) {
-	return props.rendering?.kind === "overrides-only";
-}
-function resolvePageThemeResources(props) {
-	if (isOverrideOnlyResourceInput(props)) return { kind: "unavailable" };
+	if (constructionFailures.length === 0 || input.audience === "authoring") return {
+		entries,
+		constructionFailures,
+		runtimeBoundaries: input.plan.runtimeBoundaries
+	};
+	const survivors = entries.filter((candidate) => candidate.prepared.kind !== "render-threw");
 	return {
-		kind: "available",
-		tokens: props.themeTokens ?? buildThemeRuntime(props.theme).tokens,
-		config: props.theme
+		entries: survivors,
+		constructionFailures,
+		runtimeBoundaries: retargetBoundariesAcrossOmissions({
+			boundaries: input.plan.runtimeBoundaries,
+			originalBlocks: input.plan.entries.map((planned) => planned.block),
+			survivingBlocks: new Set(survivors.map((survivor) => survivor.entry.block)),
+			previewStage: input.previewStage
+		})
 	};
 }
-function requireBlockOverride(resources, override, blockKind) {
-	if (resources.kind === "unavailable" && !override) throw new MissingBlockOverrideError(blockKind);
-}
-function overrideThemeProps(resources) {
-	return resources.kind === "available" ? {
-		theme: resources.tokens,
-		themeConfig: resources.config
-	} : {};
-}
-function requireThemeResources(resources, blockKind) {
-	if (resources.kind === "unavailable") throw new MissingBlockOverrideError(blockKind);
-	return resources;
-}
-//#endregion
-//#region ../blocks/src/pageRendererBoundaries.tsx
-const boundaryKey = (previousBlockId, nextBlockId) => `${previousBlockId}\u0000${nextBlockId}`;
-function isSiteStyleTransitionStyleGroup(value) {
-	return value?.startsWith("site-style-transition-") === true;
-}
-function boundaryMapForAdjacentBlockIds(boundaries) {
-	return new Map(boundaries.map((boundary) => [boundaryKey(boundary.previousBlockId, boundary.nextBlockId), boundary]));
-}
-function boundaryBetweenBlocks(previousBlock, nextBlock, boundaries) {
-	const previousBlockId = previousBlock?.id ?? null;
-	const nextBlockId = nextBlock?.id ?? null;
-	if (!previousBlockId || !nextBlockId) return null;
-	return boundaries.get(boundaryKey(previousBlockId, nextBlockId)) ?? null;
-}
-function renderBoundaryAfterBlock(input) {
-	const previousBlockId = input.block.id;
-	const nextBlockId = input.nextBlock?.id ?? null;
-	if (!previousBlockId || !nextBlockId) return null;
-	const boundary = input.boundaryByAdjacentBlockIds.get(boundaryKey(previousBlockId, nextBlockId));
-	if (!boundary) return null;
-	const rendered = /* @__PURE__ */ jsx("div", {
-		"aria-hidden": "true",
-		"data-block-boundary": "",
-		"data-boundary-id": boundary.boundaryId,
-		"data-boundary-previous-block-id": boundary.previousBlockId,
-		"data-boundary-next-block-id": boundary.nextBlockId,
-		"data-style-group": boundary.styleGroup,
-		style: boundaryCssVarsStyle(boundary)
-	}, `${input.blockKey}:boundary`);
-	return input.wrapBoundary ? input.wrapBoundary(boundary, rendered) : rendered;
+function prepareEntry(entry, input) {
+	if (entry.kind !== "renderable") return { kind: "plan-decided" };
+	const draftContent = previewableEditorContent(entry);
+	if (draftContent === null) return { kind: "editor-unpreviewable" };
+	try {
+		return buildPreparedContent(entry, draftContent, input);
+	} catch {
+		return { kind: "render-threw" };
+	}
 }
-function boundaryCssVarsStyle(boundary) {
+/**
+* Editor admission validates raw in-flight values without minting a renderable
+* proof. Returns `null` when even relaxed validation rejects the draft.
+*/
+function previewableEditorContent(entry) {
+	if (entry.block.presentationAdmission.kind !== "editor") return entry.renderableContent;
+	const draft = validateManifestDraft(compileManifestContentContract(entry.definition.manifest), entry.renderableContent);
+	return draft.kind === "previewable" ? draft.data : null;
+}
+function buildPreparedContent(entry, content, input) {
+	const { dataContext } = input;
+	const block = entry.block;
+	const routes = input.routeMap ?? dataContext?.routes;
+	const hydratedContent = routes ? hydrateManifestLinks(entry.definition.manifest, content, routes, dataContext?.pagesByIdentifier, dataContext?.entriesByIdentifier) : content;
+	const resolved = resolveBlockData(block.id, entry.definition.dataLoaders, dataContext, routes);
+	const baseProps = buildBlockOverrideProps({
+		content: hydratedContent,
+		data: resolved,
+		block,
+		themeResources: input.themeResources,
+		dataContext,
+		imageResolveContext: input.imageResolveContext
+	});
+	baseProps.bookingTimeZone = dataContext?.bookingTimeZone;
 	return {
-		"--site-style-transition-from": boundary.cssVars.from,
-		"--site-style-transition-to": boundary.cssVars.to
+		kind: "content",
+		baseProps,
+		component: entry.override ? void 0 : getCachedBlockComponent(entry.definition.manifest),
+		hasResolvedData: !!resolved && typeof resolved === "object" && Object.keys(resolved).length > 0,
+		routes
 	};
 }
-function boundaryReserveCssVarsStyle(input) {
-	const before = input.before?.metrics.reserveCss ?? null;
-	const after = input.after?.metrics.reserveCss ?? null;
-	if (!before && !after) return void 0;
+/**
+* The serialisable prop bundle every block component and override receives.
+*
+* Shared by the with-definition and override-without-definition paths, which
+* differ only in the content and resolved data they pass in.
+*/
+function buildBlockOverrideProps(input) {
+	const { block, dataContext } = input;
 	return {
-		...before ? { "--site-style-boundary-before-reserve": before } : {},
-		...after ? { "--site-style-boundary-after-reserve": after } : {}
+		content: input.content,
+		...overrideThemeProps(input.themeResources),
+		data: input.data,
+		...blockSessionProps(dataContext),
+		...blockSubjectProps(dataContext),
+		imageResolveContext: input.imageResolveContext,
+		blockId: block.id ?? null,
+		blockKind: block.kind
 	};
 }
-function transitionCssVarsStyle(content) {
-	const transitionStyles = isObjectRecord(content._transitionStyles) ? content._transitionStyles : null;
-	const cssVars = isObjectRecord(transitionStyles?.cssVars) ? transitionStyles.cssVars : null;
-	const from = typeof cssVars?.from === "string" ? cssVars.from : null;
-	const to = typeof cssVars?.to === "string" ? cssVars.to : null;
-	if (!from && !to) return void 0;
+/** Site, transport and session context a block needs to call back to the API. */
+function blockSessionProps(dataContext) {
 	return {
-		...from ? { "--site-style-transition-from": from } : {},
-		...to ? { "--site-style-transition-to": to } : {}
+		siteId: dataContext?.siteId,
+		apiBaseUrl: dataContext?.apiBaseUrl,
+		supabaseUrl: dataContext?.supabaseUrl,
+		portalToken: dataContext?.portalToken ?? null,
+		previewToken: dataContext?.previewToken ?? null,
+		stage: dataContext?.previewStage
 	};
 }
-function mergeStyleObjects(left, right) {
-	if (!left) return right;
-	if (!right) return left;
+/** What this render is *about* — the entry, occurrence or surface in scope. */
+function blockSubjectProps(dataContext) {
 	return {
-		...left,
-		...right
+		occurrenceContext: dataContext?.occurrenceContext ?? null,
+		entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
+		contentEntry: dataContext?.contentEntry ?? null,
+		pageSurface: dataContext?.pageSurface ?? null,
+		subject: dataContext?.subject ?? null
 	};
 }
-function pageBlockPosition(index, blockCount) {
-	if (blockCount <= 1) return "only";
-	if (index === 0) return "first";
-	if (index === blockCount - 1) return "last";
-	return "middle";
+const blockComponentCache = /* @__PURE__ */ new WeakMap();
+function getCachedBlockComponent(manifest) {
+	const cached = blockComponentCache.get(manifest);
+	if (cached) return cached;
+	const created = makeDefaultBlockComponent({ manifest });
+	blockComponentCache.set(manifest, created);
+	return created;
 }
 //#endregion
+//#region ../blocks/src/BlockErrorBoundary.tsx
+/**
+* Catches a throw from inside a block component's own render.
+*
+* `preparePageRender` guards everything that happens while *building* a block's
+* element; this covers the part React runs afterwards, which no try/catch can
+* reach. Without it one bad block takes the whole page down.
+*
+* Error boundaries have to be classes, and a class in a React Server Component
+* tree is called without `new`, so this file has to be a client module. Which is
+* also why it imports nothing from the rest of the package: the bundler groups
+* modules into chunks by which entries reach them, so importing
+* `pageRenderAudience` or `pageRenderDiagnostics` here would put them in a
+* chunk marked `"use client"` and turn `presentEmptyPage`, `logOmittedBlocks`
+* and friends into client references that the server can no longer call. The
+* fallback node and the log record come in as props instead.
+*
+* See the "Render Audiences" section of the package README for what this does
+* and does not catch on the server.
+*/
+function createBlockErrorBoundary() {
+	if (typeof React$1.Component !== "function") return function ServerBlockErrorBoundary({ children }) {
+		return children;
+	};
+	return class ClientBlockErrorBoundary extends React$1.Component {
+		constructor(props) {
+			super(props);
+			this.state = {
+				failed: false,
+				resetKey: props.resetKey
+			};
+		}
+		static getDerivedStateFromError() {
+			return { failed: true };
+		}
+		static getDerivedStateFromProps(props, state) {
+			if (props.resetKey === state.resetKey) return null;
+			return {
+				failed: false,
+				resetKey: props.resetKey
+			};
+		}
+		componentDidCatch(error) {
+			try {
+				console.error("blocks.pageRenderer.blockRenderThrew", {
+					...this.props.record,
+					message: error instanceof Error ? error.message : String(error)
+				});
+			} catch {}
+		}
+		render() {
+			return this.state.failed ? this.props.fallback : this.props.children;
+		}
+	};
+}
+const BlockErrorBoundary = createBlockErrorBoundary();
+//#endregion
 //#region ../blocks/src/pageRenderAdmission.ts
 function toEditorPresentationPage(page) {
 	if (!page) return null;
@@ -590,99 +1147,248 @@ function EditorPageRenderer(props) {
 	const page = React$1.useMemo(() => toEditorPresentationPage(props.page), [props.page]);
 	return /* @__PURE__ */ jsx(PageRendererCore, {
 		...props,
-		page
+		page,
+		audience: "authoring"
 	});
 }
 function PageRendererCore(props) {
-	const { page, runtimeBoundaries, dataContext, wrapBlock, wrapBoundary, registry } = props;
+	const { page, audience, runtimeBoundaries, dataContext, routeMap, registry, sdkConfig, customBlocks, blockOverrides } = props;
 	const imageResolveContext = React$1.useMemo(() => resolvePageRendererImageResolveContext(dataContext), [
 		dataContext?.imageResolveContext,
 		dataContext?.mediaAssets,
 		dataContext?.siteId,
 		dataContext?.supabaseUrl
 	]);
-	const boundaryByAdjacentBlockIds = React$1.useMemo(() => boundaryMapForAdjacentBlockIds(runtimeBoundaries ?? []), [runtimeBoundaries]);
-	const usesRuntimeBoundaries = runtimeBoundaries !== void 0;
+	const previewStage = dataContext?.previewStage ?? "published";
+	const plan = React$1.useMemo(() => buildPageRenderPlan({
+		page: page ?? {
+			name: "",
+			path: "",
+			purpose: "",
+			blocks: []
+		},
+		audience,
+		runtimeBoundaries,
+		previewStage,
+		sdkConfig,
+		customBlocks,
+		blockOverrides
+	}), [
+		page,
+		audience,
+		runtimeBoundaries,
+		previewStage,
+		sdkConfig,
+		customBlocks,
+		blockOverrides
+	]);
 	const themeResources = React$1.useMemo(() => resolvePageThemeResources(props), [
 		props.rendering,
 		props.theme,
 		props.themeTokens
 	]);
-	if (!page || page.blocks.length === 0) return /* @__PURE__ */ jsx("div", {
-		className: "rb-p-6 rb-caption",
-		style: textColorStyle("mutedText"),
-		children: "No blocks found."
+	const preparation = React$1.useMemo(() => preparePageRender({
+		plan,
+		audience,
+		dataContext,
+		routeMap,
+		themeResources,
+		imageResolveContext,
+		previewStage
+	}), [
+		plan,
+		audience,
+		dataContext,
+		routeMap,
+		themeResources,
+		imageResolveContext,
+		previewStage
+	]);
+	const boundaryByAdjacentBlockIds = React$1.useMemo(() => boundaryMapForAdjacentBlockIds(preparation.runtimeBoundaries ?? []), [preparation.runtimeBoundaries]);
+	const usesRuntimeBoundaries = preparation.runtimeBoundaries !== void 0;
+	reportAndReplayOmissions({
+		plan,
+		preparation,
+		dataContext,
+		themeResources
 	});
+	if (!page || preparation.entries.length === 0) return presentEmptyPage(audience);
 	const resolvedRegistry = registry ?? getDefaultComponentRegistry();
 	setContextResolveImageUrlContext(imageResolveContext);
-	return /* @__PURE__ */ jsx("div", { children: page.blocks.map((block, index) => {
-		const blockPosition = pageBlockPosition(index, page.blocks.length);
-		const blockKey = block.id ?? `${block.kind}-${index}`;
-		const previousBlock = page.blocks[index - 1] ?? null;
-		const nextBlock = page.blocks[index + 1] ?? null;
-		const boundaryBefore = boundaryBetweenBlocks(previousBlock, block, boundaryByAdjacentBlockIds);
-		const boundaryAfter = boundaryBetweenBlocks(block, nextBlock, boundaryByAdjacentBlockIds);
-		const boundaryElement = renderBoundaryAfterBlock({
-			block,
-			nextBlock,
-			blockKey,
-			boundaryByAdjacentBlockIds,
-			wrapBoundary
-		});
-		const cleanKind = block.kind.replace(/^block\./, "");
-		const definition = getBlockDefinition(block.kind);
-		const managesOwnWrapper = definition?.manifest.behaviours?.managesOwnWrapper;
-		const renderableContent = getRenderableContent(block, dataContext?.previewStage);
-		const variantKey = definition?.manifest ? resolveVariantKey(definition.manifest, renderableContent) : null;
-		const shouldUseWrapper = !managesOwnWrapper || Boolean(wrapBlock);
-		const blockSectionProps = buildBlockSectionProps({
-			props,
-			themeResources,
-			block,
-			blockKey,
-			imageResolveContext,
-			registry: resolvedRegistry
-		});
-		if (!shouldUseWrapper) {
-			const rendered = /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps }, `${blockKey}:block`);
-			return boundaryElement ? /* @__PURE__ */ jsxs(React$1.Fragment, { children: [rendered, boundaryElement] }, blockKey) : rendered;
-		}
-		const wrapperClassName = [`block-${cleanKind}`, wrapBlock ? "group relative" : null].filter(Boolean).join(" ");
-		const styleGroup = typeof renderableContent.styleGroup === "string" ? renderableContent.styleGroup : void 0;
-		const blockLook = typeof renderableContent.blockLook === "string" ? renderableContent.blockLook : void 0;
-		const blockComposition = readBlockComposition(renderableContent.blockComposition);
-		const transitionStyle = transitionCssVarsStyle(renderableContent);
-		const blockStyle = mergeStyleObjects(transitionStyle, boundaryReserveCssVarsStyle({
-			before: boundaryBefore,
-			after: boundaryAfter
-		}));
-		const blockElement = /* @__PURE__ */ jsx("div", {
-			className: wrapperClassName,
-			"data-block": cleanKind,
-			"data-block-id": block.id ?? void 0,
-			"data-block-kind": block.kind,
-			"data-variant": variantKey ?? void 0,
-			"data-block-variant": variantKey ?? void 0,
-			"data-block-look": blockLook,
-			"data-block-composition": blockComposition?.treatment,
-			"data-block-composition-kind": blockComposition?.kind,
-			"data-page-block-position": blockPosition,
-			"data-site-style-boundary-before": boundaryBefore?.metrics.size,
-			"data-site-style-boundary-after": boundaryAfter?.metrics.size,
-			"data-style-group": styleGroup,
-			style: blockStyle,
-			children: /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps })
-		}, blockKey);
-		if (boundaryElement) return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [blockElement, boundaryElement] }, blockKey);
-		if (usesRuntimeBoundaries || !isSiteStyleTransitionStyleGroup(styleGroup)) return blockElement;
-		return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [blockElement, /* @__PURE__ */ jsx("div", {
-			"aria-hidden": "true",
-			"data-block-transition": "",
-			"data-block-transition-for": block.id ?? blockKey,
-			"data-style-group": styleGroup,
-			style: transitionStyle
-		})] }, blockKey);
-	}) });
+	return /* @__PURE__ */ jsx("div", { children: preparation.entries.map((entry, index) => renderGuardedPlanEntry({
+		entry,
+		index,
+		entries: preparation.entries,
+		props,
+		themeResources,
+		imageResolveContext,
+		resolvedRegistry,
+		boundaryByAdjacentBlockIds,
+		usesRuntimeBoundaries,
+		wrapBlock: props.wrapBlock,
+		wrapBoundary: props.wrapBoundary
+	})) });
+}
+/**
+* The render pass's effects, kept out of both memos and run in the order the
+* renderer has always run them in.
+*
+* Logging comes first because the replay below can throw: in overrides-only
+* mode a missing-definition omission would otherwise abort the render before
+* the deploy-skew signal was ever emitted — the configuration where it is most
+* diagnostic. Logging is side-effect-free and cannot fail the render.
+*/
+function reportAndReplayOmissions(input) {
+	const { plan, dataContext } = input;
+	logOmittedBlocks(plan, dataContext);
+	for (const failed of input.preparation.constructionFailures) logRenderThrew(failed.block, dataContext);
+	for (const omission of plan.omitted) switch (omission.reason.kind) {
+		case "invalid-admission": break;
+		case "missing-definition":
+		case "missing-layout":
+			requireBlockOverride(input.themeResources, omission.override, omission.blockKind);
+			break;
+	}
+	for (const failed of input.preparation.constructionFailures) requireEntryBlockOverride(failed, input.themeResources);
+}
+const blockKeyFor = (block, index) => block.id ?? `${block.kind}-${index}`;
+const entryResetTokens = /* @__PURE__ */ new WeakMap();
+let nextEntryResetToken = 0;
+/**
+* A serialisable stand-in for the identity of the block an entry renders.
+*
+* The error boundary is a client component, so anything crossing into it has to
+* survive RSC serialisation — and a prepared entry carries the block definition
+* and override components. A number minted once per block object says the same
+* thing: it changes exactly when the block's content does, which is when a
+* boundary should forget that this block failed.
+*
+* Keyed on the block rather than the prepared entry on purpose. `toPresentationPage`
+* memoises blocks on `props.page`, while a prepared entry is a fresh object every
+* time preparation recomputes — any `dataContext`, `routeMap` or `themeResources`
+* identity change — so keying on the entry would reset a failed boundary on renders
+* where nothing about the block changed, and it would retry and re-log each time.
+*/
+function entryResetToken(entry) {
+	const block = entry.entry.block;
+	const existing = entryResetTokens.get(block);
+	if (existing !== void 0) return existing;
+	const token = ++nextEntryResetToken;
+	entryResetTokens.set(block, token);
+	return token;
+}
+/**
+* Wraps one entry — wrapper, block and boundary sibling alike — in the per-block
+* error boundary, so a throw from inside the block's own render takes only that
+* block out of the page rather than the page itself.
+*/
+function renderGuardedPlanEntry(input) {
+	const block = input.entry.entry.block;
+	const dataContext = input.props.dataContext;
+	requireEntryBlockOverride(input.entry.entry, input.themeResources);
+	return /* @__PURE__ */ jsx(BlockErrorBoundary, {
+		fallback: presentNotRenderableBlock({
+			kind: "render-threw",
+			blockKind: block.kind
+		}, input.props.audience),
+		record: {
+			siteId: dataContext?.siteId ?? null,
+			pageId: dataContext?.pageId ?? null,
+			blockId: block.id ?? null,
+			blockKind: block.kind
+		},
+		resetKey: entryResetToken(input.entry),
+		children: renderPlanEntry(input)
+	}, blockKeyFor(block, input.index));
+}
+/**
+* The overrides-only guard, run in the order the renderer has always run it:
+* after an admission failure has already returned, before anything else.
+*/
+function requireEntryBlockOverride(entry, themeResources) {
+	if (entry.kind === "diagnostic") {
+		if (entry.reason.kind === "invalid-admission") return;
+		requireBlockOverride(themeResources, void 0, entry.block.kind);
+		return;
+	}
+	requireBlockOverride(themeResources, entry.override, entry.block.kind);
+}
+/**
+* Renders one planned block: its wrapper, style-group data attributes,
+* boundary reserve space and any boundary or transition sibling that follows.
+*
+* Extracted from PageRendererCore so the component stays about wiring the plan
+* rather than also owning per-block markup.
+*/
+function renderPlanEntry(input) {
+	const { index, entries, props, themeResources, imageResolveContext, resolvedRegistry, boundaryByAdjacentBlockIds, usesRuntimeBoundaries, wrapBlock, wrapBoundary } = input;
+	const entry = input.entry.entry;
+	const block = entry.block;
+	const blockPosition = pageBlockPosition(index, entries.length);
+	const blockKey = blockKeyFor(block, index);
+	const previousBlock = entries[index - 1]?.entry.block ?? null;
+	const nextBlock = entries[index + 1]?.entry.block ?? null;
+	const boundaryBefore = boundaryBetweenBlocks(previousBlock, block, boundaryByAdjacentBlockIds);
+	const boundaryAfter = boundaryBetweenBlocks(block, nextBlock, boundaryByAdjacentBlockIds);
+	const boundaryElement = renderBoundaryAfterBlock({
+		block,
+		nextBlock,
+		blockKey,
+		boundaryByAdjacentBlockIds,
+		wrapBoundary
+	});
+	const cleanKind = block.kind.replace(/^block\./, "");
+	const managesOwnWrapper = entry.kind === "renderable" && entry.managesOwnWrapper;
+	const renderableContent = entry.renderableContent;
+	const variantKey = entry.kind === "renderable" ? entry.variantKey : null;
+	const shouldUseWrapper = !managesOwnWrapper || Boolean(wrapBlock);
+	const blockSectionProps = buildBlockSectionProps({
+		props,
+		themeResources,
+		entry: input.entry,
+		blockKey,
+		imageResolveContext,
+		registry: resolvedRegistry
+	});
+	if (!shouldUseWrapper) {
+		const rendered = /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps }, `${blockKey}:block`);
+		return boundaryElement ? /* @__PURE__ */ jsxs(React$1.Fragment, { children: [rendered, boundaryElement] }, blockKey) : rendered;
+	}
+	const wrapperClassName = [`block-${cleanKind}`, wrapBlock ? "group relative" : null].filter(Boolean).join(" ");
+	const styleGroup = typeof renderableContent.styleGroup === "string" ? renderableContent.styleGroup : void 0;
+	const blockLook = typeof renderableContent.blockLook === "string" ? renderableContent.blockLook : void 0;
+	const blockComposition = readBlockComposition(renderableContent.blockComposition);
+	const transitionStyle = transitionCssVarsStyle(renderableContent);
+	const blockStyle = mergeStyleObjects(transitionStyle, boundaryReserveCssVarsStyle({
+		before: boundaryBefore,
+		after: boundaryAfter
+	}));
+	const blockElement = /* @__PURE__ */ jsx("div", {
+		className: wrapperClassName,
+		"data-block": cleanKind,
+		"data-block-id": block.id ?? void 0,
+		"data-block-kind": block.kind,
+		"data-variant": variantKey ?? void 0,
+		"data-block-variant": variantKey ?? void 0,
+		"data-block-look": blockLook,
+		"data-block-composition": blockComposition?.treatment,
+		"data-block-composition-kind": blockComposition?.kind,
+		"data-page-block-position": blockPosition,
+		"data-site-style-boundary-before": boundaryBefore?.metrics.size,
+		"data-site-style-boundary-after": boundaryAfter?.metrics.size,
+		"data-style-group": styleGroup,
+		style: blockStyle,
+		children: /* @__PURE__ */ jsx(MemoBlockSection, { ...blockSectionProps })
+	}, blockKey);
+	if (boundaryElement) return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [blockElement, boundaryElement] }, blockKey);
+	if (usesRuntimeBoundaries || !isSiteStyleTransitionStyleGroup(styleGroup)) return blockElement;
+	return /* @__PURE__ */ jsxs(React$1.Fragment, { children: [blockElement, /* @__PURE__ */ jsx("div", {
+		"aria-hidden": "true",
+		"data-block-transition": "",
+		"data-block-transition-for": block.id ?? blockKey,
+		"data-style-group": styleGroup,
+		style: transitionStyle
+	})] }, blockKey);
 }
 function resolvePageRendererImageResolveContext(dataContext) {
 	const input = dataContext?.imageResolveContext;
@@ -693,34 +1399,20 @@ function resolvePageRendererImageResolveContext(dataContext) {
 		mediaAssets: input?.mediaAssets ?? dataContext?.mediaAssets
 	});
 }
-const resolveBookingTimeZone = (dataContext) => dataContext?.bookingTimeZone;
 function buildBlockSectionProps(input) {
 	return {
 		themeResources: input.themeResources,
-		block: input.block,
+		entry: input.entry,
+		audience: input.props.audience,
 		dataContext: input.props.dataContext,
 		blockKey: input.blockKey,
 		registry: input.registry,
 		routeMap: input.props.routeMap,
 		wrapBlock: input.props.wrapBlock,
-		blockOverrides: input.props.blockOverrides,
-		sdkConfig: input.props.sdkConfig,
-		customBlocks: input.props.customBlocks,
 		imageResolveContext: input.imageResolveContext,
 		previewAuthoring: input.props.previewAuthoring
 	};
 }
-/**
-* Look up a block override component by block kind.
-* Supports both full ("block.hero") and short ("hero") keys.
-*/
-function getBlockOverride(blockKind, overrides) {
-	if (!overrides) return void 0;
-	if (overrides[blockKind]) return overrides[blockKind];
-	const shortKind = blockKind.replace(/^block\./, "");
-	if (overrides[shortKind]) return overrides[shortKind];
-}
-const blockComponentCache = /* @__PURE__ */ new WeakMap();
 const DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS = 25;
 let cachedPerfSlowBlockRenderThresholdMs = null;
 function getPerfSlowBlockRenderThresholdMs() {
@@ -730,12 +1422,53 @@ function getPerfSlowBlockRenderThresholdMs() {
 	cachedPerfSlowBlockRenderThresholdMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PERF_SLOW_BLOCK_RENDER_THRESHOLD_MS;
 	return cachedPerfSlowBlockRenderThresholdMs;
 }
-function getCachedBlockComponent(manifest) {
-	const cached = blockComponentCache.get(manifest);
-	if (cached) return cached;
-	const created = makeDefaultBlockComponent({ manifest });
-	blockComponentCache.set(manifest, created);
-	return created;
+/** Site, stage and transport identity every block view model is resolved against. */
+function blockRootRuntime(dataContext) {
+	return {
+		siteId: dataContext?.siteId ?? null,
+		pageId: dataContext?.pageId ?? null,
+		previewStage: dataContext?.previewStage ?? "published",
+		apiBaseUrl: dataContext?.apiBaseUrl ?? null,
+		portalToken: dataContext?.portalToken ?? null,
+		bookingOfferingPresets: dataContext?.bookingOfferingPresets ?? [],
+		eventRegistrationOverlayEnabled: dataContext?.eventRegistrationOverlayEnabled ?? false
+	};
+}
+/**
+* Route and identifier maps for CTA link resolution at render time. Omitted
+* rather than nulled when absent, because a binding checks for the key.
+*/
+function blockRootLookups(dataContext, routes) {
+	return {
+		...routes ? { routes } : {},
+		...dataContext?.pagesByIdentifier ? { pagesByIdentifier: dataContext.pagesByIdentifier } : {},
+		...dataContext?.entriesByIdentifier ? { entriesByIdentifier: dataContext.entriesByIdentifier } : {}
+	};
+}
+/**
+* The internal-block path: everything a system block component needs and an
+* override deliberately does not receive.
+*/
+function renderSystemBlockElement(input) {
+	const { prepared, block, dataContext } = input;
+	const BlockComponent = prepared.component;
+	if (!BlockComponent) return null;
+	const rootContext = { $root: {
+		...blockRootRuntime(dataContext),
+		...blockRootLookups(dataContext, prepared.routes),
+		...blockSubjectProps(dataContext)
+	} };
+	return /* @__PURE__ */ jsx(BlockComponent, {
+		...prepared.baseProps,
+		registry: input.registry,
+		pathBase: typeof block.id === "string" && block.id.length > 0 ? `blocks.${block.id}.` : void 0,
+		blockBindings: block.bindings,
+		editableRouteMetadataFieldIds: dataContext?.editableRouteMetadataFieldIds ?? void 0,
+		viewModelOverrides: rootContext,
+		fragmentRegistry: getFragmentRegistry(),
+		imageResolveContext: input.imageResolveContext,
+		previewAuthoring: input.previewAuthoring
+	});
 }
 /**
 * Memoized block section component.
@@ -744,7 +1477,10 @@ function getCachedBlockComponent(manifest) {
 * referential equality of all props that affect rendering. Standard React.memo
 * wouldn't catch all the render triggers from the editor store.
 */
-const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources, block, dataContext, registry, routeMap, wrapBlock, blockOverrides, sdkConfig, customBlocks, imageResolveContext, previewAuthoring }) {
+const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources, entry: preparedEntry, audience, dataContext, registry, wrapBlock, imageResolveContext, previewAuthoring }) {
+	const entry = preparedEntry.entry;
+	const prepared = preparedEntry.prepared;
+	const block = entry.block;
 	const perfStart = globalThis.process?.env?.DEBUG_PERF === "1" && typeof window === "undefined" ? Date.now() : 0;
 	const fallbackImageResolveContext = getCurrentResolveImageUrlContext();
 	const resolvedImageResolveContext = imageResolveContext ?? fallbackImageResolveContext;
@@ -759,210 +1495,75 @@ const MemoBlockSection = React$1.memo(function MemoBlockSection({ themeResources
 				durationMs,
 				outcome: meta?.outcome ?? "ok",
 				override: meta?.override ?? false,
-				hasResolvedData: meta?.hasResolvedData ?? false
-			});
-		} catch {}
-		return node;
-	}
-	if (block.presentationAdmission.kind === "invalid") {
-		try {
-			if (globalThis.process?.env?.NODE_ENV !== "production") console.warn("[blocks:PageRenderer] block admission failed", {
-				blockId: block.id ?? null,
-				blockKind: block.kind,
-				error: block.presentationAdmission.error
-			});
-		} catch {}
-		return finish(fallback(`Invalid content for block kind "${block.kind}".`), {
-			outcome: "invalidContent",
-			override: false
-		});
-	}
-	const OverrideComponent = getBlockOverride(block.kind, blockOverrides);
-	requireBlockOverride(themeResources, OverrideComponent, block.kind);
-	let definition = getBlockDefinition(block.kind);
-	if (!definition && block.kind.startsWith("custom.")) definition = createCustomBlockRegistry({
-		sdkConfig,
-		customBlocks: (customBlocks ?? []).map((manifest) => ({
-			manifest,
-			source: { kind: "managed-database" }
-		}))
-	}).findManifest(block.kind)?.descriptor.definition;
-	if (!definition) {
-		if (OverrideComponent) {
-			const rendered = /* @__PURE__ */ jsx(OverrideComponent, {
-				content: getRenderableContent(block, dataContext?.previewStage),
-				...overrideThemeProps(themeResources),
-				data: void 0,
-				siteId: dataContext?.siteId,
-				apiBaseUrl: dataContext?.apiBaseUrl,
-				portalToken: dataContext?.portalToken ?? null,
-				previewToken: dataContext?.previewToken ?? null,
-				stage: dataContext?.previewStage,
-				occurrenceContext: dataContext?.occurrenceContext ?? null,
-				entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
-				contentEntry: dataContext?.contentEntry ?? null,
-				pageSurface: dataContext?.pageSurface ?? null,
-				subject: dataContext?.subject ?? null,
-				supabaseUrl: dataContext?.supabaseUrl,
-				imageResolveContext: resolvedImageResolveContext,
-				blockId: block.id ?? null,
-				blockKind: block.kind
-			});
-			return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-				outcome: "overrideWithoutDefinition",
-				override: true,
-				hasResolvedData: false
-			});
-		}
-		if (block.kind.startsWith("custom.") && shouldDebugCustomBlocks()) try {
-			console.warn("[blocks:PageRenderer] custom block definition missing", {
-				blockId: block.id ?? null,
-				blockKind: block.kind,
-				hasOverride: Boolean(OverrideComponent),
-				sdkCustomBlocksCount: sdkConfig?.customBlocks?.length ?? 0,
-				dbCustomBlocksCount: customBlocks?.length ?? 0
-			});
-		} catch {}
-		const rendered = fallback(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". The custom block definition was not found (missing manifest).` : `No renderer available for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-			outcome: "missingDefinition",
-			override: false
-		});
-	}
-	const manifestHasLayout = Boolean(definition.manifest.layout) || definition.manifest.variants && Object.keys(definition.manifest.variants).length > 0;
-	if (!OverrideComponent && !manifestHasLayout) {
-		if (block.kind.startsWith("custom.") && shouldDebugCustomBlocks()) try {
-			console.warn("[blocks:PageRenderer] custom block has no layout/variants and no override", {
-				blockId: block.id ?? null,
-				blockKind: block.kind,
-				hasOverride: false,
-				manifestKeys: Object.keys(definition.manifest ?? {}).sort()
+				hasResolvedData: meta?.hasResolvedData ?? false
 			});
 		} catch {}
-		const rendered = fallback(block.kind.startsWith("custom.") ? `No renderer available for block kind "${block.kind}". This custom block has no layout/variants, so it must be rendered via blockOverrides["${block.kind}"].` : `No renderer available for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-			outcome: "missingLayout",
-			override: false
-		});
+		return node;
 	}
-	const content = getRenderableContent(block, dataContext?.previewStage);
-	let data = content;
-	if (block.presentationAdmission.kind === "editor") {
-		const draft = validateManifestDraft(compileManifestContentContract(definition.manifest), content);
-		if (draft.kind === "previewable") data = draft.data;
-		else {
-			const rendered = fallback(`Unable to render block kind "${block.kind}".`);
-			return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-				outcome: "invalidPlaceholder",
-				override: false
-			});
-		}
+	function wrapped(node) {
+		return wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, node) }) : /* @__PURE__ */ jsx(Fragment$1, { children: node });
 	}
-	try {
-		const routes = routeMap ?? dataContext?.routes;
-		const hydratedContent = routes ? hydrateManifestLinks(definition.manifest, data, routes, dataContext?.pagesByIdentifier, dataContext?.entriesByIdentifier) : data;
-		const resolved = resolveBlockData(block.id, definition.dataLoaders, dataContext, routes);
-		const hasResolvedData = !!resolved && typeof resolved === "object" && Object.keys(resolved).length > 0;
-		const baseProps = {
-			content: hydratedContent,
-			...overrideThemeProps(themeResources),
-			data: resolved,
-			siteId: dataContext?.siteId,
-			apiBaseUrl: dataContext?.apiBaseUrl,
-			portalToken: dataContext?.portalToken ?? null,
-			previewToken: dataContext?.previewToken ?? null,
-			stage: dataContext?.previewStage,
-			occurrenceContext: dataContext?.occurrenceContext ?? null,
-			entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
-			contentEntry: dataContext?.contentEntry ?? null,
-			pageSurface: dataContext?.pageSurface ?? null,
-			subject: dataContext?.subject ?? null,
-			supabaseUrl: dataContext?.supabaseUrl,
-			imageResolveContext: resolvedImageResolveContext,
-			blockId: block.id ?? null,
-			blockKind: block.kind
-		};
-		baseProps.bookingTimeZone = resolveBookingTimeZone(dataContext);
-		let rendered;
-		if (OverrideComponent) rendered = /* @__PURE__ */ jsx(OverrideComponent, { ...baseProps });
-		else {
-			requireThemeResources(themeResources, block.kind);
-			const BlockComponent = getCachedBlockComponent(definition.manifest);
-			const pathBase = typeof block.id === "string" && block.id.length > 0 ? `blocks.${block.id}.` : void 0;
-			const rootContext = { $root: {
-				siteId: dataContext?.siteId ?? null,
-				pageId: dataContext?.pageId ?? null,
-				previewStage: dataContext?.previewStage ?? "published",
-				apiBaseUrl: dataContext?.apiBaseUrl ?? null,
-				portalToken: dataContext?.portalToken ?? null,
-				bookingOfferingPresets: dataContext?.bookingOfferingPresets ?? [],
-				eventRegistrationOverlayEnabled: dataContext?.eventRegistrationOverlayEnabled ?? false,
-				...routes ? { routes } : {},
-				...dataContext?.pagesByIdentifier ? { pagesByIdentifier: dataContext.pagesByIdentifier } : {},
-				...dataContext?.entriesByIdentifier ? { entriesByIdentifier: dataContext.entriesByIdentifier } : {},
-				occurrenceContext: dataContext?.occurrenceContext ?? null,
-				entrySubrouteContext: dataContext?.entrySubrouteContext ?? null,
-				contentEntry: dataContext?.contentEntry ?? null,
-				pageSurface: dataContext?.pageSurface ?? null,
-				subject: dataContext?.subject ?? null
-			} };
-			const blockBindings = block.bindings;
-			const fragmentRegistry = getFragmentRegistry();
-			rendered = /* @__PURE__ */ jsx(BlockComponent, {
-				...baseProps,
-				registry,
-				pathBase,
-				blockBindings,
-				editableRouteMetadataFieldIds: dataContext?.editableRouteMetadataFieldIds ?? void 0,
-				viewModelOverrides: rootContext,
-				fragmentRegistry,
-				imageResolveContext: resolvedImageResolveContext,
-				previewAuthoring
-			});
-		}
-		if (wrapBlock && block.id) return finish(/* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }), {
-			override: Boolean(OverrideComponent),
-			hasResolvedData
+	if (entry.kind === "diagnostic" && entry.reason.kind === "invalid-admission") return finish(presentNotRenderableBlock(entry.reason, audience), {
+		outcome: "invalidContent",
+		override: false
+	});
+	const OverrideComponent = entry.kind === "diagnostic" ? void 0 : entry.override;
+	if (entry.kind === "diagnostic") {
+		debugCustomBlockDiagnostic(entry.reason, block, entry.debug);
+		return finish(presentNotRenderableBlock(entry.reason, audience), {
+			outcome: entry.reason.kind === "missing-definition" ? "missingDefinition" : "missingLayout",
+			override: false
 		});
-		return finish(/* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-			override: Boolean(OverrideComponent),
-			hasResolvedData
+	}
+	if (entry.kind === "override-only") {
+		const OverrideOnlyComponent = entry.override;
+		return finish(wrapped(/* @__PURE__ */ jsx(OverrideOnlyComponent, { ...buildBlockOverrideProps({
+			content: entry.renderableContent,
+			data: void 0,
+			block,
+			themeResources,
+			dataContext,
+			imageResolveContext: resolvedImageResolveContext
+		}) })), {
+			outcome: "overrideWithoutDefinition",
+			override: true,
+			hasResolvedData: false
 		});
-	} catch {
-		const rendered = block.presentationAdmission.kind === "editor" ? fallback(`Unable to render block kind "${block.kind}".`) : fallback(`Invalid content for block kind "${block.kind}".`);
-		return finish(wrapBlock && block.id ? /* @__PURE__ */ jsx(Fragment$1, { children: wrapBlock(block.id, rendered) }) : /* @__PURE__ */ jsx(Fragment$1, { children: rendered }), {
-			outcome: "exception",
-			override: false
+	}
+	if (prepared.kind === "editor-unpreviewable") return finish(wrapped(presentNotRenderableBlock({
+		kind: "editor-unpreviewable",
+		blockKind: block.kind
+	}, audience)), {
+		outcome: "invalidPlaceholder",
+		override: false
+	});
+	if (prepared.kind !== "content") return finish(wrapped(presentNotRenderableBlock({
+		kind: "render-threw",
+		blockKind: block.kind
+	}, audience)), {
+		outcome: "exception",
+		override: false
+	});
+	let rendered;
+	if (OverrideComponent) rendered = /* @__PURE__ */ jsx(OverrideComponent, { ...prepared.baseProps });
+	else {
+		requireThemeResources(themeResources, block.kind);
+		rendered = renderSystemBlockElement({
+			prepared,
+			block,
+			dataContext,
+			registry,
+			previewAuthoring,
+			imageResolveContext: resolvedImageResolveContext
 		});
 	}
+	return finish(wrapped(rendered), {
+		override: Boolean(OverrideComponent),
+		hasResolvedData: prepared.hasResolvedData
+	});
 }, (prev, next) => {
-	return prev.block === next.block && prev.registry === next.registry && prev.dataContext === next.dataContext && prev.themeResources === next.themeResources && prev.routeMap === next.routeMap && prev.block.presentationAdmission === next.block.presentationAdmission && prev.wrapBlock === next.wrapBlock && prev.blockOverrides === next.blockOverrides && prev.sdkConfig === next.sdkConfig && prev.customBlocks === next.customBlocks && prev.imageResolveContext === next.imageResolveContext && prev.previewAuthoring === next.previewAuthoring;
+	return prev.entry === next.entry && prev.audience === next.audience && prev.registry === next.registry && prev.dataContext === next.dataContext && prev.themeResources === next.themeResources && prev.routeMap === next.routeMap && prev.wrapBlock === next.wrapBlock && prev.imageResolveContext === next.imageResolveContext && prev.previewAuthoring === next.previewAuthoring;
 });
-function fallback(message) {
-	return /* @__PURE__ */ jsx("div", {
-		className: "rb-p-6 rb-caption",
-		style: textColorStyle("mutedText"),
-		children: message
-	});
-}
-function shouldDebugCustomBlocks() {
-	try {
-		return globalThis.process?.env?.DEBUG_CUSTOM_BLOCKS === "1";
-	} catch {
-		return false;
-	}
-}
-/**
-* Resolves block content based on stage priority.
-* For draft/preview: draftContent takes priority over content.
-* For published: content is the source of truth.
-* Returns empty object if no content exists (validator will handle placeholders if needed).
-*/
-function getRenderableContent(block, previewStage = "published") {
-	const source = previewStage === "preview" && block.draftContent ? block.draftContent : block.content ?? {};
-	if (!isObjectRecord(source)) return {};
-	return source;
-}
 //#endregion
 //#region ../theme-core/src/fonts/types.ts
 /**
@@ -1710,7 +2311,7 @@ function normalizeLoaderParams(endpoint, params, context) {
 		ensureSiteId(out, context);
 		return out;
 	}
-	if (endpoint === "listPublicEvents" || endpoint === "listPublicRecurringSchedule") {
+	if (endpoint === "listPublicEvents" || endpoint === "listPublicRecurringSchedule" || endpoint === "listPublicEventCalendarWindow") {
 		ensureSiteId(out, context);
 		return out;
 	}
@@ -1756,6 +2357,297 @@ function normalizePublicApiLoaderParams(endpoint, params, context) {
 const Text = Text$1;
 const RichText = RichText$1;
 //#endregion
+//#region ../db/src/schemas/forms.ts
+/**
+* Form Settings Schemas
+*
+* Zod schemas for validating form settings JSON stored in the database.
+* These schemas are the single source of truth for form settings validation
+* across API routes, type guards, and client-side form submission.
+*/
+const sensitiveCollectionModeSchema = z.enum(["standard", "sensitive"]).default("standard");
+const sensitiveCollectionConfirmationVersionSchema = z.union([z.literal(1), z.null()]);
+const formPresentationSettingsShape = {
+	submitLabel: z.string().min(1).max(40).nullable().optional(),
+	templateKey: z.string().min(1).nullable().optional()
+};
+const formPresentationSettingsSchema = z.object(formPresentationSettingsShape).strict();
+const sensitiveCollectionConfigSchema = z.object({
+	enabledAt: z.string().datetime().nullable(),
+	enabledByUserId: z.string().uuid().nullable(),
+	confirmationVersion: sensitiveCollectionConfirmationVersionSchema
+}).strict();
+/**
+* Email notification settings for contact forms
+*/
+const emailNotificationSchema = z.object({
+	enabled: z.boolean(),
+	recipients: z.array(z.string().email()).optional()
+}).strict();
+/**
+* Submitter auto-reply settings for contact forms.
+*
+* Intentionally does not include form field values; overrides are purely template strings.
+*/
+const submitterAutoReplySchema = z.object({
+	enabled: z.boolean(),
+	override: z.object({
+		subjectTemplate: z.string().max(200),
+		bodyTemplate: z.string().max(1e4)
+	}).strict().optional()
+}).strict();
+/**
+* Webhook notification settings for forms
+*/
+const webhookNotificationSchema = z.object({
+	enabled: z.boolean(),
+	url: z.string().url().optional(),
+	headers: z.record(z.string(), z.string()).optional()
+}).strict();
+/**
+* Notification settings structure
+*/
+const notificationSettingsSchema = z.object({
+	email: emailNotificationSchema.optional(),
+	autoReply: submitterAutoReplySchema.optional(),
+	webhook: webhookNotificationSchema.optional(),
+	emails: z.array(z.string().email()).optional()
+}).strict().optional();
+const standardContactOptionalFieldSettingsSchema = z.object({ visible: z.boolean() }).strict();
+const contactFormDefinitionSettingsSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("custom-contact") }).strict(), z.object({
+	kind: z.literal("standard-contact"),
+	optionalFields: z.object({
+		name: standardContactOptionalFieldSettingsSchema,
+		phone: standardContactOptionalFieldSettingsSchema
+	}).strict()
+}).strict()]);
+/**
+* Contact form settings
+* Used for general inquiry forms that send notifications to site owners
+*/
+const contactFormSettingsSchema = z.object({
+	type: z.literal("contact"),
+	successMessage: z.string().optional(),
+	sensitiveCollectionMode: sensitiveCollectionModeSchema.optional(),
+	sensitiveCollection: sensitiveCollectionConfigSchema.optional(),
+	notifications: notificationSettingsSchema,
+	definition: contactFormDefinitionSettingsSchema.default({ kind: "custom-contact" })
+}).strict();
+/**
+* Booking form settings
+* Used for appointment booking forms that create appointments in the system
+*
+* Service configuration:
+* - serviceId: Single service (backward compatible)
+* - serviceIds: Multiple services (user selects at booking time)
+* - If neither provided: Shows all available services for the site
+*
+* Note: Form can have either serviceId OR serviceIds, not both.
+* XOR validation enforces this constraint.
+*/
+const bookingFormSettingsSchema = z.object({
+	type: z.literal("booking"),
+	serviceId: z.string().optional(),
+	serviceIds: z.array(z.string()).optional(),
+	resourceId: z.string().nullable().optional(),
+	requiresApproval: z.boolean().default(false),
+	successMessage: z.string().optional(),
+	sensitiveCollectionMode: sensitiveCollectionModeSchema.optional(),
+	sensitiveCollection: sensitiveCollectionConfigSchema.optional()
+}).strict().refine((data) => {
+	const hasSingle = data.serviceId !== void 0 && data.serviceId.length > 0;
+	const hasMultiple = data.serviceIds !== void 0 && data.serviceIds.length > 0;
+	return !(hasSingle && hasMultiple);
+}, { message: "Form cannot have both serviceId and serviceIds. Use one or the other." });
+/**
+* Event registration form settings
+* Used for event registration forms that create event attendees
+*
+* Series configuration:
+* - seriesId: Single event series (form is for specific event)
+* - If not provided: Block must specify series or get from context
+*/
+const eventRegistrationFormSettingsSchema = z.object({
+	type: z.literal("event-registration"),
+	seriesId: z.string().uuid().optional(),
+	maxTickets: z.number().int().positive().max(10).default(10),
+	requiresApproval: z.boolean().default(false),
+	successMessage: z.string().optional(),
+	sensitiveCollectionMode: sensitiveCollectionModeSchema.optional(),
+	sensitiveCollection: sensitiveCollectionConfigSchema.optional()
+}).strict();
+/**
+* Booking Questions form settings
+* Used for reusable short forms / detailed questionnaires attached through booking requirements.
+*/
+const bookingQuestionsFormSettingsSchema = z.object({
+	type: z.literal("booking-questions"),
+	schemaVersion: z.literal(2).default(2),
+	shape: z.enum(["short-form", "detailed-questionnaire"]).default("short-form"),
+	sensitiveCollectionMode: sensitiveCollectionModeSchema.optional(),
+	sensitiveCollection: sensitiveCollectionConfigSchema.optional(),
+	audienceHint: z.enum([
+		"appointments",
+		"events",
+		"courses",
+		"mixed"
+	]).optional(),
+	customerTitle: z.string().min(1).max(120).optional(),
+	introTitle: z.string().min(1).max(120).nullable().optional(),
+	introBody: z.string().min(1).max(4e3).nullable().optional(),
+	reviewLayout: z.enum(["flat", "sectioned"]).default("flat")
+}).strict();
+z.discriminatedUnion("type", [
+	contactFormSettingsSchema,
+	bookingFormSettingsSchema,
+	eventRegistrationFormSettingsSchema,
+	bookingQuestionsFormSettingsSchema
+]);
+const contactFormSettingsInputSchema = contactFormSettingsSchema.extend(formPresentationSettingsShape).strict();
+const bookingFormSettingsInputSchema = bookingFormSettingsSchema.safeExtend(formPresentationSettingsShape).strict();
+const eventRegistrationFormSettingsInputSchema = eventRegistrationFormSettingsSchema.extend(formPresentationSettingsShape).strict();
+const bookingQuestionsFormSettingsInputSchema = bookingQuestionsFormSettingsSchema.extend(formPresentationSettingsShape).strict();
+/**
+* Transitional input schema for API/SDK callers that may still send form-level
+* presentation metadata inside settings. Storage code must split these keys out
+* before persisting canonical behavior settings.
+*/
+const formSettingsInputSchema = z.discriminatedUnion("type", [
+	contactFormSettingsInputSchema,
+	bookingFormSettingsInputSchema,
+	eventRegistrationFormSettingsInputSchema,
+	bookingQuestionsFormSettingsInputSchema
+]);
+/**
+* Form field option schema
+*/
+const formFieldOptionSchema = z.object({
+	value: z.string().min(1),
+	label: z.string()
+}).strict();
+/**
+* Form field layout schema
+* Controls presentation on the public site renderer (e.g. 2-column rows).
+*/
+const formFieldLayoutSchema = z.object({ width: z.enum(["full", "half"]).default("full") }).strict();
+const formFieldSchema = z.object({
+	id: z.string().min(1, "Field ID is required"),
+	label: z.string().min(1, "Field label is required"),
+	type: z.enum([
+		"text",
+		"email",
+		"textarea",
+		"select",
+		"radio",
+		"checkbox",
+		"consent",
+		"tel",
+		"url",
+		"number",
+		"date",
+		"time"
+	]),
+	required: z.boolean().default(false),
+	placeholder: z.string().optional(),
+	helpText: z.string().optional(),
+	options: z.array(formFieldOptionSchema).optional(),
+	multiple: z.boolean().optional(),
+	minLength: z.number().int().positive().optional(),
+	maxLength: z.number().int().positive().optional(),
+	pattern: z.string().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	layout: formFieldLayoutSchema.optional()
+}).strict();
+const bookingQuestionFieldTypeSchema = z.enum([
+	"text",
+	"email",
+	"textarea",
+	"select",
+	"radio",
+	"checkbox",
+	"tel",
+	"url",
+	"number",
+	"date",
+	"time"
+]);
+const bookingQuestionDocumentFileTypeSchema = z.enum([
+	"pdf",
+	"image",
+	"docx"
+]);
+const bookingQuestionScalarFieldSchema = formFieldSchema.extend({ type: bookingQuestionFieldTypeSchema }).strict();
+const bookingQuestionDocumentUploadFieldSchema = z.object({
+	id: z.string().min(1, "Field ID is required"),
+	label: z.string().min(1, "Field label is required"),
+	type: z.literal("document_upload"),
+	required: z.boolean().default(false),
+	placeholder: z.string().optional(),
+	helpText: z.string().optional(),
+	layout: formFieldLayoutSchema.optional(),
+	allowedFileTypes: z.array(bookingQuestionDocumentFileTypeSchema).min(1, "Choose at least one allowed file type").default([
+		"pdf",
+		"image",
+		"docx"
+	]),
+	maxBytes: z.number().int().positive().max(25 * 1024 * 1024).default(25 * 1024 * 1024)
+}).strict();
+const bookingQuestionFieldSchema = z.discriminatedUnion("type", [bookingQuestionScalarFieldSchema, bookingQuestionDocumentUploadFieldSchema]);
+const bookingQuestionsSectionSchema = z.object({
+	id: z.string().min(1, "Section ID is required"),
+	title: z.string().min(1, "Section title is required"),
+	description: z.string().optional(),
+	items: z.array(bookingQuestionFieldSchema).min(1, "Section must contain at least one question")
+}).strict();
+const bookingQuestionsDetailedSchemaSchema = z.object({
+	schemaVersion: z.literal(2),
+	sections: z.array(bookingQuestionsSectionSchema).min(1, "Questionnaire must have at least one section")
+}).strict();
+/**
+* Form schema structure
+* Validates the complete form schema stored in schema_json column
+*/
+const formSchemaSchema = z.object({
+	version: z.string().default("1.0"),
+	fields: z.array(formFieldSchema).min(1, "Form must have at least one field")
+}).strict();
+const bookingQuestionsFlatSchemaSchema = z.object({
+	version: z.string().default("1.0"),
+	fields: z.array(bookingQuestionFieldSchema).min(1, "Form must have at least one question")
+}).strict();
+z.union([bookingQuestionsFlatSchemaSchema, bookingQuestionsDetailedSchemaSchema]);
+const formSlugSchema = z.string().min(1, "Form slug is required").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers, and hyphens only").transform((value) => value);
+z.object({
+	name: z.string().min(1, "Form name is required"),
+	slug: formSlugSchema,
+	schema: formSchemaSchema,
+	settings: formSettingsInputSchema.optional(),
+	presentation: formPresentationSettingsSchema.optional()
+}).strict();
+//#endregion
+//#region ../db/src/schemas/standard-contact.ts
+const standardContactLabelSchema = z.string().trim().min(1).max(80);
+const standardContactPlaceholderSchema = z.string().trim().max(160).optional();
+function standardContactFieldSchema(id, type, required) {
+	return z.object({
+		id: z.literal(id),
+		label: standardContactLabelSchema,
+		type: z.literal(type),
+		required: z.literal(required),
+		placeholder: standardContactPlaceholderSchema
+	}).strict();
+}
+z.object({
+	version: z.literal("1.0"),
+	fields: z.tuple([
+		standardContactFieldSchema("name", "text", false),
+		standardContactFieldSchema("email", "email", true),
+		standardContactFieldSchema("phone", "tel", false),
+		standardContactFieldSchema("message", "textarea", true)
+	])
+}).strict();
+//#endregion
 //#region ../media-storage-supabase/dist/index.mjs
 function ok(value) {
 	return {
@@ -2527,15 +3419,17 @@ const createApiMediaRepo = ({ client }) => ({
 		}, (error) => toMediaStorageError(error, DEFAULT_MESSAGES.update));
 	},
 	async deleteAsset(assetId, options) {
-		try {
-			await client({
-				endpoint: "mediaDelete",
-				params: { assetId },
-				body: { deleteObject: options?.deleteObject }
-			});
-		} catch (error) {
-			throw toMediaStorageError(error, DEFAULT_MESSAGES.delete);
-		}
+		const response = await callClient(client, {
+			endpoint: "mediaDelete",
+			params: { assetId },
+			body: { deleteObject: options?.deleteObject }
+		}, (error) => toMediaStorageError(error, DEFAULT_MESSAGES.delete));
+		if (response.kind === "deleted") return response;
+		const orphanWarning = response.warnings.find((warning) => warning.kind === "ORPHAN_CLEANUP_FAILED");
+		return orphanWarning === void 0 ? { kind: "deleted" } : {
+			kind: "deleted_with_orphan_warning",
+			warning: orphanWarning
+		};
 	},
 	generateStoragePath
 });
@@ -2626,8 +3520,9 @@ function createCachedMediaRepo(baseRepo, options) {
 			return result;
 		},
 		async deleteAsset(assetId, options) {
-			await baseRepo.deleteAsset(assetId, options);
+			const outcome = await baseRepo.deleteAsset(assetId, options);
 			invalidateCache();
+			return outcome;
 		},
 		generateStoragePath: baseRepo.generateStoragePath
 	};
@@ -8302,10 +9197,10 @@ function resolveShellThemeRoles(props) {
 }
 const previewContainerResponsiveEnabled = process.env.NEXT_PUBLIC_ENABLE_PREVIEW_CONTAINER_RESPONSIVE !== "false";
 const PreviewEditorSidebar = React.lazy(async () => {
-	return { default: (await import("./PreviewEditorSidebar-BU5ZlhQR.mjs")).PreviewEditorSidebar };
+	return { default: (await import("./PreviewEditorSidebar-BVPur_CU.mjs")).PreviewEditorSidebar };
 });
 const PreviewEditorUI = React.lazy(async () => {
-	return { default: (await import("./PreviewEditorUI-9XkHL-bC.mjs")).PreviewEditorUI };
+	return { default: (await import("./PreviewEditorUI-DLhWX8oh.mjs")).PreviewEditorUI };
 });
 const previewPaneContainmentStyle = {
 	contain: "layout paint",
@@ -8321,6 +9216,7 @@ function renderShellProviders(input) {
 			siteId: props.siteId,
 			apiClient: input.apiClient,
 			theme: themeRoles.persistenceTheme,
+			headerPreferences: props.themeSelectionHeaderPreferences ?? null,
 			themeId: props.themeId ?? null,
 			selectionId: props.themeSelectionId ?? null,
 			selectionVersion: props.themeSelectionVersion ?? null,
@@ -8636,6 +9532,7 @@ function resolveShellLayoutProps(input) {
 		themeSelectionUpdatedAt: props.themeSelectionUpdatedAt ?? null,
 		themeSelectionButtonStyleSelection: props.themeSelectionButtonStyleSelection ?? null,
 		themeSelectionButtonStyleRepairs: props.themeSelectionButtonStyleRepairs ?? [],
+		themeSelectionHeaderPreferences: props.themeSelectionHeaderPreferences ?? null,
 		themeSelectionHeaderSelection: props.themeSelectionHeaderSelection ?? null,
 		themeSelectionFooterLookId: props.themeSelectionFooterLookId ?? null,
 		themeSelectionHeaderLogo: props.themeSelectionHeaderLogo,
@@ -9584,10 +10481,14 @@ function BlockToolbar({ blockId, blockKind, content, bookingOfferingPresets, the
 		const state = uiStore.getState();
 		state.setPreviewSidebarTab("editor");
 		state.setDrawerOpen(true);
-		state.requestFocus({
+		const path = typeof focusTarget.itemIndex === "number" && focusTarget.fieldPath ? `${focusTarget.fieldPath}.${focusTarget.itemIndex}` : focusTarget.fieldPath;
+		state.requestFocus(path ? {
+			kind: "main-field",
 			blockId: editorBlockId,
-			fieldPath: focusTarget.fieldPath,
-			itemIndex: focusTarget.itemIndex
+			fieldPath: path
+		} : {
+			kind: "block",
+			blockId: editorBlockId
 		});
 	};
 	const inspectBlock = useCallback(() => {
@@ -10515,6 +11416,80 @@ function resolveRuntimePreviewSource(input) {
 }
 //#endregion
 //#region ../preview-next/src/client/blocks/previewBatchLoaderParams.ts
+function isBatchableEndpoint(endpoint) {
+	return endpoint === "listPublicEvents" || endpoint === "listPublicEventCalendarWindow" || endpoint === "getPublicEventDetails" || endpoint === "listPublicRouteCandidates" || endpoint === "listPublicTeamMembers" || endpoint === "listPublicProducts" || endpoint === "getPublicBookingServices" || endpoint === "getPublicWeeklySlotAvailability" || endpoint === "getPublicFormById";
+}
+function buildBatchLoaderRequest(id, endpoint, params) {
+	switch (endpoint) {
+		case "listPublicEventCalendarWindow": return {
+			id,
+			endpoint,
+			params: calendarWindowQuerySchema.parse(params ?? {})
+		};
+		case "listPublicEvents": {
+			const typedParams = params;
+			return typedParams ? {
+				id,
+				endpoint,
+				params: typedParams
+			} : {
+				id,
+				endpoint
+			};
+		}
+		case "getPublicEventDetails": {
+			const typedParams = params;
+			return typedParams ? {
+				id,
+				endpoint,
+				params: typedParams
+			} : {
+				id,
+				endpoint
+			};
+		}
+		case "listPublicRouteCandidates": return {
+			id,
+			endpoint
+		};
+		case "listPublicProducts": {
+			const typedParams = params;
+			return typedParams ? {
+				id,
+				endpoint,
+				params: typedParams
+			} : {
+				id,
+				endpoint
+			};
+		}
+		case "listPublicTeamMembers": return {
+			id,
+			endpoint
+		};
+		case "getPublicBookingServices": {
+			const typedParams = params;
+			return typedParams ? {
+				id,
+				endpoint,
+				params: typedParams
+			} : {
+				id,
+				endpoint
+			};
+		}
+		case "getPublicWeeklySlotAvailability": return {
+			id,
+			endpoint,
+			params: params ?? { serviceId: "" }
+		};
+		case "getPublicFormById": return {
+			id,
+			endpoint,
+			params: params ?? { formId: "" }
+		};
+	}
+}
 function stripUndefined(obj) {
 	const out = {};
 	for (const [key, value] of Object.entries(obj)) if (value !== void 0) out[key] = value;
@@ -10552,17 +11527,13 @@ function nonEmpty(params) {
 }
 function toPreviewBatchParams(endpoint, params) {
 	switch (endpoint) {
+		case "listPublicEventCalendarWindow": return calendarWindowQuerySchema.parse(params);
 		case "listPublicEvents": return nonEmpty({
 			...eventLoaderParams(params),
 			detailLevel: params.detailLevel || void 0,
 			readProfile: params.readProfile || void 0
 		});
 		case "getPublicEventDetails": return nonEmpty(eventLoaderParams(params));
-		case "listPublicWholeSeriesOfferings": return nonEmpty(stripUndefined({ limit: params.limit || void 0 }));
-		case "getPublicWholeSeriesOffering": return nonEmpty(stripUndefined({
-			eventSeriesId: params.eventSeriesId || void 0,
-			stage: params.stage || void 0
-		}));
 		case "listPublicProducts": return nonEmpty(stripUndefined({ categorySelector: decodePublicProductCategorySelectorQuery(params) ?? void 0 }));
 		case "getPublicBookingServices": return nonEmpty(stripUndefined({ ids: normalizeIdsParam(params.ids || void 0) }));
 		case "getPublicFormById": return { formId: params.formId ?? "" };
@@ -10924,97 +11895,6 @@ async function callDirectLoaderApiEndpoint(dashboardApiClient, endpoint, params)
 		})));
 	}
 }
-function isBatchableEndpoint(endpoint) {
-	return endpoint === "listPublicEvents" || endpoint === "getPublicEventDetails" || endpoint === "listPublicWholeSeriesOfferings" || endpoint === "getPublicWholeSeriesOffering" || endpoint === "listPublicRouteCandidates" || endpoint === "listPublicTeamMembers" || endpoint === "listPublicProducts" || endpoint === "getPublicBookingServices" || endpoint === "getPublicWeeklySlotAvailability" || endpoint === "getPublicFormById";
-}
-function buildBatchLoaderRequest(id, endpoint, params) {
-	switch (endpoint) {
-		case "listPublicEvents": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "getPublicEventDetails": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "listPublicWholeSeriesOfferings": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "getPublicWholeSeriesOffering": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "listPublicRouteCandidates": return {
-			id,
-			endpoint
-		};
-		case "listPublicProducts": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "listPublicTeamMembers": return {
-			id,
-			endpoint
-		};
-		case "getPublicBookingServices": {
-			const typedParams = params;
-			return typedParams ? {
-				id,
-				endpoint,
-				params: typedParams
-			} : {
-				id,
-				endpoint
-			};
-		}
-		case "getPublicWeeklySlotAvailability": return {
-			id,
-			endpoint,
-			params: params ?? { serviceId: "" }
-		};
-		case "getPublicFormById": return {
-			id,
-			endpoint,
-			params: params ?? { formId: "" }
-		};
-	}
-}
 function usePreviewHeaderClearance() {
 	const [clearance, setClearance] = useState({ kind: "none" });
 	useEffect(() => {