riverbankcms 0.28.0 → 0.28.1

package/dist/{entryCommands-Bus1LjSx.mjs → entryCommands-CrfobcW7.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { A as evaluateSiteCommandExposure, E as parseAndPlanCommandBatchForTypes, F as entryIdentifierForCommand, It as themeSchema, K as bookingQuestionAttachmentSchema, Mr as asPageFlowPresetId, Nr as asSiteStyleId, T as createDryRunReport, V as eventBookingOfferIntentSchema, X as createCommandRef, Xr as parseSurfaceTree, Z as createContentEntryRef, Zn as getDirectImageUrlForSiteScopedPath, _n as pageDesignIntentSchemaVersion, _r as normalizeAmbiguousStoragePathForSite, br as MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES, cn as asHeaderLayoutId, ct as require_dist, dn as headerStyleIdValues, dr as slugifyMediaIdentifier, fn as buttonStyleSelectionSchema, gn as pageDesignBoundaryTreatmentSchema, gt as headerPreferencesSchema, hr as getMimeType, it as createSiteCommandSiteRef, j as getSiteCommandMetadata, k as evaluateSiteCommandBatchExposure, kr as asAppearancePresetId, ln as asHeaderStyleId, m as isInternalResolvedLinkValue, mr as getExtensionForMimeType, n as sdkCourseBookingSettingsSchema, on as asFooterLookId, r as sdkEventOccurrenceInputSchema, s as RESOLVED_INTERNAL_LINK_ENTITY_TYPES, sn as footerLookIdValues, sr as buildMediaIdentifierFromFilename, st as slugPart, un as headerLayoutIdValues, ur as resolveMediaIdentifier, vn as footerPreferencesSchema, w as stableStringify, x as resolvePageUpsertSeo, y as eventVisibilitySchema, yr as FILE_SIZE_LIMITS } from "./sdk-event-upsert-BrJvTQ-D.mjs";
-import { C as createSecret, Cn as parsePageId, Et as resolveBookingTimeZoneId, L as parseFooterCompositionV1, Ln as unsafeAsEventOfferingId, On as unsafeAsAppointmentResourceId, Qn as unsafeAsStaffMemberId, Rn as unsafeAsEventSeriesId, St as parseBookingLocalDate, T as parseManagementKey, Tn as parseSiteId, Vn as unsafeAsOccurrenceId, Z as locationValueSchema, _ as publicReadFreshnessSeconds, c as parseVerticalId, d as DEFAULT_EVENT_TYPE_PRESETS, f as EVENT_PRESET_VALUES, g as getPublicReadCachePolicy, ir as ok, l as parseVerticalPresetId, o as areConfiguredBookingVerticalConfigsEqual, ot as formatDate, pn as assertNever, r as resolveEventCatalogue, rr as err, s as canonicalizeConfiguredBookingVerticalConfig, t as committedWriteProofSchema, u as resolveSiteVerticalBookingConfig, w as exposeSecret } from "./src-D9-RAM-l.mjs";
-import { n as CliSdkPeerError, t as loadConfigFile } from "./load-config-9DBnYiBm.mjs";
+import { A as evaluateSiteCommandExposure, E as parseAndPlanCommandBatchForTypes, F as entryIdentifierForCommand, Ht as BREAKPOINT_MD, It as themeSchema, Jn as parseAspectRatioValue, K as bookingQuestionAttachmentSchema, Mr as asPageFlowPresetId, Nr as asSiteStyleId, Or as arrangementModes, T as createDryRunReport, Ut as BREAKPOINT_SM, V as eventBookingOfferIntentSchema, Vt as BREAKPOINT_LG, Wt as BREAKPOINT_XL, X as createCommandRef, Xr as parseSurfaceTree, Z as createContentEntryRef, Zn as getDirectImageUrlForSiteScopedPath, _n as pageDesignIntentSchemaVersion, _r as normalizeAmbiguousStoragePathForSite, br as MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES, cn as asHeaderLayoutId, ct as require_dist, dn as headerStyleIdValues, dr as slugifyMediaIdentifier, fn as buttonStyleSelectionSchema, gn as pageDesignBoundaryTreatmentSchema, hr as getMimeType, it as createSiteCommandSiteRef, j as getSiteCommandMetadata, k as evaluateSiteCommandBatchExposure, kr as asAppearancePresetId, ln as asHeaderStyleId, m as isInternalResolvedLinkValue, mr as getExtensionForMimeType, n as sdkCourseBookingSettingsSchema, on as asFooterLookId, r as sdkEventOccurrenceInputSchema, s as RESOLVED_INTERNAL_LINK_ENTITY_TYPES, sn as footerLookIdValues, sr as buildMediaIdentifierFromFilename, st as slugPart, un as headerLayoutIdValues, ur as resolveMediaIdentifier, vn as footerPreferencesSchema, vt as headerPreferencesSchema, w as stableStringify, x as resolvePageUpsertSeo, y as eventVisibilitySchema, yr as FILE_SIZE_LIMITS } from "./sdk-event-upsert-4Dn75Ui9.mjs";
+import { $ as locationValueSchema, D as parseManagementKey, E as exposeSecret, J as assertAllowedPublicUrl, Kn as parsePageId, Ot as resolveBookingTimeZoneId, R as parseMailingListProviderScope, T as createSecret, Tt as parseBookingLocalDate, Yn as parseSiteId, a as resolveEventCatalogue, bn as unsafeAsAppointmentResourceId, c as areConfiguredBookingVerticalConfigsEqual, ct as formatDate, d as parseVerticalPresetId, f as resolveSiteVerticalBookingConfig, gn as assertNever, ir as unsafeAsOccurrenceId, l as canonicalizeConfiguredBookingVerticalConfig, m as EVENT_PRESET_VALUES, n as committedWriteProofSchema, nr as unsafeAsEventOfferingId, or as err, p as DEFAULT_EVENT_TYPE_PRESETS, rr as unsafeAsEventSeriesId, sr as ok, t as OFFLINE_PAYMENT_METHODS, u as parseVerticalId, v as getPublicReadCachePolicy, xn as unsafeAsStaffMemberId, y as publicReadFreshnessSeconds, z as parseFooterCompositionV1 } from "./src-nzVzuMR1.mjs";
+import { n as CliSdkPeerError, t as loadConfigFile } from "./load-config-DTbiJyCf.mjs";
 import { Command } from "commander";
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs$1 from "fs/promises";
@@ -82,20 +82,20 @@ function isApiError(result) {
 function isApiSuccess(result) {
 	return result.success === true;
 }
-function isRecord$10(value) {
+function isRecord$11(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isFieldError$1(value) {
-	return isRecord$10(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string" && (value.capacityOverride === undefined || isCapacityOverrideRefusal(value.capacityOverride));
+	return isRecord$11(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string" && (value.capacityOverride === undefined || isCapacityOverrideRefusal(value.capacityOverride));
 }
 function fieldErrorsFromUnknown(value) {
 	if (!Array.isArray(value)) return null;
 	return value.every(isFieldError$1) ? value : null;
 }
 function extractEnvelopeErrorObject(body) {
-	if (!isRecord$10(body)) return null;
+	if (!isRecord$11(body)) return null;
 	const error = body.error;
-	if (!isRecord$10(error)) return null;
+	if (!isRecord$11(error)) return null;
 	if ("success" in body && body.success !== false) {
 		return null;
 	}
@@ -339,6 +339,24 @@ function toFlattenedFieldErrors(zodError, options) {
 //#region ../api/src/retentionPolicies.ts
 /** Pure policy catalogue shared by retention execution and its API projections. */
 const retentionPolicyRegistry = {
+	assistant_messages: {
+		dataClass: "assistant_messages",
+		policyKind: "platform_auto_delete",
+		trigger: "created_at",
+		window: {
+			kind: "relative",
+			unit: "months",
+			value: 12
+		},
+		action: "hard_delete",
+		automation: {
+			kind: "scheduled",
+			jobKind: "assistant_conversation_cleanup",
+			executionModes: ["dry_run", "scheduled"],
+			executionSubstrate: "vercel_cron"
+		},
+		rationale: "Each assistant message expires after twelve months, regardless of later conversation activity. Empty conversations and their choices are removed too."
+	},
 	portal_sessions: {
 		dataClass: "portal_sessions",
 		policyKind: "platform_auto_delete",
@@ -810,7 +828,9 @@ const PREVIEW_BLOCKED_REASONS = [
 	"duplicate",
 	"run_closed",
 	"past_date",
-	"invalid_schedule"
+	"invalid_schedule",
+	"stale",
+	"invalid_state"
 ];
 
 //#endregion
@@ -859,6 +879,7 @@ const pageCommitReasonSchema = z.enum([
 	"invalid-document",
 	"invalid-history",
 	"path-unavailable",
+	"homepage-publication-required",
 	"invalid-page-version",
 	"invalid-block-reference",
 	"invalid-content-reference",
@@ -905,6 +926,7 @@ const reasonMessages = {
 	"invalid-revision": "The saved page version could not be read. Reload the page before continuing.",
 	"invalid-document": "The saved page content could not be read. Reload the page before continuing.",
 	"invalid-history": "The saved page history could not be read. Reload the page before continuing.",
+	"homepage-publication-required": "Publish this page first. Your current homepage is live, so the page that replaces it has to be published too.",
 	"path-unavailable": "This address is already in use. Choose a different page address.",
 	"invalid-page-version": "This saved page version could not be read. Choose another version.",
 	"invalid-block-reference": "A saved block is missing from this page. Reload the page before continuing.",
@@ -934,6 +956,44 @@ function pageCommitReasonFromTag(tag) {
 //#endregion
 //#region ../api/src/pageJournalEndpoints.ts
 const PAGE_JOURNAL_ENDPOINT_DEFINITIONS = {
+	discardAssistantPage: {
+		path: "/sites/{siteId}/pages/{pageId}/assistant-discard",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		editLease: "unleased-editor",
+		errors: [
+			"validation:invalid_input",
+			"auth:forbidden",
+			"server:internal_error"
+		]
+	},
+	constructAssistantPage: {
+		path: "/sites/{siteId}/pages/assistant",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		editLease: "unleased-editor",
+		errors: [
+			"validation:invalid_input",
+			"auth:forbidden",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
+	commitPageChangeBatch: {
+		path: "/sites/{siteId}/pages/{pageId}/journal",
+		method: "PUT",
+		auth: "user",
+		responseKind: "json",
+		editLease: "managed",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
 	getPagePublishReadinessFacts: {
 		path: "/sites/{siteId}/pages/readiness-facts",
 		method: "POST",
@@ -2836,48 +2896,6 @@ const NEWSLETTER_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 		auth: "user",
 		responseKind: "json"
 	},
-	listNewsletterTemplates: {
-		path: "/sites/{siteId}/newsletter/templates",
-		method: "GET",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
-	createNewsletterTemplate: {
-		path: "/sites/{siteId}/newsletter/templates",
-		method: "POST",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
-	getNewsletterTemplate: {
-		path: "/sites/{siteId}/newsletter/templates/{templateId}",
-		method: "GET",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
-	updateNewsletterTemplate: {
-		path: "/sites/{siteId}/newsletter/templates/{templateId}",
-		method: "PATCH",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
-	deleteNewsletterTemplate: {
-		path: "/sites/{siteId}/newsletter/templates/{templateId}",
-		method: "DELETE",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
-	previewNewsletterTemplate: {
-		path: "/sites/{siteId}/newsletter/templates/{templateId}/preview",
-		method: "POST",
-		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
-		auth: "user",
-		responseKind: "json"
-	},
 	listNewsletterCampaigns: {
 		path: "/sites/{siteId}/newsletter/campaigns",
 		method: "GET",
@@ -2935,6 +2953,38 @@ const NEWSLETTER_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 		responseKind: "json",
 		demoMutation: DEMO_MUTATION_BLOCKED_HIDDEN
 	},
+	listNewsletterWebsitePicker: {
+		path: "/sites/{siteId}/newsletter/website-picker",
+		method: "GET",
+		auth: "user",
+		responseKind: "json",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
+		errors: []
+	},
+	renderNewsletterCampaignDraft: {
+		path: "/sites/{siteId}/newsletter/campaigns/{campaignId}/render-draft",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
+		errors: []
+	},
+	reviewNewsletterCampaign: {
+		path: "/sites/{siteId}/newsletter/campaigns/{campaignId}/review",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
+		errors: []
+	},
+	duplicateNewsletterCampaign: {
+		path: "/sites/{siteId}/newsletter/campaigns/{campaignId}/duplicate",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteNewsletter],
+		errors: []
+	},
 	scheduleNewsletterCampaign: {
 		path: "/sites/{siteId}/newsletter/campaigns/{campaignId}/schedule",
 		method: "POST",
@@ -3499,25 +3549,6 @@ const EVENT_MANAGEMENT_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 			"server:internal_error"
 		]
 	},
-	updateEventAddress: {
-		editLease: "managed",
-		path: "/sites/{siteId}/bookings/events/{eventId}/address",
-		method: "PATCH",
-		tags: [
-			"site-{siteId}",
-			"event-series-{siteId}",
-			TAG_TEMPLATES.siteRoutableContent,
-			TAG_TEMPLATES.siteRedirects
-		],
-		auth: "user",
-		responseKind: "json",
-		errors: [
-			"validation:invalid_input",
-			"resource:not_found",
-			"resource:conflict",
-			"server:internal_error"
-		]
-	},
 	createWholeSeriesRun: {
 		path: "/sites/{siteId}/bookings/events/{eventId}/runs",
 		method: "POST",
@@ -4605,20 +4636,22 @@ const ENDPOINT_DEFINITIONS = {
 		auth: "user",
 		responseKind: "json"
 	},
-	aiPlaygroundProposeMulti: {
-		path: "/sites/{siteId}/ai/playground/propose-multi",
+	assistantConversation: {
+		path: "/assistant/conversation",
 		method: "POST",
 		auth: "user",
-		responseKind: "stream"
+		responseKind: "json",
+		errors: []
 	},
-	aiPlaygroundProposeMultiGet: {
-		path: "/sites/{siteId}/ai/playground/propose-multi",
-		method: "GET",
+	assistantNewConversation: {
+		path: "/assistant/conversation/new",
+		method: "POST",
 		auth: "user",
-		responseKind: "stream"
+		responseKind: "json",
+		errors: []
 	},
-	assistantSuggestions: {
-		path: "/assistant/suggestions",
+	assistantOutcome: {
+		path: "/assistant/outcome",
 		method: "POST",
 		auth: "user",
 		responseKind: "json",
@@ -4645,42 +4678,6 @@ const ENDPOINT_DEFINITIONS = {
 		responseKind: "stream",
 		errors: []
 	},
-	aiPlaygroundPageConvert: {
-		path: "/sites/{siteId}/ai/playground/page-convert",
-		method: "POST",
-		auth: "user",
-		responseKind: "json"
-	},
-	aiPlaygroundPageConvertJobsCreate: {
-		path: "/sites/{siteId}/ai/playground/page-convert/jobs",
-		method: "POST",
-		auth: "user",
-		responseKind: "json"
-	},
-	aiPlaygroundPageConvertJobsList: {
-		path: "/sites/{siteId}/ai/playground/page-convert/jobs",
-		method: "GET",
-		auth: "user",
-		responseKind: "json"
-	},
-	aiPlaygroundPageConvertJobGet: {
-		path: "/sites/{siteId}/ai/playground/page-convert/jobs/{jobId}",
-		method: "GET",
-		auth: "user",
-		responseKind: "json"
-	},
-	aiPlaygroundPageConvertJobRun: {
-		path: "/sites/{siteId}/ai/playground/page-convert/jobs/{jobId}/run",
-		method: "POST",
-		auth: "user",
-		responseKind: "json"
-	},
-	aiPlaygroundPageConvertJobEvents: {
-		path: "/sites/{siteId}/ai/playground/page-convert/jobs/{jobId}/events",
-		method: "GET",
-		auth: "user",
-		responseKind: "json"
-	},
 	aiGenerateSite: {
 		path: "/sites/{siteId}/ai/generate",
 		method: "POST",
@@ -5463,6 +5460,32 @@ const ENDPOINT_DEFINITIONS = {
 		auth: "user",
 		responseKind: "json"
 	},
+	getRouteAddress: {
+		path: "/sites/{siteId}/content-address/{targetKind}/{targetId}",
+		method: "GET",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteRoutableContent],
+		auth: "user",
+		responseKind: "json",
+		errors: ["resource:not_found", "resource:conflict"]
+	},
+	changeRouteAddress: {
+		editLease: "managed",
+		path: "/sites/{siteId}/content-address/{targetKind}/{targetId}",
+		method: "PATCH",
+		tags: [
+			TAG_TEMPLATES.site,
+			TAG_TEMPLATES.siteRoutableContent,
+			TAG_TEMPLATES.siteRedirects
+		],
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
 	updateRouteMetadata: {
 		editLease: "managed",
 		path: "/sites/{siteId}/routes/{routeId}/metadata",
@@ -5653,6 +5676,30 @@ const ENDPOINT_DEFINITIONS = {
 		auth: "user",
 		responseKind: "json"
 	},
+	previewWebsiteOperation: {
+		path: "/sites/{siteId}/website/preview",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"auth:insufficient_permissions",
+			"server:internal_error"
+		]
+	},
+	confirmWebsiteOperation: {
+		editLease: "unleased-editor",
+		path: "/sites/{siteId}/website/confirm",
+		method: "POST",
+		auth: "user",
+		responseKind: "json",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteSettings],
+		errors: [
+			"validation:invalid_input",
+			"auth:insufficient_permissions",
+			"server:internal_error"
+		]
+	},
 	previewSiteBrandingOperation: {
 		path: "/sites/{siteId}/settings/general/preview",
 		method: "POST",
@@ -8799,14 +8846,6 @@ const ENDPOINT_DEFINITIONS = {
 		auth: "user",
 		responseKind: "json"
 	},
-	aiPlaygroundApply: {
-		editLease: "unleased-editor",
-		path: "/sites/{siteId}/ai/playground/apply",
-		method: "POST",
-		tags: ["site-{siteId}"],
-		auth: "user",
-		responseKind: "json"
-	},
 	billingStatus: {
 		path: "/billing/status",
 		method: "GET",
@@ -9759,6 +9798,7 @@ const ENDPOINT_DEFINITIONS = {
 		responseKind: "json",
 		errors: [
 			"resource:not_found",
+			"resource:conflict",
 			"validation:invalid_input",
 			"server:internal_error"
 		]
@@ -10250,17 +10290,6 @@ const blockLocationFields = {
 	blockIdentifier: z.string().nullable(),
 	stage: z.enum(["draft", "published"])
 };
-const newsletterUsageLocationSchemas = [z.object({
-	kind: z.literal("newsletterTemplate"),
-	siteId: identifierSchema,
-	templateId: identifierSchema,
-	templateName: z.string()
-}), z.object({
-	kind: z.literal("newsletterCampaign"),
-	siteId: identifierSchema,
-	campaignId: identifierSchema,
-	campaignName: z.string()
-})];
 const mediaUsageLocationSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("appointmentService"),
@@ -10268,7 +10297,12 @@ const mediaUsageLocationSchema = z.discriminatedUnion("kind", [
 		serviceId: identifierSchema,
 		serviceTitle: z.string()
 	}),
-	...newsletterUsageLocationSchemas,
+	z.object({
+		kind: z.literal("newsletterCampaign"),
+		siteId: identifierSchema,
+		campaignId: identifierSchema,
+		campaignName: z.string()
+	}),
 	z.object({
 		kind: z.literal("pageBlock"),
 		...blockLocationFields,
@@ -10861,7 +10895,6 @@ const BOOKING_SETTINGS_SECTION_KEYS = {
 	],
 	appointments: [
 		"appointmentReminderOverrides",
-		"appointmentRescheduleHours",
 		"appointmentDefaultMinLeadMinutes",
 		"appointmentDefaultMaxBookingNoticeMinutes",
 		"appointmentBookingPolicies"
@@ -10885,61 +10918,423 @@ const BOOKING_SETTINGS_EMAIL_SEND_KEYS = [
 ];
 
 //#endregion
-//#region ../api/src/event-destination-policy.ts
-const eventDestinationModeValues = ["cms-managed", "system-managed"];
-const eventDestinationPresetValues = EVENT_PRESET_VALUES;
-const DEFAULT_EVENT_DESTINATION_POLICY = {
-	defaultMode: "cms-managed",
-	presetOverrides: {}
-};
-function isEventDestinationMode(value) {
-	return eventDestinationModeValues.some((mode) => mode === value);
+//#region ../api/src/event-listing-destination.ts
+const EVENT_LISTING_DESTINATION_SETTINGS_KEY = "listingDestination";
+const DEFAULT_EXTERNAL_EVENT_CTA_LABEL = "View details";
+function isRecord$10(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function resolveEventDestinationMode(input) {
-	const policy = input.policy ?? DEFAULT_EVENT_DESTINATION_POLICY;
-	if (input.preset) {
-		const presetOverride = policy.presetOverrides[input.preset];
-		if (presetOverride) return presetOverride;
+function normalizeOptionalLabel(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeOptionalUrl(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function normalizeEventListingDestinationInput(value) {
+	if (!value || value.kind === "native") {
+		return { kind: "native" };
 	}
-	if (input.publicExperience === "hosted_booking") return "system-managed";
-	return policy.defaultMode;
+	return {
+		kind: "external",
+		url: normalizeOptionalUrl(value.url),
+		label: normalizeOptionalLabel(value.label)
+	};
 }
-function macadamiaDefaultEventDestinationPolicy(selectedPresets) {
-	const presetOverrides = {};
-	for (const preset of selectedPresets) {
-		presetOverrides[preset] = preset === "class" ? "system-managed" : "cms-managed";
+function readEventListingDestinationFromSettings(settingsJson) {
+	if (!isRecord$10(settingsJson)) {
+		return { kind: "native" };
+	}
+	const rawDestination = settingsJson[EVENT_LISTING_DESTINATION_SETTINGS_KEY];
+	if (!isRecord$10(rawDestination) || rawDestination.kind !== "external") {
+		return { kind: "native" };
 	}
 	return {
-		defaultMode: "cms-managed",
-		presetOverrides
+		kind: "external",
+		url: normalizeOptionalUrl(rawDestination.url),
+		label: normalizeOptionalLabel(rawDestination.label)
 	};
 }
-
-//#endregion
-//#region ../api/src/bookingConfig.ts
-/** Every option kind; the checkout routes validate the requested kind against it. */
-const DIRECT_CHECKOUT_COLLECTION_OPTION_KINDS = [
-	"upfront",
-	"deferred_manual",
-	"instalment_plan",
-	"flexible_balance"
-];
-const eventOccurrenceRestorationSummarySchema = z.object({
-	restoredOccurrenceIds: z.array(z.string().uuid()),
-	excludedBookings: z.array(z.object({
-		attendeeId: z.string().uuid(),
-		occurrenceId: z.string().uuid(),
-		customerId: z.string().uuid(),
-		customerName: z.string().nullable(),
-		customerEmail: z.string().nullable()
-	}))
-});
-const DEFAULT_BOOKING_NOTIFICATION_SEND_RULE = {
-	kind: "send",
-	sendToAssignedStaff: true,
-	extraEmail: null,
-	sendToSiteOwnerIfNoStaff: true
-};
+function serializeEventListingDestination(destination) {
+	switch (destination.kind) {
+		case "native": return { kind: "native" };
+		case "external": return {
+			kind: "external",
+			url: destination.url,
+			label: destination.label
+		};
+	}
+}
+function buildEventListingDestinationSettingsPatch(destination) {
+	return { [EVENT_LISTING_DESTINATION_SETTINGS_KEY]: serializeEventListingDestination(destination) };
+}
+function parseExternalEventUrl(value) {
+	const raw = normalizeOptionalUrl(value);
+	if (!raw) {
+		return {
+			ok: false,
+			error: {
+				code: "missing_url",
+				message: "External event URL is required."
+			}
+		};
+	}
+	try {
+		const url = assertAllowedPublicUrl(raw, {
+			allowedProtocols: ["https:"],
+			portPolicy: "standard-only"
+		});
+		return {
+			ok: true,
+			url: url.href
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: {
+				code: "invalid_url",
+				message: error instanceof Error ? error.message : "External event URL must be a valid public HTTPS URL."
+			}
+		};
+	}
+}
+function getExternalEventCtaLabel(destination) {
+	return destination.label ?? DEFAULT_EXTERNAL_EVENT_CTA_LABEL;
+}
+function getEventListingDestinationPublicationIssue(destination) {
+	if (destination.kind === "native") {
+		return null;
+	}
+	const validation = parseExternalEventUrl(destination.url);
+	if (validation.ok) {
+		return null;
+	}
+	return {
+		field: "listingDestination.url",
+		code: validation.error.code,
+		message: validation.error.message
+	};
+}
+function buildPublicEventDestination(input) {
+	if (input.listingDestination.kind === "native") {
+		if (!input.nativePath.trim()) {
+			return null;
+		}
+		return {
+			kind: "native",
+			mode: input.nativeMode,
+			path: input.nativePath
+		};
+	}
+	const validation = parseExternalEventUrl(input.listingDestination.url);
+	if (!validation.ok) {
+		return null;
+	}
+	return {
+		kind: "external",
+		url: validation.url,
+		label: getExternalEventCtaLabel(input.listingDestination)
+	};
+}
+
+//#endregion
+//#region ../api/src/event-destination-policy.ts
+const eventDestinationModeValues = ["cms-managed", "system-managed"];
+const eventDestinationPresetValues = EVENT_PRESET_VALUES;
+const DEFAULT_EVENT_DESTINATION_POLICY = {
+	defaultMode: "cms-managed",
+	presetOverrides: {}
+};
+function isEventDestinationMode(value) {
+	return eventDestinationModeValues.some((mode) => mode === value);
+}
+function resolveEventDestinationMode(input) {
+	const policy = input.policy ?? DEFAULT_EVENT_DESTINATION_POLICY;
+	if (input.preset) {
+		const presetOverride = policy.presetOverrides[input.preset];
+		if (presetOverride) return presetOverride;
+	}
+	if (input.publicExperience === "hosted_booking") return "system-managed";
+	return policy.defaultMode;
+}
+function macadamiaDefaultEventDestinationPolicy(selectedPresets) {
+	const presetOverrides = {};
+	for (const preset of selectedPresets) {
+		presetOverrides[preset] = preset === "class" ? "system-managed" : "cms-managed";
+	}
+	return {
+		defaultMode: "cms-managed",
+		presetOverrides
+	};
+}
+
+//#endregion
+//#region ../api/src/appointmentServiceVisibility.ts
+const APPOINTMENT_SERVICE_VISIBILITY_VALUES = ["public", "unlisted"];
+function isAppointmentServiceVisibility(value) {
+	return value === "public" || value === "unlisted";
+}
+
+//#endregion
+//#region ../api/src/request-error.ts
+var ApiRequestError = class extends Error {
+	constructor(message, options) {
+		super(message);
+		this.name = "ApiRequestError";
+		this.endpoint = options.endpoint;
+		this.status = options.status;
+		this.method = options.method;
+		this.auth = options.auth;
+		this.requestId = options.requestId;
+		this.body = options.body;
+		this.cause = options.cause;
+		this.errorCode = options.errorCode;
+		this.tag = options.tag;
+		this.retryAfterMs = options.retryAfterMs;
+	}
+};
+
+//#endregion
+//#region ../api/src/utils/isRecord.ts
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region ../api/src/utils/error-propagation.ts
+/**
+* Extracts an error message from an API error response body.
+* Checks for our standard API error format: { error: { message: "..." } }
+* Also handles legacy formats with `error` or `message` as strings.
+*/
+function extractApiErrorMessage(body) {
+	if (!isRecord$5(body)) {
+		return null;
+	}
+	if (isRecord$5(body.error)) {
+		if (typeof body.error.message === "string" && body.error.message.trim().length > 0) {
+			return body.error.message;
+		}
+	}
+	if (typeof body.error === "string" && body.error.trim().length > 0) {
+		return body.error;
+	}
+	if (typeof body.message === "string" && body.message.trim().length > 0) {
+		return body.message;
+	}
+	return null;
+}
+/**
+* Normalizes various error types and throws with an appropriate message.
+*
+* - For ApiRequestError: extracts message from body.error or body.message
+* - For Error instances: re-throws as-is
+* - For unknown errors: wraps with fallback message
+*
+* @param error - The error to normalize
+* @param fallback - Fallback message if no specific message can be extracted
+* @throws {Error} Always throws - this function never returns
+*/
+function normalizeApiError(error, fallback) {
+	if (error instanceof ApiRequestError) {
+		const message = extractApiErrorMessage(error.body);
+		throw new ApiRequestError(message ?? fallback, {
+			endpoint: error.endpoint,
+			status: error.status,
+			method: error.method,
+			auth: error.auth,
+			requestId: error.requestId,
+			body: error.body,
+			cause: error,
+			errorCode: error.errorCode,
+			tag: error.tag,
+			retryAfterMs: error.retryAfterMs
+		});
+	}
+	if (error instanceof Error) {
+		throw error;
+	}
+	throw new Error(fallback);
+}
+
+//#endregion
+//#region ../api/src/appointmentSetup.ts
+const APPOINTMENT_SETUP_MAX_MINUTES = 1440;
+const appointmentSetupRefSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("existing"),
+	id: z.string().min(1)
+}), z.object({
+	kind: z.literal("new"),
+	draftId: z.string().min(1)
+})]);
+const appointmentSetupVenueChoiceSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }),
+	z.object({
+		kind: z.literal("existing"),
+		venueId: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("create"),
+		draftId: z.string().min(1),
+		title: z.string().trim().min(1),
+		description: z.string().nullable(),
+		timezone: z.string().trim().min(1).nullable(),
+		locationValue: locationValueSchema.nullable().optional(),
+		addressJson: z.record(z.string(), z.unknown()).optional(),
+		locationJson: z.object({
+			lat: z.number(),
+			lng: z.number()
+		}).nullable().optional()
+	})
+]);
+const appointmentSetupPaymentDraftSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("free") }),
+	z.object({ kind: z.literal("paid_online") }),
+	z.object({ kind: z.literal("paid_offline") })
+]);
+const appointmentSetupServiceAssignmentDraftSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("all_practitioners") }), z.object({
+	kind: z.literal("selected_practitioners"),
+	resourceRefs: z.array(appointmentSetupRefSchema)
+})]);
+const appointmentSetupServiceDraftSchema = z.object({
+	ref: appointmentSetupRefSchema,
+	title: z.string().trim().min(1),
+	description: z.string().nullable(),
+	durationMinutes: z.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
+	prepMinutes: z.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+	cleanupMinutes: z.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+	priceAmount: z.number().int().nonnegative().nullable(),
+	isActive: z.boolean(),
+	visibility: z.enum(APPOINTMENT_SERVICE_VISIBILITY_VALUES).default("public"),
+	locationType: z.union([
+		z.literal("virtual"),
+		z.literal("in_person"),
+		z.literal("hybrid")
+	]),
+	venue: appointmentSetupVenueChoiceSchema,
+	timezone: z.string().trim().min(1).nullable(),
+	payment: appointmentSetupPaymentDraftSchema,
+	assignment: appointmentSetupServiceAssignmentDraftSchema,
+	categoryId: z.string().uuid().nullable().optional()
+}).superRefine((service, ctx) => {
+	if (service.payment.kind !== "free" && (service.priceAmount === null || service.priceAmount <= 0)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["priceAmount"],
+			message: "Paid appointment services need a positive price."
+		});
+	}
+	if (service.payment.kind === "free" && service.priceAmount !== null && service.priceAmount > 0) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["priceAmount"],
+			message: "Free appointment services cannot carry a positive price."
+		});
+	}
+});
+const appointmentSetupPractitionerDraftSchema = z.object({
+	ref: appointmentSetupRefSchema,
+	displayName: z.string().trim().min(1),
+	bio: z.string().nullable(),
+	timezone: z.string().trim().min(1),
+	colorHex: z.string().nullable()
+});
+const appointmentSetupWeeklyWindowDraftSchema = z.object({
+	weekday: z.number().int().min(0).max(6),
+	startTime: z.string(),
+	endTime: z.string()
+});
+const appointmentSetupStartTimePolicyDraftSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("automatic_spacing") }), z.object({
+	kind: z.literal("regular_interval"),
+	intervalMinutes: z.union([
+		z.literal(10),
+		z.literal(15),
+		z.literal(20),
+		z.literal(30),
+		z.literal(45),
+		z.literal(60)
+	])
+})]);
+const appointmentSetupAvailabilityDraftSchema = z.object({
+	kind: z.literal("weekly_windows"),
+	resourceRef: appointmentSetupRefSchema,
+	serviceRef: appointmentSetupRefSchema.nullable(),
+	windows: z.array(appointmentSetupWeeklyWindowDraftSchema),
+	startTimePolicy: appointmentSetupStartTimePolicyDraftSchema.optional()
+});
+/**
+* Upper bounds on the booking-notice fields. Site-wide defaults — these caps
+* keep the slot engine arithmetic (`now + minutes * 60_000`) well inside safe
+* integer range and surface UI typos rather than silently storing nonsense.
+*
+* - `MIN_LEAD` capped at 28 days. A "must book at least N minutes ahead"
+*   value beyond that reads as misconfiguration.
+* - `MAX_NOTICE` capped at 10 years. A reasonable ceiling for "how far in
+*   the future bookings may be made"; safe against overflow.
+*
+* Mirror these in `bookingSettingsSchema` (storage layer) and the wizard
+* draft schemas — single source of truth for the contract.
+*/
+const APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
+const APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
+const appointmentSetupBookingNoticeSchema = z.object({
+	minLeadMinutes: z.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+	maxBookingNoticeMinutes: z.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+});
+const applyAppointmentSetupRequestSchema = z.object({
+	services: z.array(appointmentSetupServiceDraftSchema),
+	practitioners: z.array(appointmentSetupPractitionerDraftSchema),
+	availability: z.array(appointmentSetupAvailabilityDraftSchema),
+	bookingNotice: appointmentSetupBookingNoticeSchema
+});
+async function getAppointmentSetupRequest(apiClient, siteId, options) {
+	try {
+		return unwrapResponse(await apiClient({
+			endpoint: "getAppointmentSetup",
+			params: { siteId },
+			options
+		}));
+	} catch (error) {
+		normalizeApiError(error, "Failed to load appointment setup");
+	}
+}
+async function applyAppointmentSetupRequest(apiClient, siteId, payload, options) {
+	try {
+		return unwrapResponse(await apiClient({
+			endpoint: "applyAppointmentSetup",
+			params: { siteId },
+			body: payload,
+			options
+		}));
+	} catch (error) {
+		normalizeApiError(error, "Failed to save appointment setup");
+	}
+}
+
+//#endregion
+//#region ../api/src/bookingConfig.ts
+/** Every option kind; the checkout routes validate the requested kind against it. */
+const DIRECT_CHECKOUT_COLLECTION_OPTION_KINDS = [
+	"upfront",
+	"deferred_manual",
+	"instalment_plan",
+	"flexible_balance"
+];
+const eventOccurrenceRestorationSummarySchema = z.object({
+	restoredOccurrenceIds: z.array(z.string().uuid()),
+	excludedBookings: z.array(z.object({
+		attendeeId: z.string().uuid(),
+		occurrenceId: z.string().uuid(),
+		customerId: z.string().uuid(),
+		customerName: z.string().nullable(),
+		customerEmail: z.string().nullable()
+	}))
+});
+const DEFAULT_BOOKING_NOTIFICATION_SEND_RULE = {
+	kind: "send",
+	sendToAssignedStaff: true,
+	extraEmail: null,
+	sendToSiteOwnerIfNoStaff: true
+};
 const DEFAULT_BOOKING_NOTIFICATION_SETTINGS = {
 	state: "configured",
 	defaultRule: DEFAULT_BOOKING_NOTIFICATION_SEND_RULE,
@@ -11854,59 +12249,2311 @@ function paginateItems(items, options) {
 		}
 	};
 }
-function mapPulledPage(page) {
-	return {
-		id: page.id,
-		identifier: page.identifier,
-		title: page.title,
-		...page.seoTitle !== undefined ? { seoTitle: page.seoTitle } : {},
-		...page.seoDescription !== undefined ? { seoDescription: page.seoDescription } : {},
-		path: page.path,
-		status: page.status,
-		hasUnpublishedChanges: page.hasUnpublishedChanges,
-		createdAt: page.createdAt,
-		updatedAt: page.updatedAt,
-		publishedAt: page.publishedAt
-	};
+function mapPulledPage(page) {
+	return {
+		id: page.id,
+		identifier: page.identifier,
+		title: page.title,
+		...page.seoTitle !== undefined ? { seoTitle: page.seoTitle } : {},
+		...page.seoDescription !== undefined ? { seoDescription: page.seoDescription } : {},
+		path: page.path,
+		status: page.status,
+		hasUnpublishedChanges: page.hasUnpublishedChanges,
+		createdAt: page.createdAt,
+		updatedAt: page.updatedAt,
+		publishedAt: page.publishedAt
+	};
+}
+function createPageOperations(http) {
+	async function upsert(input) {
+		if (input.publication === "publish") {
+			return sdkUpsertPagePublishResponseSchema.parse(await http.post("/pages", input, "write"));
+		}
+		return sdkUpsertPageDraftResponseSchema.parse(await http.post("/pages", input, "write"));
+	}
+	return {
+		async list(options) {
+			const result = await http.get("/pull/pages");
+			return paginateItems(result.pages.map(mapPulledPage), options);
+		},
+		async get(identifier) {
+			const result = await http.get("/pull/pages");
+			const page = result.pages.find((entry) => entry.identifier === identifier);
+			return page ? mapPulledPage(page) : null;
+		},
+		upsert,
+		async publish(identifier) {
+			return http.post(`/pages/${encodeURIComponent(identifier)}/publish`, undefined, "write");
+		},
+		async unpublish(identifier) {
+			return http.post(`/pages/${encodeURIComponent(identifier)}/unpublish`, undefined, "write");
+		},
+		async delete(identifier) {
+			return http.delete(`/pages/${encodeURIComponent(identifier)}`);
+		},
+		async getDesign(identifier) {
+			return http.getValidated(designPath(identifier), sdkGetPageDesignResponseSchema);
+		},
+		async saveDesign(identifier, design, expectedRevision) {
+			return http.postValidated(designPath(identifier), sdkSavePageDesignResponseSchema, {
+				design,
+				expectedRevision
+			}, "write");
+		}
+	};
+}
+
+//#endregion
+//#region ../theme-core/src/footer/mode.ts
+const footerModeSchema = z.enum([
+	"default",
+	"blocks",
+	"default+blocks",
+	"none"
+]);
+/** Reads only SDK footer intent; unrelated config and theme fields are not authorities. */
+function resolveSdkFooterMode(config) {
+	const parsed = z.object({ layout: z.object({ footerMode: footerModeSchema.optional() }).optional() }).safeParse(config);
+	return parsed.success ? parsed.data.layout?.footerMode ?? "default" : "default";
+}
+const legacyFooterBrandSchema = z.object({
+	variant: z.enum([
+		"simple",
+		"columns",
+		"split",
+		"centred"
+	]),
+	showLogoText: z.boolean().optional(),
+	logo: z.object({
+		showLogo: z.boolean().optional(),
+		showLogoText: z.boolean().optional()
+	}).optional()
+});
+/** Offline composition backfill only. Never read appearance visibility at runtime. */
+function readLegacyFooterBrandVisibility(value) {
+	const parsed = legacyFooterBrandSchema.safeParse(value);
+	if (!parsed.success) return null;
+	const footer = parsed.data;
+	return {
+		showLogo: footer.variant === "simple" ? footer.logo?.showLogo === true : footer.logo?.showLogo !== false,
+		showTitle: footer.logo?.showLogoText ?? footer.showLogoText === true
+	};
+}
+/**
+* Resolve what to render for the footer given the current mode and whether the
+* site is SDK-managed.
+*
+* Backwards compatible: missing/undefined mode is treated as 'default'.
+*/
+function resolveFooterRenderPlan(params) {
+	if (!params.isSdkSite) {
+		return {
+			mode: "default",
+			renderDefaultFooter: true,
+			renderFooterBlocks: false
+		};
+	}
+	const mode = params.mode ?? "default";
+	switch (mode) {
+		case "blocks": return {
+			mode: "blocks",
+			renderDefaultFooter: false,
+			renderFooterBlocks: true
+		};
+		case "default+blocks": return {
+			mode: "default+blocks",
+			renderDefaultFooter: true,
+			renderFooterBlocks: true
+		};
+		case "none": return {
+			mode: "none",
+			renderDefaultFooter: false,
+			renderFooterBlocks: false
+		};
+		case "default":
+		default: return {
+			mode: "default",
+			renderDefaultFooter: true,
+			renderFooterBlocks: false
+		};
+	}
+}
+
+//#endregion
+//#region ../blocks/src/system/node/schema.ts
+const transformStepSchema = z.object({
+	id: z.string().min(1, "Transform requires an identifier"),
+	options: z.record(z.string(), z.unknown()).optional()
+});
+const bindingPathSchema = z.string().min(1, "Binding path is required").regex(/[A-Za-z0-9_\.$\[\]/-]+/, "Binding path contains invalid characters");
+const bindingSchema = z.object({
+	from: bindingPathSchema,
+	fallback: z.unknown().optional(),
+	transforms: transformStepSchema.array().default([]),
+	pick: z.enum([
+		"value",
+		"collection",
+		"context"
+	]).default("value"),
+	coerce: z.enum([
+		"number",
+		"boolean",
+		"string"
+	]).optional()
+});
+const repeatSchema = z.object({
+	collection: bindingSchema,
+	itemName: z.string().min(1).default("item"),
+	indexName: z.string().min(1).default("index"),
+	limit: z.number().int().positive().optional(),
+	sortBy: z.object({
+		path: bindingPathSchema,
+		direction: z.enum(["asc", "desc"]).default("asc")
+	}).optional()
+});
+const conditionalAuthoringPresenceSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("visitor-only") }), z.object({
+	kind: z.literal("recover-empty-when-active"),
+	placeholder: z.string().min(1).optional()
+})]);
+const conditionSchema = z.object({
+	when: bindingSchema,
+	equals: z.unknown().optional(),
+	not: z.boolean().default(false),
+	authoringPresence: conditionalAuthoringPresenceSchema.default({ kind: "visitor-only" })
+});
+const dataScopeSchema = z.object({
+	name: z.string().min(1),
+	from: bindingSchema
+});
+const nodePropsSchema = z.record(z.string(), z.unknown()).default({});
+const nodeSchema = z.object({
+	type: z.string().min(1, "Node type is required"),
+	key: z.string().optional(),
+	props: nodePropsSchema.optional(),
+	children: z.lazy(() => nodeSchema.array().default([])).optional(),
+	$bind: bindingSchema.optional(),
+	$repeat: repeatSchema.optional(),
+	$when: conditionSchema.optional(),
+	$scopes: dataScopeSchema.array().optional()
+});
+const nodeTreeSchema = nodeSchema.array().or(nodeSchema);
+const NodeSchema = nodeSchema;
+const NodeTreeSchema = nodeTreeSchema;
+
+//#endregion
+//#region ../blocks/src/system/data/loaderEndpoints.ts
+const SUPPORTED_LOADER_ENDPOINTS = [
+	"listPublishedEntries",
+	"getPublishedEntryPreview",
+	"listPublicEvents",
+	"listPublicEventCalendarWindow",
+	"listPublicRecurringSchedule",
+	"getPublicEventDetails",
+	"listPublicRouteCandidates",
+	"listPublicTeamMembers",
+	"listPublicProducts",
+	"listPublicPasses",
+	"listPublicMemberships",
+	"getPublicFormById",
+	"getPublicBookingServices",
+	"getPublicWeeklySlotAvailability"
+];
+function isSupportedLoaderEndpoint(endpoint) {
+	return SUPPORTED_LOADER_ENDPOINTS.includes(endpoint);
+}
+
+//#endregion
+//#region ../blocks/src/system/constants/blockKinds.ts
+const EVENT_DISPLAY_BLOCK_KINDS = [
+	"block.event-details",
+	"block.event-spotlight",
+	"block.event-listing",
+	"block.event-calendar",
+	"block.recurring-schedule",
+	"block.offerings-preview"
+];
+const SYSTEM_BLOCK_KINDS = [
+	"block.hero",
+	"block.intro",
+	"block.columns",
+	"block.collection",
+	"block.feature-cards",
+	"block.media-text",
+	"block.cta-full",
+	"block.single-button",
+	"block.body-text",
+	"block.location-map",
+	"block.faq",
+	"block.testimonials",
+	"block.team-members",
+	"block.embed",
+	"block.blog-post",
+	"block.blog-listing",
+	"block.site-header",
+	"block.site-footer",
+	"block.form",
+	"block.contact-newsletter",
+	"block.appointment-booking",
+	"block.appointment-services",
+	"block.weekly-slot-availability",
+	"block.event-registration",
+	...EVENT_DISPLAY_BLOCK_KINDS,
+	"block.shop",
+	"block.product-list",
+	"block.product-detail",
+	"block.cart",
+	"block.checkout",
+	"block.gifting",
+	"block.newsletter-signup",
+	"block.image-gallery",
+	"block.video-grid",
+	"block.audio-player",
+	"block.file-download"
+];
+
+//#endregion
+//#region ../blocks/src/system/node/typeBasedLayout.ts
+/**
+* Creates conditional layout branches based on item type.
+* Used for polymorphic repeaters where each item type has a different layout.
+*
+* @param itemTypesMap - Map of type IDs to their layout definitions
+* @param options - Configuration options
+* @returns Array of conditional node definitions
+*
+* @example
+* ```typescript
+* // In a repeater with items: [{_type: 'card', ...}, {_type: 'quote', ...}]
+* const children = typeBasedLayout({
+*   card: stack({}, [
+*     text({ as: 'h3' }, bind('item.title')),
+*     richText({}, bind('item.body'))
+*   ]),
+*   quote: stack({}, [
+*     richText({}, bind('item.text')),
+*     text({ className: 'author' }, bind('item.author'))
+*   ])
+* }, { itemName: 'item' });
+* ```
+*/
+function typeBasedLayout(itemTypesMap, options) {
+	const itemName = options?.itemName ?? "item";
+	const result = Object.entries(itemTypesMap).map(([typeId, layout]) => {
+		const node = Array.isArray(layout) ? layout.length === 0 ? {
+			type: "div",
+			children: []
+		} : layout.length === 1 ? layout[0] ?? {
+			type: "div",
+			children: []
+		} : {
+			type: "div",
+			children: layout
+		} : layout;
+		return {
+			...node,
+			$when: {
+				when: { from: `${itemName}._type` },
+				equals: typeId
+			}
+		};
+	});
+	return result;
+}
+
+//#endregion
+//#region ../blocks/src/system/node/validation-constants.ts
+/**
+* Constants for validating declarative node layouts.
+*
+* These whitelists define which node types and transform IDs
+* are allowed in custom block layouts.
+*/
+/**
+* Valid node types for declarative layouts.
+*
+* This whitelist defines which component types can be used in
+* SdkCustomBlock.layout definitions. Node types not in this list
+* will be rejected during validation.
+*/
+const ALLOWED_NODE_TYPES = [
+	"div",
+	"figure",
+	"section",
+	"headerSection",
+	"stack",
+	"inline",
+	"grid",
+	"text",
+	"richText",
+	"media",
+	"videoEmbed",
+	"icon",
+	"feature-card-icon",
+	"svg",
+	"button",
+	"link",
+	"carousel",
+	"accordion",
+	"accordionItem",
+	"form",
+	"booking-form",
+	"weekly-slot-availability",
+	"event-registration",
+	"event-spotlight",
+	"event-listing",
+	"event-calendar",
+	"offerings-preview",
+	"event-combined",
+	"shop",
+	"product-list",
+	"product-detail",
+	"cart",
+	"checkout",
+	"gifting"
+];
+/**
+* Valid transform IDs for declarative layouts.
+*
+* This whitelist defines which transforms can be referenced in
+* $bind.transforms within custom block layouts. Transform IDs
+* not in this list will be rejected during validation.
+*/
+const ALLOWED_TRANSFORM_IDS = [
+	"string.uppercase",
+	"value.fallback",
+	"date.formatShort",
+	"array.length",
+	"value.jsonArray",
+	"value.csv",
+	"array.marqueeLoop",
+	"value.mapToken",
+	"layout.maxWidthClass",
+	"layout.headerRootClass",
+	"layout.footerRootClass",
+	"layout.headerRootStyle",
+	"layout.headerSectionBackground",
+	"layout.footerRootStyle",
+	"ui.headerNavLinkClass",
+	"ui.headingClassFromAlignment",
+	"ui.bodyClassFromAlignment",
+	"ui.stackAlignFromAlignment",
+	"ui.sectionStateTone",
+	"ui.heroContentWrapperClass",
+	"ui.heroCtaJustify",
+	"ui.heroStackJustifyFromVerticalAlignment",
+	"ui.heroGridClassFromVerticalAlignment",
+	"ui.conditionalClass",
+	"ui.twoColumnContainerClass",
+	"ui.twoColumnFlexBasis",
+	"ui.imageGalleryFilterClass",
+	"ui.imageGalleryTileClass",
+	"ui.imageGalleryTileStyle",
+	"ui.imageGalleryMarqueeTileStyle",
+	"ui.imageGalleryMarqueeDuration",
+	"ui.imageGalleryMarqueeDirection",
+	"ui.imageFragmentClass",
+	"ui.imageFragmentSize",
+	"media.fromUrl",
+	"background.resolveStyle",
+	"background.resolveColorsStyle",
+	"background.resolveFrameClassName",
+	"background.resolveImageStyle",
+	"background.resolveImageClassName",
+	"background.resolveOverlayStyle",
+	"links.resolve",
+	"links.label",
+	"content.interpolateRichTextTokens",
+	"boxStyles.spacing",
+	"boxStyles.resolveRootClass",
+	"boxStyles.resolveRootStyle",
+	"boxStyles.semanticGap",
+	"boxStyles.semanticGapValue",
+	"containerStyles.resolveBoxClassName"
+];
+/**
+* Set for O(1) lookup of allowed node types.
+*/
+const ALLOWED_NODE_TYPES_SET = new Set(ALLOWED_NODE_TYPES);
+/**
+* Set for O(1) lookup of allowed transform IDs.
+*/
+const ALLOWED_TRANSFORM_IDS_SET = new Set(ALLOWED_TRANSFORM_IDS);
+/**
+* Check if a node type is allowed in layouts.
+*/
+function isAllowedNodeType(type) {
+	return ALLOWED_NODE_TYPES_SET.has(type);
+}
+/**
+* Check if a transform ID is allowed in layouts.
+*/
+function isAllowedTransformId(id) {
+	return ALLOWED_TRANSFORM_IDS_SET.has(id);
+}
+
+//#endregion
+//#region ../blocks/src/system/layout/repeaterGridModel.ts
+const DEFAULT_REPEATER_GRID_SPAN_FIELD_ID = "gridSpan";
+const DEFAULT_REPEATER_GRID_ROW_FIELD_ID = "gridRow";
+const DEFAULT_REPEATER_GRID_COLUMN_FIELD_ID = "gridColumn";
+const MIN_COLUMNS = 1;
+const MAX_REPEATER_GRID_COLUMNS = 6;
+const MAX_COLUMNS = MAX_REPEATER_GRID_COLUMNS;
+function normalizeInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return Math.trunc(value);
+	}
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return null;
+		const parsed = Number(trimmed);
+		if (!Number.isFinite(parsed)) return null;
+		return Math.trunc(parsed);
+	}
+	return null;
+}
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+function asNonEmptyString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function resolveRepeaterGridSpanFieldId(options) {
+	return asNonEmptyString(options?.id) ?? DEFAULT_REPEATER_GRID_SPAN_FIELD_ID;
+}
+function resolveRepeaterGridRowFieldId(options) {
+	return asNonEmptyString(options?.id) ?? DEFAULT_REPEATER_GRID_ROW_FIELD_ID;
+}
+function resolveRepeaterGridColumnFieldId(options) {
+	return asNonEmptyString(options?.id) ?? DEFAULT_REPEATER_GRID_COLUMN_FIELD_ID;
+}
+function getBreakpointFallbackOrder(breakpoint) {
+	if (breakpoint === "xl") return [
+		"xl",
+		"lg",
+		"md",
+		"sm",
+		"base"
+	];
+	if (breakpoint === "lg") return [
+		"lg",
+		"md",
+		"sm",
+		"base"
+	];
+	if (breakpoint === "md") return [
+		"md",
+		"sm",
+		"base",
+		"lg"
+	];
+	if (breakpoint === "sm") return [
+		"sm",
+		"base",
+		"lg"
+	];
+	return ["base", "lg"];
+}
+function resolveRepeaterGridBreakpointForWidth(width) {
+	if (!Number.isFinite(width)) {
+		return "lg";
+	}
+	if (width >= BREAKPOINT_XL) return "xl";
+	if (width >= BREAKPOINT_LG) return "lg";
+	if (width >= BREAKPOINT_MD) return "md";
+	if (width >= BREAKPOINT_SM) return "sm";
+	return "base";
+}
+function createRepeaterGridSpanField(options) {
+	const fieldId = resolveRepeaterGridSpanFieldId(options);
+	const label = asNonEmptyString(options?.label) ?? "Grid span";
+	const description = asNonEmptyString(options?.description) ?? "Columns occupied by this item in layout-grid mode.";
+	const defaultSpan = clamp(normalizeRepeaterGridColumns(options?.defaultSpan ?? 1), 1, 4);
+	return {
+		id: fieldId,
+		type: "select",
+		label,
+		description,
+		options: [
+			{
+				value: "1",
+				label: "1 column"
+			},
+			{
+				value: "2",
+				label: "2 columns"
+			},
+			{
+				value: "3",
+				label: "3 columns"
+			},
+			{
+				value: "4",
+				label: "4 columns"
+			}
+		],
+		defaultValue: String(defaultSpan)
+	};
+}
+function createRepeaterGridRowField(options) {
+	const fieldId = resolveRepeaterGridRowFieldId(options);
+	const label = asNonEmptyString(options?.label) ?? "Grid row";
+	const description = asNonEmptyString(options?.description) ?? "Manual layout row for this item.";
+	const defaultRow = normalizeRepeaterGridRow(options?.defaultRow ?? 1);
+	return {
+		id: fieldId,
+		type: "number",
+		label,
+		description,
+		defaultValue: defaultRow,
+		ui: { hidden: true }
+	};
+}
+function createRepeaterGridColumnField(options) {
+	const fieldId = resolveRepeaterGridColumnFieldId(options);
+	const label = asNonEmptyString(options?.label) ?? "Grid column";
+	const description = asNonEmptyString(options?.description) ?? "Manual layout starting column for this item.";
+	const defaultColumn = normalizeRepeaterGridColumns(options?.defaultColumn ?? 1);
+	return {
+		id: fieldId,
+		type: "number",
+		label,
+		description,
+		defaultValue: defaultColumn,
+		ui: { hidden: true }
+	};
+}
+function withRepeaterGridSpanField(fields, options) {
+	const spanFieldId = resolveRepeaterGridSpanFieldId(options);
+	if (fields.some((field) => field.id === spanFieldId)) {
+		return [...fields];
+	}
+	return [createRepeaterGridSpanField(options), ...fields];
+}
+function withRepeaterGridPositionFields(fields, options) {
+	const rowFieldId = resolveRepeaterGridRowFieldId(options?.row);
+	const withRow = fields.some((field) => field.id === rowFieldId) ? [...fields] : [createRepeaterGridRowField(options?.row), ...fields];
+	const columnFieldId = resolveRepeaterGridColumnFieldId(options?.column);
+	return withRow.some((field) => field.id === columnFieldId) ? withRow : [createRepeaterGridColumnField(options?.column), ...withRow];
+}
+function withRepeaterGridSpanFieldOnItemTypes(itemTypes, options) {
+	const entries = Object.entries(itemTypes).map(([typeKey, itemType]) => {
+		const nextFields = withRepeaterGridSpanField(itemType.fields, options);
+		return [typeKey, {
+			...itemType,
+			fields: nextFields
+		}];
+	});
+	return Object.fromEntries(entries);
+}
+function withRepeaterGridPositionFieldsOnItemTypes(itemTypes, options) {
+	const entries = Object.entries(itemTypes).map(([typeKey, itemType]) => {
+		const nextFields = withRepeaterGridPositionFields(itemType.fields, options);
+		return [typeKey, {
+			...itemType,
+			fields: nextFields
+		}];
+	});
+	return Object.fromEntries(entries);
+}
+function normalizeRepeaterGridColumns(value) {
+	const parsed = normalizeInteger(value);
+	if (parsed == null) {
+		return MIN_COLUMNS;
+	}
+	return clamp(parsed, MIN_COLUMNS, MAX_COLUMNS);
+}
+function normalizeRepeaterGridRow(value) {
+	const parsed = normalizeInteger(value);
+	if (parsed == null) {
+		return 1;
+	}
+	return Math.max(1, parsed);
+}
+function resolveRepeaterGridColumnsForBreakpoint(values, bindings, breakpoint) {
+	const order = getBreakpointFallbackOrder(breakpoint);
+	for (const candidate of order) {
+		const fieldId = asNonEmptyString(bindings[candidate]);
+		if (!fieldId) continue;
+		const resolved = normalizeInteger(values[fieldId]);
+		if (resolved == null) continue;
+		return clamp(resolved, MIN_COLUMNS, MAX_COLUMNS);
+	}
+	return MIN_COLUMNS;
+}
+/** Strict admission; rendering normalization never grants permission to persist. */
+function parseRepeaterGridInteger(value) {
+	if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) return null;
+	const number = Number(value);
+	return Number.isInteger(number) ? number : null;
+}
+function isAcceptedRepeaterGridSpan(value, columns, acceptedSpans) {
+	const span = parseRepeaterGridInteger(value);
+	return span != null && span >= 1 && span <= columns && (!acceptedSpans || acceptedSpans.includes(span));
+}
+function resolveRepeaterGridAcceptedSpans(fields, spanField) {
+	const field = fields.find((candidate) => candidate.id === spanField);
+	return field?.type === "select" ? (field.options ?? []).map((option) => Number(option.value)) : undefined;
+}
+function normalizeRepeaterGridSpan(value, activeColumns, acceptedSpans) {
+	if (acceptedSpans) {
+		const valid = acceptedSpans.filter((span) => span <= activeColumns);
+		const parsed$1 = parseRepeaterGridInteger(value);
+		return parsed$1 != null && valid.includes(parsed$1) ? parsed$1 : valid.length ? Math.min(...valid) : 1;
+	}
+	const parsed = normalizeInteger(value);
+	if (parsed == null) {
+		return 1;
+	}
+	return clamp(parsed, 1, Math.max(1, activeColumns));
+}
+function normalizeRepeaterGridColStart(value, activeColumns, span) {
+	const parsed = normalizeInteger(value);
+	const normalizedColumns = Math.max(1, activeColumns);
+	const normalizedSpan = clamp(span, 1, normalizedColumns);
+	const maxColStart = Math.max(1, normalizedColumns - normalizedSpan + 1);
+	if (parsed == null) {
+		return 1;
+	}
+	return clamp(parsed, 1, maxColStart);
+}
+function deriveRepeaterGridMaxRowsForBreakpoint(input) {
+	const { desktopColumns, desktopMaxRows, activeColumns } = input;
+	if (desktopMaxRows == null) {
+		return undefined;
+	}
+	const normalizedDesktopColumns = Math.max(1, desktopColumns);
+	const normalizedActiveColumns = Math.max(1, activeColumns);
+	const capacityCells = normalizedDesktopColumns * desktopMaxRows;
+	return Math.max(1, Math.ceil(capacityCells / normalizedActiveColumns));
+}
+function toRowCellKey(row, col, columns) {
+	return (row - 1) * columns + col;
+}
+function buildPlacementCells(placement) {
+	return Array.from({ length: placement.span }, (_, index) => placement.colStart + index);
+}
+function buildOccupancyByCell(placements, columns) {
+	const entries = placements.flatMap((placement) => buildPlacementCells(placement).map((col) => [toRowCellKey(placement.row, col, columns), placement.id]));
+	const occupancy = entries.reduce((cells, [cell, id]) => new Map(cells).set(cell, new Set([...cells.get(cell) ?? [], id])), new Map());
+	return {
+		occupancy,
+		hasCollisions: Array.from(occupancy.values()).some((ids) => ids.size > 1)
+	};
+}
+function getOverlappingItemIds(input) {
+	return new Set(buildPlacementCells(input).flatMap((col) => Array.from(input.occupancy.get(toRowCellKey(input.row, col, input.columns)) ?? []).filter((id) => !input.excludedIds?.has(id))));
+}
+function normalizeInputItem(item, columns, sourceIndex) {
+	const span = normalizeRepeaterGridSpan(item.span, columns, item.acceptedSpans);
+	const row = normalizeRepeaterGridRow(item.row);
+	const colStart = normalizeRepeaterGridColStart(item.colStart, columns, span);
+	const colEnd = colStart + span - 1;
+	return {
+		id: item.id,
+		startNewRow: item.startNewRow,
+		acceptedSpans: item.acceptedSpans,
+		sourceIndex,
+		span,
+		row,
+		colStart,
+		colEnd,
+		startCell: toRowCellKey(row, colStart, columns)
+	};
+}
+/** Ordered, non-dense placement. Rendering clamps widths; admission checks originals separately. */
+function flowRepeaterGridItems(items, columns) {
+	const count = normalizeRepeaterGridColumns(columns);
+	return items.reduce((placed, item) => {
+		const span = normalizeRepeaterGridSpan(item.span, count);
+		const previous = placed.at(-1);
+		const nextColumn = previous ? previous.colStart + previous.span : 1;
+		const wraps = previous != null && (item.startNewRow === true || nextColumn + span - 1 > count);
+		return [...placed, {
+			...item,
+			span,
+			row: (previous?.row ?? 1) + (wraps ? 1 : 0),
+			colStart: wraps ? 1 : nextColumn
+		}];
+	}, []);
+}
+/** @internal */
+function orderedGridItems(layout) {
+	return [...layout.placements].sort((a, b) => a.sourceIndex - b.sourceIndex);
+}
+function isRepeaterGridLayoutInvalid(layout) {
+	return layout.hasInvalidItems || layout.hasCollisions || layout.overCapacity;
+}
+function hasInvalidGridItems(items, columns, policy) {
+	const flow = policy === "flow" ? flowRepeaterGridItems(items, columns) : null;
+	return items.some((item, index) => !isValidGridItemGeometry(item, columns) || flow != null && (item.row !== flow[index]?.row || item.colStart !== flow[index]?.colStart));
+}
+function isValidGridItemGeometry(item, columns) {
+	return isAcceptedRepeaterGridSpan(item.span, columns, item.acceptedSpans) && parseRepeaterGridInteger(item.row) != null && item.row >= 1 && parseRepeaterGridInteger(item.colStart) != null && item.colStart >= 1 && item.colStart + item.span - 1 <= columns;
+}
+function findFlowAppendPlacement(layout, span, startNewRow) {
+	const next = flowRepeaterGridItems([...orderedGridItems(layout), {
+		id: "new",
+		span,
+		row: 1,
+		colStart: 1,
+		startNewRow
+	}], layout.columns).at(-1);
+	return !isRepeaterGridLayoutInvalid(layout) && next && (layout.maxRows == null || next.row <= layout.maxRows) ? {
+		row: next.row,
+		colStart: next.colStart
+	} : null;
+}
+/** @internal */
+function planFlowItems(layout, items) {
+	const placed = flowRepeaterGridItems(items, layout.columns);
+	if (isRepeaterGridLayoutInvalid(layout) || placed.some((item) => !isAcceptedRepeaterGridSpan(item.span, layout.columns, item.acceptedSpans) || layout.maxRows != null && item.row > layout.maxRows)) return { kind: "blocked" };
+	const [first, ...rest] = placed.map(({ id, row, colStart, span }) => ({
+		id,
+		row,
+		colStart,
+		span
+	}));
+	return first ? {
+		kind: "move",
+		updates: [first, ...rest]
+	} : { kind: "unchanged" };
+}
+/** Insertion reorder, with a complete coordinate write for the resulting order. */
+function planRepeaterGridReorder(layout, id, to, interaction = "step") {
+	if (layout.placementPolicy !== "flow") return { kind: "blocked" };
+	const items = orderedGridItems(layout);
+	const from = items.findIndex((item) => item.id === id);
+	if (from < 0 || to < 0 || to >= items.length) return { kind: "blocked" };
+	if (from === to) return { kind: "unchanged" };
+	const active = items[from];
+	if (!active) return { kind: "blocked" };
+	return decideFlowReorder({
+		layout,
+		items,
+		active,
+		from,
+		to,
+		interaction
+	});
+}
+function decideFlowReorder(input) {
+	const { layout, items, active, from, to, interaction } = input;
+	const id = active.id;
+	const remaining = items.filter((item) => item.id !== id);
+	const inserted = [
+		...remaining.slice(0, to),
+		active,
+		...remaining.slice(to)
+	];
+	const clearRowBreak = interaction === "drag" && active.startNewRow === true && dragInsertsWithinRow(items, from, to, layout.columns);
+	const nextItems = clearRowBreak ? inserted.map((item) => item.id === id ? {
+		...item,
+		startNewRow: false
+	} : item) : inserted;
+	const decision = planFlowItems(layout, nextItems);
+	return decision.kind === "move" ? {
+		...decision,
+		reorder: {
+			id,
+			from,
+			to
+		},
+		...clearRowBreak ? { startNewRowUpdate: {
+			id,
+			value: false
+		} } : {}
+	} : decision;
+}
+/** Read the insertion bar position, independently of the dragged width. */
+function dragInsertsWithinRow(items, from, to, columns) {
+	const target = items[to];
+	if (!target) return false;
+	const column = from < to ? target.colEnd + 1 : target.colStart;
+	return column > 1 && column <= columns;
+}
+function planRepeaterGridStartNewRow(layout, id, value) {
+	const active = layout.byId[id];
+	if (layout.placementPolicy !== "flow" || !active) return { kind: "blocked" };
+	const decision = planFlowItems(layout, orderedGridItems(layout).map((item) => item.id === id ? {
+		...item,
+		startNewRow: value
+	} : item));
+	return decision.kind === "move" ? {
+		...decision,
+		startNewRowUpdate: {
+			id,
+			value
+		}
+	} : decision;
+}
+function buildRepeaterGridLayout(input) {
+	const columns = normalizeRepeaterGridColumns(input.columns);
+	const maxRows = input.maxRows != null ? Math.max(1, Math.trunc(input.maxRows)) : undefined;
+	const capacityCells = maxRows != null ? maxRows * columns : undefined;
+	const placements = input.items.map((item, sourceIndex) => normalizeInputItem(item, columns, sourceIndex)).sort((a, b) => {
+		if (a.row !== b.row) return a.row - b.row;
+		if (a.colStart !== b.colStart) return a.colStart - b.colStart;
+		return a.sourceIndex - b.sourceIndex;
+	});
+	const byId = Object.fromEntries(placements.map((placement) => [placement.id, placement]));
+	const maxRowUsed = placements.length > 0 ? Math.max(...placements.map((placement) => placement.row)) : 0;
+	const { hasCollisions } = buildOccupancyByCell(placements, columns);
+	const overCapacity = maxRows != null && maxRowUsed > maxRows;
+	return {
+		placementPolicy: input.placementPolicy,
+		sourceItems: input.items.map((item) => ({ ...item })),
+		columns,
+		maxRows,
+		capacityCells,
+		maxRowUsed,
+		overCapacity,
+		hasCollisions,
+		hasInvalidItems: hasInvalidGridItems(input.items, columns, input.placementPolicy),
+		placements,
+		byId
+	};
+}
+function findFirstAvailableRepeaterGridPlacement(input) {
+	const columns = normalizeRepeaterGridColumns(input.columns);
+	const maxRows = input.maxRows != null ? Math.max(1, Math.trunc(input.maxRows)) : undefined;
+	if (!isAcceptedRepeaterGridSpan(input.newItemSpan, columns, input.acceptedSpans)) return null;
+	const span = normalizeRepeaterGridSpan(input.newItemSpan, columns, input.acceptedSpans);
+	const layout = buildRepeaterGridLayout({
+		items: input.items,
+		columns,
+		maxRows,
+		placementPolicy: input.placementPolicy
+	});
+	if (input.placementPolicy === "flow") return findFlowAppendPlacement(layout, span, input.startNewRow);
+	const { occupancy } = buildOccupancyByCell(layout.placements, columns);
+	const rowLimit = maxRows ?? Math.max(1, layout.maxRowUsed + 1);
+	if (isRepeaterGridLayoutInvalid(layout)) return null;
+	const maxColStart = columns - span + 1;
+	return Array.from({ length: rowLimit * maxColStart }, (_, index) => ({
+		row: Math.floor(index / maxColStart) + 1,
+		colStart: index % maxColStart + 1
+	})).find(({ row, colStart }) => getOverlappingItemIds({
+		occupancy,
+		row,
+		colStart,
+		span,
+		columns
+	}).size === 0) ?? null;
+}
+function canAppendRepeaterGridItem(input) {
+	return findFirstAvailableRepeaterGridPlacement({
+		items: input.items,
+		newItemSpan: input.newItemSpan,
+		acceptedSpans: input.acceptedSpans,
+		columns: input.columns,
+		maxRows: input.maxRows
+	}) != null;
+}
+
+//#endregion
+//#region ../blocks/src/system/layout/repeaterGrid.ts
+function placementsOverlap(left, right) {
+	return left.row === right.row && left.colStart < right.colStart + right.span && right.colStart < left.colStart + left.span;
+}
+function swapPositionUpdates(active, target) {
+	const adjacent = active.row === target.row && (active.colEnd + 1 === target.colStart || target.colEnd + 1 === active.colStart);
+	const activeCol = adjacent && active.colStart < target.colStart ? active.colStart + target.span : target.colStart;
+	const targetCol = adjacent && target.colStart < active.colStart ? target.colStart + active.span : active.colStart;
+	return [{
+		id: active.id,
+		row: target.row,
+		colStart: activeCol,
+		span: active.span
+	}, {
+		id: target.id,
+		row: active.row,
+		colStart: targetCol,
+		span: target.span
+	}];
+}
+/** Admission retains raw authoring geometry; display-only callers may supply placements alone. */
+function sourceGridItems(layout) {
+	return layout.sourceItems ?? layout.placements;
+}
+/** Repair edits may remove existing defects, but cannot introduce another one. */
+function gridDefects(layout) {
+	const geometry = sourceGridItems(layout).flatMap((item) => [
+		...!isAcceptedRepeaterGridSpan(item.span, layout.columns, item.acceptedSpans) ? [`span:${item.id}`] : [],
+		...!Number.isInteger(item.row) || item.row < 1 ? [`row:${item.id}`] : [],
+		...!Number.isInteger(item.colStart) || item.colStart < 1 || item.colStart + item.span - 1 > layout.columns ? [`column:${item.id}`] : []
+	]);
+	const collisions = layout.placements.flatMap((item, index) => layout.placements.slice(index + 1).filter((other) => placementsOverlap(item, other)).map((other) => `collision:${[item.id, other.id].sort().join(":")}`));
+	const capacity = layout.placements.filter((item) => layout.maxRows != null && item.row > layout.maxRows).map((item) => `capacity:${item.id}`);
+	return new Set([
+		...geometry,
+		...collisions,
+		...capacity,
+		...(layout.invalidCoordinateIds ?? []).map((id) => `coordinate:${id}`)
+	]);
+}
+function validateGridMove(layout, updates) {
+	const items = sourceGridItems(layout).map((item) => ({
+		...item,
+		...updates.find((update) => update.id === item.id)
+	}));
+	const candidate = buildRepeaterGridLayout({
+		items,
+		columns: layout.columns,
+		maxRows: layout.maxRows,
+		placementPolicy: layout.placementPolicy
+	});
+	const unresolved = (layout.invalidCoordinateIds ?? []).filter((id) => !updates.some((update) => update.id === id));
+	const before = gridDefects(layout);
+	const after = gridDefects({
+		...candidate,
+		invalidCoordinateIds: unresolved
+	});
+	const valid = before.size === 0 ? after.size === 0 : after.size < before.size && [...after].every((defect) => before.has(defect));
+	return valid ? {
+		kind: "move",
+		updates
+	} : { kind: "blocked" };
+}
+function decideGridDrop(layout, active, destination) {
+	const occupants = layout.placements.filter((placement) => placement.id !== active.id && placement.row === destination.row && destination.colStart >= placement.colStart && destination.colStart <= placement.colEnd);
+	if (occupants.length > 1) return { kind: "blocked" };
+	const target = occupants[0];
+	if (target) return validateGridMove(layout, swapPositionUpdates(active, target));
+	if (destination.row === active.row && destination.colStart === active.colStart && !isRepeaterGridLayoutInvalid(layout)) return { kind: "unchanged" };
+	return validateGridMove(layout, [{
+		id: active.id,
+		row: destination.row,
+		colStart: destination.colStart,
+		span: active.span
+	}]);
+}
+function buildRepeaterGridDropTargets(input) {
+	const { layout, draggedId, rowsToRender } = input;
+	const active = layout.byId[draggedId];
+	if (!active || layout.placementPolicy === "flow" && isRepeaterGridLayoutInvalid(layout)) return [];
+	if (layout.placementPolicy === "flow") return orderedGridItems(layout).map((item, index) => ({
+		id: `repeater-grid-drop-${item.row}-${item.colStart}`,
+		row: item.row,
+		colStart: item.colStart,
+		cell: item.startCell,
+		decision: planRepeaterGridReorder(layout, draggedId, index, input.interaction ?? "drag")
+	}));
+	const rowCeiling = layout.maxRows ?? Math.max(1, rowsToRender ?? layout.maxRowUsed + 1, active.row + 1);
+	const targets = Array.from({ length: rowCeiling * layout.columns }, (_, index) => {
+		const row = Math.floor(index / layout.columns) + 1;
+		const colStart = index % layout.columns + 1;
+		return {
+			id: `repeater-grid-drop-${row}-${colStart}`,
+			row,
+			colStart,
+			cell: index + 1,
+			decision: decideGridDrop(layout, active, {
+				row,
+				colStart
+			})
+		};
+	});
+	return targets.some((target) => target.row === active.row && target.colStart === active.colStart) ? targets : [...targets, {
+		id: `repeater-grid-drop-${active.row}-${active.colStart}`,
+		row: active.row,
+		colStart: active.colStart,
+		cell: active.startCell,
+		decision: { kind: "unchanged" }
+	}];
+}
+/** Width edits keep the item's start when it fits; otherwise relocate it to the first free cell.
+* Neighbours keep their positions. A full bounded grid blocks the change without partial writes.
+*/
+function planRepeaterGridSpanChange(input) {
+	const { layout, id, span } = input;
+	const active = layout.byId[id];
+	if (layout.placementPolicy === "flow" && isRepeaterGridLayoutInvalid(layout)) return { kind: "blocked" };
+	if (!active || !isAcceptedRepeaterGridSpan(span, layout.columns, active.acceptedSpans)) return { kind: "blocked" };
+	const nextSpan = Number(span);
+	if (!isRepeaterGridLayoutInvalid(layout) && sourceGridItems(layout).find((item) => item.id === id)?.span === nextSpan) return { kind: "unchanged" };
+	if (layout.placementPolicy === "flow") return planFlowItems(layout, orderedGridItems(layout).map((item) => item.id === id ? {
+		...item,
+		span: nextSpan
+	} : item));
+	return planFreeGridSpanChange(layout, active, nextSpan);
+}
+/** Free width edits retain the current start when possible, then use the shared first-free planner. */
+function planFreeGridSpanChange(layout, active, nextSpan) {
+	const id = active.id;
+	const atCurrent = validateGridMove(layout, [{
+		id,
+		span: nextSpan,
+		row: active.row,
+		colStart: active.colStart
+	}]);
+	if (atCurrent.kind === "move") return atCurrent;
+	const destination = findFirstAvailableRepeaterGridPlacement({
+		items: layout.placements.filter((item) => item.id !== id),
+		newItemSpan: nextSpan,
+		acceptedSpans: active.acceptedSpans,
+		columns: layout.columns,
+		maxRows: layout.maxRows
+	});
+	return destination ? validateGridMove(layout, [{
+		id,
+		span: nextSpan,
+		...destination
+	}]) : { kind: "blocked" };
+}
+/** Narrow rendering is a projection only. Never feed these placements into an authoring write. */
+function projectRepeaterGridLayout(layout, columns) {
+	if (isRepeaterGridLayoutInvalid(layout)) return projectRepeaterGridLayoutForRendering(layout, columns);
+	if (columns === layout.columns) return layout;
+	if (layout.placementPolicy === "flow") return buildProjectedRepeaterGridLayout(layout, flowRepeaterGridItems(orderedGridItems(layout), columns), columns);
+	const items = layout.placements.reduce((placed, item) => {
+		const span = normalizeRepeaterGridSpan(item.span, columns);
+		const destination = findFirstAvailableRepeaterGridPlacement({
+			items: placed,
+			newItemSpan: span,
+			columns
+		});
+		return [...placed, {
+			id: item.id,
+			span,
+			row: destination?.row ?? placed.length + 1,
+			colStart: destination?.colStart ?? 1
+		}];
+	}, []);
+	return buildProjectedRepeaterGridLayout(layout, items, columns);
+}
+function buildProjectedRepeaterGridLayout(source, items, columns) {
+	const projected = buildRepeaterGridLayout({
+		items: items.map(({ id, span, row, colStart, startNewRow }) => ({
+			id,
+			span,
+			row,
+			colStart,
+			startNewRow
+		})),
+		columns,
+		placementPolicy: source.placementPolicy === "flow" || isRepeaterGridLayoutInvalid(source) ? "flow" : source.placementPolicy
+	});
+	const placements = projected.placements.map((item) => ({
+		...item,
+		sourceIndex: source.byId[item.id]?.sourceIndex ?? item.sourceIndex
+	}));
+	return {
+		...projected,
+		placements,
+		byId: Object.fromEntries(placements.map((item) => [item.id, item]))
+	};
+}
+/** Public fallback: preserve saved array order, use non-dense auto-placement, and ignore authoring capacity. */
+function projectRepeaterGridLayoutForRendering(layout, columns = layout.columns) {
+	if (!isRepeaterGridLayoutInvalid(layout)) {
+		return projectRepeaterGridLayout(layout, columns);
+	}
+	const count = normalizeRepeaterGridColumns(columns);
+	return buildProjectedRepeaterGridLayout(layout, flowRepeaterGridItems(orderedGridItems(layout), count), count);
+}
+/** An explicit column reduction re-places free grids through the existing placement primitive. */
+function planRepeaterGridColumnChange(layout, columns) {
+	if (layout.placementPolicy === "flow" || columns >= layout.columns) return { kind: "unchanged" };
+	if (isRepeaterGridLayoutInvalid(layout)) return { kind: "blocked" };
+	const placed = orderedGridItems(layout).reduce((items, item) => {
+		if (!items) return null;
+		const bounded = normalizeRepeaterGridSpan(item.span, columns);
+		const span = item.acceptedSpans ? Math.max(0, ...item.acceptedSpans.filter((width) => width <= bounded)) : bounded;
+		const destination = findFirstAvailableRepeaterGridPlacement({
+			items,
+			columns,
+			maxRows: layout.maxRows,
+			newItemSpan: span,
+			acceptedSpans: item.acceptedSpans
+		});
+		return destination ? [...items, {
+			...item,
+			span,
+			...destination
+		}] : null;
+	}, []);
+	const [first, ...rest] = placed ?? [];
+	return first ? {
+		kind: "move",
+		updates: [first, ...rest]
+	} : placed ? { kind: "unchanged" } : { kind: "blocked" };
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/layoutGridConfiguration.ts
+const itemFieldsSchema = z.object({ fields: z.array(z.object({
+	id: z.string(),
+	type: z.string(),
+	defaultValue: z.unknown().optional(),
+	options: z.array(z.object({ value: z.string() })).optional(),
+	multiple: z.boolean().optional(),
+	source: z.object({ kind: z.string() }).optional()
+})) });
+function validateSpanSelect(span, columns, ctx) {
+	if (span.type !== "select") return;
+	const options = span.options ?? [];
+	const invalidOptions = options.some((option) => !isAcceptedRepeaterGridSpan(option.value, columns) || String(Number(option.value)) !== option.value);
+	if (span.multiple || options.length === 0 || invalidOptions || span.source && span.source.kind !== "static") {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridSpanField"],
+			message: `Layout-grid span select must have single, static integer options within 1..${columns}`
+		});
+	}
+	if (span.defaultValue !== undefined && !options.some((option) => option.value === span.defaultValue)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridSpanField"],
+			message: "Layout-grid default span must be one of the span select options"
+		});
+	}
+}
+/** Both monomorphic and polymorphic item schemas have the same layout contract. */
+function validateLayoutGridConfiguration(data, ctx) {
+	const ui = data.ui;
+	if (ui?.repeaterPreset !== "layoutGrid") return;
+	if (ui.layoutGridColumns !== undefined === (ui.layoutGridColumnsFields !== undefined)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridColumns"],
+			message: "Layout-grid requires exactly one of ui.layoutGridColumns or ui.layoutGridColumnsFields.lg; do not set both"
+		});
+	}
+	const spanId = resolveRepeaterGridSpanFieldId({ id: ui.layoutGridSpanField });
+	const requiredIds = [
+		spanId,
+		resolveRepeaterGridRowFieldId({ id: ui.layoutGridRowField }),
+		resolveRepeaterGridColumnFieldId({ id: ui.layoutGridColumnField })
+	];
+	const schemas = data.polymorphic && data.itemTypes ? Object.values(data.itemTypes) : [data.schema];
+	schemas.forEach((schema) => {
+		const parsed = itemFieldsSchema.safeParse(schema);
+		if (!parsed.success) return;
+		if (!requiredIds.every((id) => parsed.data.fields.some((field) => field.id === id))) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridRowField"],
+				message: `layoutGrid repeaters require span/row/column fields (${requiredIds.join(", ")}) to exist in repeater item fields`
+			});
+		}
+		if (ui.layoutGridStartNewRowField && !parsed.data.fields.some((field) => field.id === ui.layoutGridStartNewRowField && field.type === "boolean")) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridStartNewRowField"],
+				message: "Layout-grid Start a new row field must reference a boolean item field"
+			});
+		}
+		if (ui.layoutGridStartNewRowField && ui.layoutGridColumns === undefined) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridStartNewRowField"],
+				message: "Layout-grid Start a new row requires fixed columns (flow placement)"
+			});
+		}
+		parsed.data.fields.filter((field) => field.id === spanId).forEach((span) => validateSpanSelect(span, ui.layoutGridColumns ?? MAX_REPEATER_GRID_COLUMNS, ctx));
+	});
+}
+
+//#endregion
+//#region ../blocks/src/system/icons/presets.ts
+const ICON_PICKER_PRESETS = ["cta", "feature"];
+function isIconPickerPreset(value) {
+	return typeof value === "string" && ICON_PICKER_PRESETS.includes(value);
+}
+function resolveIconPickerPreset(value) {
+	return isIconPickerPreset(value) ? value : "cta";
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/sdkBlockPresentationSchema.ts
+const sdkBlockPresentationShape = {
+	variants: z.record(z.string().min(1), NodeSchema).optional(),
+	defaultVariant: z.string().min(1).optional(),
+	variantOptions: z.record(z.string().min(1), z.object({
+		label: z.string().min(1).optional(),
+		description: z.string().min(1).optional(),
+		icon: z.string().min(1).optional()
+	})).optional()
+};
+function validateSdkBlockDeclaration(data, ctx) {
+	validateTitleSource(data, ctx);
+	if (data.layout && data.variants) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Custom block must define either `layout` or `variants`, not both",
+		path: ["variants"]
+	});
+	if (data.variants) validateVariantKeys(data, ctx);
+}
+function validateTitleSource(data, ctx) {
+	if (!data.titleSource) return;
+	const sources = Array.isArray(data.titleSource) ? data.titleSource : [data.titleSource];
+	sources.forEach((source, index) => {
+		if (data.fields.some((field) => field !== null && typeof field === "object" && "id" in field && field.id === source)) return;
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `titleSource must reference a valid field ID (got "${source}")`,
+			path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
+		});
+	});
+}
+function validateVariantKeys(data, ctx) {
+	const variants = data.variants ?? {};
+	if (Object.keys(variants).length === 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "`variants` must contain at least one variant key",
+		path: ["variants"]
+	});
+	if (data.defaultVariant && !Object.prototype.hasOwnProperty.call(variants, data.defaultVariant)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "`defaultVariant` must be a key present in `variants`",
+		path: ["defaultVariant"]
+	});
+	Object.keys(data.variantOptions ?? {}).filter((key) => !Object.prototype.hasOwnProperty.call(variants, key)).forEach((key) => ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "`variantOptions` key must exist in `variants`",
+		path: ["variantOptions", key]
+	}));
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/schema.ts
+const visibilityLevels = [
+	"admin",
+	"designer",
+	"author"
+];
+const MEDIA_KINDS = [
+	"image",
+	"video",
+	"audio",
+	"document",
+	"spreadsheet",
+	"archive"
+];
+const DISPLAY_MEDIA_KINDS = [
+	"image",
+	"video",
+	"audio"
+];
+const DEFAULT_MEDIA_FIELD_KINDS = ["image"];
+const PUBLIC_FILE_FIELD_KINDS = [
+	"document",
+	"spreadsheet",
+	"archive",
+	"audio"
+];
+function isDisplayMediaKind(kind) {
+	return DISPLAY_MEDIA_KINDS.includes(kind);
+}
+const siteOptionSources = [
+	"eventCategories",
+	"eventSeries",
+	"venues",
+	"staffMembers",
+	"appointmentServiceCategories"
+];
+const mediaDeliverySchema = z.object({
+	sizes: z.string().optional(),
+	widthCandidates: z.array(z.number().int().positive()).optional(),
+	maxCssWidth: z.number().positive().optional(),
+	maxCssHeight: z.number().positive().optional(),
+	strategy: z.enum([
+		"default",
+		"columnsAuto",
+		"imageGalleryVariant"
+	]).optional(),
+	strategyOptions: z.record(z.string(), z.unknown()).optional()
+});
+const selectOptionSchema = z.object({
+	value: z.string(),
+	label: z.string(),
+	description: z.string().optional(),
+	icon: z.string().optional()
+});
+const selectSourceSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("static") }),
+	z.object({
+		kind: z.literal("site"),
+		optionSource: z.enum(siteOptionSources)
+	}),
+	z.object({ kind: z.literal("sdk") })
+]);
+function assertNeverSelectSource(value) {
+	throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
+}
+const visibleWhenPredicateSchema = z.object({
+	field: z.string().min(1),
+	equals: z.any().optional(),
+	notEquals: z.any().optional(),
+	oneOf: z.array(z.any()).optional(),
+	notIn: z.array(z.any()).optional(),
+	minItems: z.number().int().nonnegative().optional(),
+	maxItems: z.number().int().nonnegative().optional()
+});
+const visibleWhenSchema = z.lazy(() => z.union([
+	visibleWhenPredicateSchema,
+	z.object({ allOf: z.array(visibleWhenSchema).min(1) }),
+	z.object({ anyOf: z.array(visibleWhenSchema).min(1) })
+]));
+const uiSchema = z.object({
+	widget: z.string().optional(),
+	preset: z.enum(["disclosure"]).optional(),
+	flattenInRepeater: z.boolean().optional(),
+	hidden: z.boolean().optional(),
+	hideLabel: z.boolean().optional(),
+	hideDescription: z.boolean().optional(),
+	showCharCount: z.union([z.number().int().positive(), z.object({ max: z.number().int().positive() })]).optional(),
+	showSlugPreview: z.boolean().optional(),
+	variant: z.enum([
+		"full",
+		"inline",
+		"limited",
+		"media",
+		"notes"
+	]).optional(),
+	richTextVariant: z.enum([
+		"full",
+		"inline",
+		"limited",
+		"media",
+		"notes"
+	]).optional(),
+	cropEditorMode: z.enum(["dialog", "inline"]).optional(),
+	cropEditorAutoOpen: z.boolean().optional(),
+	mediaPickerAutoOpen: z.boolean().optional(),
+	showMediaPreview: z.boolean().optional(),
+	showMediaOverlayActions: z.boolean().optional(),
+	mediaPreviewMaxWidth: z.enum([
+		"xs",
+		"sm",
+		"md",
+		"none"
+	]).optional(),
+	preventMediaPreviewUpscale: z.boolean().optional(),
+	mediaDelivery: mediaDeliverySchema.optional(),
+	mediaDeliveryByVariant: z.record(z.string(), mediaDeliverySchema).optional(),
+	inputType: z.enum([
+		"text",
+		"email",
+		"tel",
+		"number"
+	]).optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	step: z.number().optional(),
+	showValue: z.boolean().optional(),
+	valueUnit: z.enum([
+		"percent",
+		"pixels",
+		"unitless"
+	]).optional(),
+	unsetValue: z.enum(["max", "field-default"]).optional(),
+	allowDirectInput: z.boolean().optional(),
+	pattern: z.string().optional(),
+	placeholder: z.string().optional(),
+	visibleWhen: visibleWhenSchema.optional(),
+	modalConfig: z.object({
+		buttonLabel: z.string().optional(),
+		description: z.string().optional(),
+		buttonVariant: z.enum(["default", "outline"]).optional(),
+		showCustomizedIndicator: z.boolean().optional(),
+		maxWidth: z.string().optional()
+	}).optional(),
+	allowedTypes: z.array(z.enum([
+		"color",
+		"gradient",
+		"image"
+	])).optional(),
+	fullWidth: z.boolean().optional(),
+	row: z.string().optional(),
+	colSpan: z.number().int().min(1).max(4).optional(),
+	layout: z.enum(["stack", "grid"]).optional(),
+	columns: z.number().int().min(2).max(4).optional(),
+	gridColsPreset: z.enum([
+		"simple2",
+		"simple3",
+		"simple4",
+		"buttonCtaRow"
+	]).optional(),
+	gridColumns: z.object({
+		base: z.number().int().min(1).max(4).optional(),
+		sm: z.number().int().min(1).max(4).optional(),
+		md: z.number().int().min(1).max(4).optional(),
+		lg: z.number().int().min(1).max(4).optional(),
+		xl: z.number().int().min(1).max(4).optional()
+	}).optional(),
+	gridColsClassName: z.string().optional(),
+	repeaterPreset: z.enum(["thumbnailGrid", "layoutGrid"]).optional(),
+	thumbnailField: z.string().optional(),
+	thumbnailAltField: z.string().optional(),
+	thumbnailLabelField: z.string().optional(),
+	thumbnailAspectRatio: z.string().optional(),
+	thumbnailCardDensity: z.enum(["compact", "comfortable"]).optional(),
+	layoutGridColumns: z.union([
+		z.literal(1),
+		z.literal(2),
+		z.literal(3),
+		z.literal(4),
+		z.literal(5),
+		z.literal(6)
+	]).optional(),
+	layoutGridColumnsFields: z.object({
+		base: z.string().optional(),
+		sm: z.string().optional(),
+		md: z.string().optional(),
+		lg: z.string().min(1),
+		xl: z.string().optional()
+	}).optional(),
+	layoutGridSpanField: z.string().optional(),
+	layoutGridStartNewRowField: z.string().optional(),
+	layoutGridRowField: z.string().optional(),
+	layoutGridColumnField: z.string().optional(),
+	layoutGridMaxRows: z.number().int().positive().optional(),
+	iconPickerPreset: z.enum(ICON_PICKER_PRESETS).optional(),
+	contentTypeField: z.string().optional(),
+	fixedContentType: z.string().optional(),
+	valueFrom: z.enum([
+		"id",
+		"identifier",
+		"slug"
+	]).optional(),
+	siteOptionSource: z.enum(siteOptionSources).optional(),
+	searchThreshold: z.number().int().positive().optional(),
+	renderInHeader: z.boolean().optional(),
+	intent: z.enum([
+		"content",
+		"display",
+		"behavior",
+		"style"
+	]).optional(),
+	underLooks: z.literal("owner").optional(),
+	valueContract: z.enum(["boxBackground", "location"]).optional()
+}).partial().superRefine((ui, ctx) => {
+	if (ui.layoutGridColumns !== undefined && ui.layoutGridColumnsFields !== undefined) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["layoutGridColumns"],
+			message: "Layout-grid requires exactly one of ui.layoutGridColumns or ui.layoutGridColumnsFields.lg; do not set both"
+		});
+	}
+}).transform((input) => {
+	const { layoutGridColumns, layoutGridColumnsFields, ...ui } = input;
+	if (layoutGridColumns !== undefined) return {
+		...ui,
+		layoutGridColumns
+	};
+	if (layoutGridColumnsFields !== undefined) return {
+		...ui,
+		layoutGridColumnsFields
+	};
+	return ui;
+});
+const baseFieldSchema = z.object({
+	id: z.string().min(1, "Field id is required"),
+	label: z.string().min(1, "Field label is required"),
+	description: z.string().optional(),
+	visibleRoles: z.array(z.enum(visibilityLevels)).optional(),
+	defaultValue: z.any().optional(),
+	required: z.boolean().default(false),
+	ui: uiSchema.optional()
+});
+const textFieldSchema = baseFieldSchema.extend({
+	type: z.literal("text"),
+	multiline: z.boolean().default(false),
+	maxLength: z.number().int().positive().optional()
+});
+const richTextFieldSchema = baseFieldSchema.extend({ type: z.literal("richText") });
+const inlineTextFieldSchema = baseFieldSchema.extend({
+	type: z.literal("inlineText"),
+	maxLength: z.number().int().positive().optional(),
+	plainTextField: z.string().min(1).optional()
+});
+function hasMediaDefaultIdentifier(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.identifier === "string" && value.identifier.trim().length > 0;
+}
+function validateMediaFieldDefault(field, ctx) {
+	if (field.defaultValue !== undefined && field.defaultValue !== null && !hasMediaDefaultIdentifier(field.defaultValue)) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["defaultValue"],
+			message: `${field.type} defaultValue must be null or an object with a non-empty identifier`
+		});
+	}
+}
+const mediaFieldSchema = baseFieldSchema.extend({
+	type: z.literal("media"),
+	mediaKinds: z.array(z.enum(MEDIA_KINDS)).default([...DEFAULT_MEDIA_FIELD_KINDS]).transform((kinds) => {
+		const displayKinds = kinds.filter(isDisplayMediaKind);
+		return displayKinds.length > 0 ? displayKinds : [...DEFAULT_MEDIA_FIELD_KINDS];
+	}),
+	aspectRatio: z.string().optional()
+}).superRefine(validateMediaFieldDefault);
+const fileFieldSchema = baseFieldSchema.extend({
+	type: z.literal("file"),
+	fileKinds: z.array(z.enum(PUBLIC_FILE_FIELD_KINDS)).default([...PUBLIC_FILE_FIELD_KINDS])
+}).superRefine(validateMediaFieldDefault);
+const booleanFieldSchema = baseFieldSchema.extend({ type: z.literal("boolean") });
+const dateFieldSchema = baseFieldSchema.extend({ type: z.literal("date") });
+const timeFieldSchema = baseFieldSchema.extend({ type: z.literal("time") });
+const dateTimeFieldSchema = baseFieldSchema.extend({ type: z.literal("datetime") });
+const slugFieldSchema = baseFieldSchema.extend({
+	type: z.literal("slug"),
+	sourceFieldId: z.string().min(1).optional(),
+	statusFieldId: z.string().min(1).optional(),
+	maxLength: z.number().int().positive().optional()
+});
+const urlFieldSchema = baseFieldSchema.extend({
+	type: z.literal("url"),
+	allowRelative: z.boolean().default(false)
+});
+const linkFieldSchema = baseFieldSchema.extend({ type: z.literal("link") });
+const selectFieldSchema = baseFieldSchema.extend({
+	type: z.literal("select"),
+	options: z.array(selectOptionSchema),
+	multiple: z.boolean().default(false),
+	source: selectSourceSchema.optional()
+}).superRefine((field, ctx) => {
+	const widget = field.ui?.widget;
+	const siteOptionSource = field.ui?.siteOptionSource;
+	if (!field.source) {
+		if (siteOptionSource || widget === "sdkSelect") {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Runtime-backed select fields must declare source.kind explicitly",
+				path: ["source"]
+			});
+			return;
+		}
+		if (field.options.length === 0) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Select fields require at least one option unless a runtime source is configured",
+				path: ["options"]
+			});
+		}
+		return;
+	}
+	switch (field.source.kind) {
+		case "static":
+			if (siteOptionSource || widget === "sdkSelect") {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Static select fields cannot declare runtime-backed UI metadata",
+					path: ["ui"]
+				});
+			}
+			if (field.options.length === 0) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Static select fields require at least one option",
+					path: ["options"]
+				});
+			}
+			return;
+		case "site":
+			if (field.options.length > 0) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Site-backed select fields must not define static options",
+					path: ["options"]
+				});
+			}
+			if (widget !== "siteOptionPicker") {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Site-backed select fields must use the siteOptionPicker widget",
+					path: ["ui", "widget"]
+				});
+			}
+			if (siteOptionSource !== field.source.optionSource) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Site-backed select fields must keep ui.siteOptionSource in sync with source.optionSource",
+					path: ["ui", "siteOptionSource"]
+				});
+			}
+			return;
+		case "sdk":
+			if (widget !== "sdkSelect") {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "SDK-backed select fields must use the sdkSelect widget",
+					path: ["ui", "widget"]
+				});
+			}
+			if (siteOptionSource) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "SDK-backed select fields cannot declare ui.siteOptionSource",
+					path: ["ui", "siteOptionSource"]
+				});
+			}
+			return;
+		default: return assertNeverSelectSource(field.source);
+	}
+});
+const referenceFieldSchema = baseFieldSchema.extend({
+	type: z.literal("reference"),
+	referenceKind: z.string().min(1),
+	allowManualEntry: z.boolean().default(false)
+});
+/**
+* Item type schema for polymorphic repeaters.
+* Each type has a label, optional icon, and its own field schema.
+*/
+const itemTypeSchema = z.object({
+	label: z.string().min(1),
+	icon: z.string().optional(),
+	fields: z.lazy(() => getFieldSchemaInternal().array().min(1, "Item type requires at least one field"))
+});
+/**
+* Repeater fields allow nesting of other fields within them.
+* This enables complex layouts and structures by repeating a set of fields.
+*
+* Supports two modes:
+* 1. Monomorphic (default): All items have the same schema
+* 2. Polymorphic: Items can be different types (e.g., card, quote, stat)
+*
+* Uses z.lazy() to allow mutual recursion.
+*/
+const repeaterFieldSchema = baseFieldSchema.extend({
+	type: z.literal("repeater"),
+	itemLabel: z.string().default("Item"),
+	itemLabelSource: z.string().optional(),
+	showSummary: z.boolean().optional(),
+	summaryFields: z.string().array().optional(),
+	summaryMaxChars: z.number().int().positive().optional(),
+	minItems: z.number().int().min(0).default(0),
+	maxItems: z.number().int().positive().optional(),
+	schema: z.object({ fields: z.lazy(() => getFieldSchemaInternal().array().min(1, "Repeater requires at least one field")) }).optional(),
+	polymorphic: z.boolean().optional(),
+	itemTypes: z.record(z.string(), itemTypeSchema).optional(),
+	allowConversion: z.boolean().default(true)
+}).refine((data) => {
+	const hasSchema = data.schema !== undefined;
+	const hasPolymorphic = data.polymorphic === true && data.itemTypes !== undefined;
+	return hasSchema !== hasPolymorphic;
+}, { message: "Repeater must have either 'schema' (monomorphic) or 'polymorphic: true' with 'itemTypes' (polymorphic)" }).superRefine(validateLayoutGridConfiguration).refine((data) => {
+	const thumbnailAspectRatio = data.ui?.thumbnailAspectRatio;
+	if (!thumbnailAspectRatio) {
+		return true;
+	}
+	return parseAspectRatioValue(thumbnailAspectRatio) != null;
+}, {
+	message: "ui.thumbnailAspectRatio must be a valid ratio (e.g. '16/9', '4:3', or '1.5')",
+	path: ["ui", "thumbnailAspectRatio"]
+}).refine((data) => {
+	const labelField = data.ui?.thumbnailLabelField;
+	if (!labelField) {
+		return true;
+	}
+	const schemaFields = data.schema?.fields;
+	if (!schemaFields) {
+		return true;
+	}
+	const field = schemaFields.find((candidate) => candidate.id === labelField);
+	return field?.type === "text";
+}, {
+	message: "ui.thumbnailLabelField must reference a text field in the repeater schema",
+	path: ["ui", "thumbnailLabelField"]
+});
+const groupFieldSchema = baseFieldSchema.extend({
+	type: z.literal("group"),
+	schema: z.object({ fields: z.lazy(() => getFieldSchemaInternal().array().min(1, "Group requires at least one field")) })
+});
+const modalFieldSchema = baseFieldSchema.extend({
+	type: z.literal("modal"),
+	schema: z.object({ fields: z.lazy(() => getFieldSchemaInternal().array().min(1, "Modal requires at least one field")) })
+});
+const numberFieldSchema = baseFieldSchema.extend({
+	type: z.literal("number"),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	step: z.number().optional()
+});
+const tabDefinitionSchema = z.object({
+	id: z.string().min(1),
+	label: z.string().min(1),
+	icon: z.string().optional(),
+	description: z.string().optional(),
+	fields: z.lazy(() => getFieldSchemaInternal().array()),
+	sdkSectionOption: z.enum([
+		"backgroundColor",
+		"backgroundGradient",
+		"backgroundImage"
+	]).optional()
+});
+const tabGroupFieldSchema = baseFieldSchema.extend({
+	type: z.literal("tabGroup"),
+	tabs: z.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
+	activeTabField: z.string().optional()
+});
+const presetOptionSchema = z.object({
+	value: z.string(),
+	label: z.string()
+});
+const presetOrCustomFieldSchema = baseFieldSchema.extend({
+	type: z.literal("presetOrCustom"),
+	presets: z.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
+	customInput: z.object({
+		placeholder: z.string().optional(),
+		pattern: z.string().optional(),
+		helpText: z.string().optional()
+	}).optional()
+});
+const contentTypeSelectFieldSchema = baseFieldSchema.extend({
+	type: z.literal("contentTypeSelect"),
+	filter: z.enum([
+		"all",
+		"routable",
+		"nonRoutable"
+	]).default("all")
+});
+const entryPickerFieldSchema = baseFieldSchema.extend({
+	type: z.literal("entryPicker"),
+	fixedContentType: z.string().optional(),
+	contentTypeField: z.string().optional(),
+	valueFrom: z.enum([
+		"id",
+		"identifier",
+		"slug"
+	]).optional()
+});
+let _fieldSchemaInternal = null;
+function getFieldSchemaInternal() {
+	if (_fieldSchemaInternal) {
+		return _fieldSchemaInternal;
+	}
+	_fieldSchemaInternal = z.discriminatedUnion("type", [
+		textFieldSchema,
+		richTextFieldSchema,
+		inlineTextFieldSchema,
+		mediaFieldSchema,
+		fileFieldSchema,
+		booleanFieldSchema,
+		numberFieldSchema,
+		dateFieldSchema,
+		timeFieldSchema,
+		dateTimeFieldSchema,
+		slugFieldSchema,
+		urlFieldSchema,
+		linkFieldSchema,
+		selectFieldSchema,
+		referenceFieldSchema,
+		repeaterFieldSchema,
+		groupFieldSchema,
+		modalFieldSchema,
+		tabGroupFieldSchema,
+		presetOrCustomFieldSchema,
+		contentTypeSelectFieldSchema,
+		entryPickerFieldSchema
+	]);
+	return _fieldSchemaInternal;
+}
+function getFieldSchema() {
+	return getFieldSchemaInternal();
+}
+const fieldSchema = new Proxy({}, {
+	get(_, prop) {
+		const schema = getFieldSchemaInternal();
+		const value = schema[prop];
+		return typeof value === "function" ? value.bind(schema) : value;
+	},
+	has(_, prop) {
+		return prop in getFieldSchemaInternal();
+	}
+});
+function parseFieldDefinition(input) {
+	return fieldSchema.parse(input);
+}
+function parseFieldDefinitions(input) {
+	return fieldSchema.array().parse(input);
 }
-function createPageOperations(http) {
-	async function upsert(input) {
-		if (input.publication === "publish") {
-			return sdkUpsertPagePublishResponseSchema.parse(await http.post("/pages", input, "write"));
-		}
-		return sdkUpsertPageDraftResponseSchema.parse(await http.post("/pages", input, "write"));
+/**
+* Normalize legacy select fields into the closed source union before any consumer
+* branches on source semantics. Runtime-backed definitions must be explicit;
+* legacy static definitions normalize to `kind: "static"`.
+*/
+function normalizeSelectSource(field) {
+	return field.source ?? { kind: "static" };
+}
+function expectParsedSelectField(field) {
+	if (field.type !== "select") {
+		throw new Error(`Expected select field, received ${field.type}`);
 	}
-	return {
-		async list(options) {
-			const result = await http.get("/pull/pages");
-			return paginateItems(result.pages.map(mapPulledPage), options);
-		},
-		async get(identifier) {
-			const result = await http.get("/pull/pages");
-			const page = result.pages.find((entry) => entry.identifier === identifier);
-			return page ? mapPulledPage(page) : null;
-		},
-		upsert,
-		async publish(identifier) {
-			return http.post(`/pages/${encodeURIComponent(identifier)}/publish`, undefined, "write");
-		},
-		async unpublish(identifier) {
-			return http.post(`/pages/${encodeURIComponent(identifier)}/unpublish`, undefined, "write");
-		},
-		async delete(identifier) {
-			return http.delete(`/pages/${encodeURIComponent(identifier)}`);
-		},
-		async getDesign(identifier) {
-			return http.getValidated(designPath(identifier), sdkGetPageDesignResponseSchema);
+	return field;
+}
+function createStaticSelectField(input) {
+	return expectParsedSelectField(parseFieldDefinition({
+		...input,
+		type: "select",
+		options: input.options,
+		multiple: input.multiple ?? false,
+		source: { kind: "static" }
+	}));
+}
+function createSiteOptionSelectField(input) {
+	return expectParsedSelectField(parseFieldDefinition({
+		...input,
+		type: "select",
+		options: [],
+		multiple: input.multiple ?? false,
+		source: {
+			kind: "site",
+			optionSource: input.optionSource
 		},
-		async saveDesign(identifier, design, expectedRevision) {
-			return http.postValidated(designPath(identifier), sdkSavePageDesignResponseSchema, {
-				design,
-				expectedRevision
-			}, "write");
+		ui: {
+			...input.ui ?? {},
+			widget: "siteOptionPicker",
+			siteOptionSource: input.optionSource
 		}
-	};
+	}));
+}
+function createSdkSelectField(input) {
+	return expectParsedSelectField(parseFieldDefinition({
+		...input,
+		type: "select",
+		options: input.options,
+		multiple: input.multiple ?? false,
+		source: { kind: "sdk" },
+		ui: {
+			...input.ui ?? {},
+			widget: "sdkSelect"
+		}
+	}));
+}
+const slotSchema = z.object({
+	id: z.string().min(1),
+	label: z.string().min(1),
+	allowedKinds: z.array(z.string()).default([]),
+	min: z.number().int().min(0).default(0),
+	max: z.number().int().positive().optional(),
+	help: z.string().optional(),
+	visibleRoles: z.array(z.enum(visibilityLevels)).optional()
+});
+const typographyTokens = [
+	"display",
+	"heading",
+	"subheading",
+	"body",
+	"caption"
+];
+const colorTokens = [
+	"background",
+	"surface",
+	"foreground",
+	"accent",
+	"muted"
+];
+const spacingTokens = [
+	"none",
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl"
+];
+const radiusTokens = [
+	"none",
+	"sm",
+	"md",
+	"lg",
+	"full"
+];
+const styleTokenSchema = z.object({
+	background: z.enum(colorTokens).optional(),
+	foreground: z.enum(colorTokens).optional(),
+	border: z.enum(colorTokens).optional(),
+	typography: z.enum(typographyTokens).optional(),
+	spacing: z.enum(spacingTokens).optional(),
+	radius: z.enum(radiusTokens).optional()
+});
+const behaviourSchema = z.object({
+	supportsThemeSwitching: z.boolean().default(true),
+	inlineEditing: z.boolean().default(false),
+	animation: z.boolean().default(false),
+	paletteHidden: z.boolean().default(false),
+	managesOwnWrapper: z.boolean().optional()
+});
+const builtInBlockKindsSchema = z.array(z.enum(SYSTEM_BLOCK_KINDS)).readonly();
+const blockRequiredFeatureSchema = z.enum([
+	"bookings.appointments",
+	"bookings.events",
+	"shop",
+	"newsletter",
+	"analytics"
+]);
+const blockCategoryEnum = z.enum([
+	"text-and-images",
+	"photos",
+	"people",
+	"events-and-bookings",
+	"shop",
+	"forms-and-sign-ups",
+	"marketing",
+	"content",
+	"blog",
+	"media",
+	"layout",
+	"interactive"
+]);
+/**
+* Explicit authoring classification of where a block's rendered content comes from.
+*
+* - `inline`  — all content is authored inline in the block's own fields.
+* - `entries` — the block renders content-type entries; `contentType` names the backing type.
+* - `mixed`   — the block has inline fields AND renders entries; `contentType` names the
+*               backing type when a single one applies.
+*
+* This is EXPLICIT metadata declared on every block definition (not inferred from
+* dataLoaders/field types), so the catalog can classify entry-backed vs inline blocks
+* honestly. A registry-wide test asserts every registered block declares it.
+*/
+const blockContentSourceKinds = [
+	"inline",
+	"entries",
+	"mixed"
+];
+const blockContentSourceSchema = z.object({
+	kind: z.enum(blockContentSourceKinds),
+	contentType: z.string().min(1).optional()
+}).superRefine((value, ctx) => {
+	if (value.kind === "inline" && value.contentType) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["contentType"],
+			message: "contentType is not allowed when contentSource.kind is \"inline\""
+		});
+	}
+});
+const manifestSchema = z.object({
+	name: z.string().min(1),
+	version: z.string().min(1),
+	title: z.string().min(1),
+	titleSource: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
+	description: z.string().optional(),
+	component: z.string().min(1),
+	fields: fieldSchema.array().default([]),
+	slots: slotSchema.array().default([]),
+	styleTokens: styleTokenSchema.optional(),
+	behaviours: behaviourSchema.optional(),
+	layout: NodeTreeSchema.optional(),
+	lookField: z.string().min(1).optional(),
+	sourceLine: z.object({
+		text: z.string(),
+		target: z.enum([
+			"testimonials",
+			"team",
+			"mailing-lists"
+		]),
+		when: z.object({
+			field: z.string(),
+			equals: z.string()
+		}).optional()
+	}).optional(),
+	promotedFields: z.array(z.string().min(1)).optional(),
+	variantMeaning: z.discriminatedUnion("kind", [z.object({
+		kind: z.literal("arrangement"),
+		lookOnlyKeys: z.array(z.string().min(1)).readonly().optional()
+	}), z.object({
+		kind: z.literal("mode"),
+		modes: z.array(z.enum(arrangementModes)).min(1).readonly(),
+		defaultMode: z.enum(arrangementModes),
+		arrangementField: z.string().min(1),
+		keys: z.array(z.string().min(1)).min(1).readonly(),
+		defaultKey: z.string().min(1),
+		lookOnlyKeys: z.array(z.string().min(1)).readonly().optional(),
+		modeLabels: z.record(z.string(), z.string().min(1)).readonly().optional()
+	})]),
+	variants: z.record(z.string(), NodeTreeSchema).optional(),
+	defaultVariant: z.string().optional(),
+	variantOptions: z.record(z.string(), z.object({
+		label: z.string().optional(),
+		description: z.string().optional(),
+		icon: z.string().optional()
+	}).optional()).optional(),
+	category: blockCategoryEnum.optional(),
+	contentTypes: z.array(z.string()).optional(),
+	requiredFeatures: z.array(blockRequiredFeatureSchema).optional(),
+	contentSource: blockContentSourceSchema.optional(),
+	tags: z.array(z.string()).optional(),
+	icon: z.string().optional()
+});
+/** SDK Looks name a single top-level select owned by this definition. */
+function validateManifestLookField(data, ctx) {
+	if (!data.lookField) return;
+	const valid = data.fields.some((field) => field !== null && typeof field === "object" && "id" in field && field.id === data.lookField && "type" in field && field.type === "select" && (!("multiple" in field) || field.multiple !== true));
+	if (!valid) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["lookField"],
+		message: "lookField must name an existing single select field"
+	});
 }
+const blockSectionDeclarationShape = {
+	promotedFields: z.array(z.string().min(1)).optional(),
+	lookField: z.string().min(1).optional()
+};
+
+//#endregion
+//#region ../api/src/sdkConfig/contracts.ts
+/**
+* Canonical SDK config Zod contracts.
+*
+* Goal: a single source-of-truth for request payload shapes used across dashboard + SDK.
+* - Endpoint request/response types live in `packages/api/src/types.ts`
+* - Schemas live here and are tied to those types via `satisfies z.ZodType<...>`
+*
+* NOTE: These schemas represent the *wire/input* shape for API requests.
+* Service-layer code should parse/normalize again (defaults/refinements) into domain types.
+*/
+/**
+* UNSAFE: Retype an existing Zod schema to a different (compile-time) output type.
+*
+* Use only for cases where:
+* - the runtime schema is known to accept the desired *input/wire* shape, but
+* - Zod's inferred output type doesn't match the desired TS type due to transforms/defaults.
+*
+* If used incorrectly, this can lie to TypeScript and cause drift.
+*
+* @internal
+*/
+function unsafeRetypeZodSchema(schema) {
+	return schema;
+}
+const navIdListSchema = z.preprocess((value) => {
+	if (!Array.isArray(value)) return undefined;
+	const filtered = value.filter((v) => typeof v === "string" && v.trim().length > 0);
+	return filtered.length > 0 ? filtered : undefined;
+}, z.array(z.string()).max(200).optional());
+const dashboardNavVisibilityBaseSchema = z.object({
+	mode: z.enum(["augment", "restrict"]).optional(),
+	allowIds: navIdListSchema,
+	denyIds: navIdListSchema
+}).strip();
+const dashboardNavVisibilityRolesSchema = z.object({
+	administrator: dashboardNavVisibilityBaseSchema.optional(),
+	editor: dashboardNavVisibilityBaseSchema.optional(),
+	team_member: dashboardNavVisibilityBaseSchema.optional()
+}).strip().optional();
+const dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({ roles: dashboardNavVisibilityRolesSchema }).strip();
+const dashboardNavigationConfigSchema = z.object({
+	siteNav: dashboardNavVisibilitySchema.optional(),
+	settingsNav: dashboardNavVisibilitySchema.optional()
+}).strip();
+const dashboardConfigSchema = z.object({
+	previewEditingEnabled: z.boolean().optional(),
+	navigation: dashboardNavigationConfigSchema.optional()
+}).strip();
+/**
+* Canonical field schema comes from @riverbankcms/blocks.
+*
+* It accepts FieldDefinitionInput (pre-defaults) and outputs FieldDefinition (post-defaults).
+* This `satisfies` assertion prevents drift in the *accepted wire shape* without forcing
+* the schema output type to match the input type.
+*/
+const fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
+const nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
+const sdkLoaderEndpointSchema = z.enum(SUPPORTED_LOADER_ENDPOINTS);
+const loaderFallbackScalarSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const loaderParamBindingSchema = z.object({ $bind: z.object({
+	from: z.string().min(1, "Binding path is required"),
+	fallback: loaderFallbackScalarSchema.optional()
+}) });
+const loaderParamValueSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	loaderParamBindingSchema
+]);
+const sdkConfigLoaderSchema = z.object({
+	endpoint: sdkLoaderEndpointSchema,
+	params: z.record(z.string(), loaderParamValueSchema),
+	requiredParams: z.array(z.string().min(1)).optional(),
+	mode: z.enum(["server", "client"]).default("server")
+});
+const sdkDataLoadersSchema = z.record(z.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+const sdkCustomBlockIdSchema = z.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, { message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens" }).transform((value) => value);
+const sdkCustomBlockInputSchema = z.object({
+	id: sdkCustomBlockIdSchema,
+	title: z.string().min(1),
+	titleSource: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
+	description: z.string().optional(),
+	category: blockCategoryEnum,
+	icon: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	fields: fieldDefinitionInputSchema.array().min(1),
+	dataLoaders: sdkDataLoadersSchema,
+	layout: NodeSchema.optional(),
+	...sdkBlockPresentationShape,
+	...blockSectionDeclarationShape
+}).superRefine(validateManifestLookField).superRefine(validateSdkBlockDeclaration);
+const sdkBlockFieldExtensionInputSchema = z.object({
+	fields: fieldDefinitionInputSchema.array().min(1),
+	...blockSectionDeclarationShape
+}).superRefine(validateManifestLookField);
+const sdkBlockFieldExtensionsInputSchema = z.record(z.string().min(1), sdkBlockFieldExtensionInputSchema);
+const sdkThemePaletteSchema = z.record(z.string(), z.string());
+const sdkThemeConfigSchema = z.object({ palette: sdkThemePaletteSchema });
+const sdkSectionBackgroundSchema = z.object({
+	id: z.string().min(1),
+	label: z.string().min(1),
+	token: z.string().min(1)
+});
+const sdkSectionOptionsConfigSchema = z.object({
+	backgroundColor: z.boolean().optional(),
+	backgroundImage: z.boolean().optional(),
+	backgroundGradient: z.boolean().optional(),
+	spacing: z.union([z.array(z.enum([
+		"compact",
+		"default",
+		"spacious"
+	])), z.boolean()]).optional(),
+	textColor: z.boolean().optional()
+});
+const sdkContainerOptionsConfigSchema = z.object({
+	maxWidth: z.union([z.array(z.enum([
+		"narrow",
+		"default",
+		"wide",
+		"full"
+	])), z.boolean()]).optional(),
+	alignment: z.union([z.array(z.enum([
+		"left",
+		"center",
+		"right"
+	])), z.boolean()]).optional()
+});
+const sdkSiteStyleConfigSchema = z.object({
+	sectionBackgrounds: z.array(sdkSectionBackgroundSchema).optional(),
+	sectionOptions: sdkSectionOptionsConfigSchema.optional(),
+	containerOptions: sdkContainerOptionsConfigSchema.optional()
+});
+const sdkSiteLayoutConfigSchema = z.object({
+	footerMode: footerModeSchema.optional(),
+	footerBlocks: z.array(z.object({
+		id: z.string().min(1).optional(),
+		kind: z.string().min(1),
+		content: z.record(z.string(), z.unknown()).optional()
+	})).optional()
+});
+const sdkFieldSelectOptionSchema = z.object({
+	value: z.string(),
+	label: z.string()
+});
+const sdkBlockFieldConfigSchema = z.object({ options: z.array(sdkFieldSelectOptionSchema).optional() });
+const sdkBlockFieldOptionsMapSchema = z.record(z.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, { message: "Block ID must be 'block.*' or 'custom.*' format" }), z.record(z.string().min(1), sdkBlockFieldConfigSchema)).optional();
+const sdkContentTypeTemplateConfigSchema = z.object({ blocks: z.array(z.unknown()) }).passthrough();
+const sdkContentTypeOrderingConfigSchema = z.object({ mode: z.enum(["default", "manual"]).optional() }).optional();
+const sdkContentTypeConfigSchema = z.object({
+	key: z.string().min(1),
+	fields: z.array(z.unknown()),
+	ordering: sdkContentTypeOrderingConfigSchema,
+	template: sdkContentTypeTemplateConfigSchema.nullable().optional()
+}).passthrough();
+const sdkContentConfigSchema = z.object({
+	contentTypes: z.array(sdkContentTypeConfigSchema).optional(),
+	pages: z.array(z.unknown()).optional(),
+	entries: z.array(z.unknown()).optional(),
+	navigationMenus: z.array(z.unknown()).optional(),
+	settings: z.unknown().optional()
+}).passthrough();
+const SDK_WORKFLOW_ID_MAX_LENGTH = 120;
+const SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
+const SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH = 500;
+const SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH = 120;
+const SDK_WORKFLOW_ENDPOINT_MAX_LENGTH = 500;
+const SDK_WORKFLOW_TRIGGER_MAX_COUNT = 5;
+const SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH = 120;
+const SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT = 10;
+const SDK_WORKFLOW_MAX_COUNT = 50;
+const SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH = 120;
+const SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
+const SDK_WORKFLOW_ID_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
+const SDK_WORKFLOW_ENDPOINT_PATTERN = /^\//;
+const sdkWorkflowIdSchema = z.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, { message: "Workflow ID must start with a lowercase letter and use lowercase letters, numbers, dots, underscores, or hyphens" });
+const sdkWorkflowEndpointSchema = z.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: "Workflow endpoint must be a site-relative path starting with \"/\"" });
+const sdkWorkflowManualTriggerSchema = z.object({ type: z.literal("manual") }).strict();
+const sdkWorkflowTriggerFieldSchema = z.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), { message: "Workflow trigger fields must be top-level content field IDs, not paths" });
+const sdkWorkflowFieldChangedConditionSchema = z.object({
+	field: sdkWorkflowTriggerFieldSchema,
+	changed: z.literal(true)
+}).strict();
+const sdkWorkflowFieldEmptyConditionSchema = z.object({
+	field: sdkWorkflowTriggerFieldSchema,
+	isEmpty: z.boolean()
+}).strict();
+const sdkWorkflowEntryDraftUpdatedTriggerSchema = z.object({
+	type: z.literal("entry.draft.updated"),
+	when: z.array(z.union([sdkWorkflowFieldChangedConditionSchema, sdkWorkflowFieldEmptyConditionSchema])).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
+}).strict();
+const sdkWorkflowTriggerSchema = z.discriminatedUnion("type", [sdkWorkflowManualTriggerSchema, sdkWorkflowEntryDraftUpdatedTriggerSchema]);
+const sdkWorkflowConfirmationSchema = z.object({
+	title: z.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+	body: z.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+}).strict();
+const sdkWorkflowConfigSchema = z.object({
+	id: sdkWorkflowIdSchema,
+	title: z.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+	description: z.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+	contentType: z.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+	endpoint: sdkWorkflowEndpointSchema,
+	triggers: z.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+	confirmation: sdkWorkflowConfirmationSchema.optional()
+}).strict();
+const sdkWorkflowsSchema = z.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+	const ids = workflows.map((workflow) => workflow.id);
+	return ids.length === new Set(ids).size;
+}, { message: "Workflow IDs must be unique" }).optional();
+const riverbankSiteConfigInputSchema = z.object({
+	siteId: z.string().uuid(),
+	builtInBlocks: builtInBlockKindsSchema.optional(),
+	previewUrl: z.string().url().optional(),
+	liveUrl: z.string().url().optional(),
+	theme: sdkThemeConfigSchema.optional(),
+	styles: sdkSiteStyleConfigSchema.optional(),
+	layout: sdkSiteLayoutConfigSchema.optional(),
+	customBlocks: z.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+		const ids = blocks.map((b) => b.id);
+		return ids.length === new Set(ids).size;
+	}, { message: "Block IDs must be unique" }).optional(),
+	blockFieldOptions: sdkBlockFieldOptionsMapSchema,
+	blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
+	workflows: sdkWorkflowsSchema,
+	content: sdkContentConfigSchema.optional(),
+	contentDir: z.string().optional(),
+	sync: z.object({ existingEntries: z.enum(["skip", "update"]).optional() }).optional(),
+	deploy: z.object({
+		verifyCommand: z.string().optional(),
+		prebuildOutput: z.string().optional()
+	}).optional(),
+	themeSource: z.enum(["local", "cms"]).optional(),
+	activeTheme: z.string().optional(),
+	enablePortal: z.boolean().optional(),
+	dashboard: dashboardConfigSchema.optional()
+}).strict();
+const pushSdkConfigBodySchema = z.object({
+	config: riverbankSiteConfigInputSchema,
+	forceContentTypes: z.boolean().optional(),
+	mode: z.enum(["apply", "preview"]).optional(),
+	expectedMailingListProviderScope: z.unknown().transform((value, ctx) => {
+		if (value === undefined) return undefined;
+		const parsed = parseMailingListProviderScope(value);
+		if (parsed.ok) return parsed.value;
+		ctx.addIssue({
+			code: "custom",
+			message: "Invalid mailing-list provider scope"
+		});
+		return z.NEVER;
+	}).optional()
+}).strict();
 
 //#endregion
 //#region ../api/src/sdkContracts.ts
@@ -14388,25 +17035,6 @@ function parsePublicProductCategorySelector(value) {
 	return undefined;
 }
 
-//#endregion
-//#region ../api/src/request-error.ts
-var ApiRequestError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "ApiRequestError";
-		this.endpoint = options.endpoint;
-		this.status = options.status;
-		this.method = options.method;
-		this.auth = options.auth;
-		this.requestId = options.requestId;
-		this.body = options.body;
-		this.cause = options.cause;
-		this.errorCode = options.errorCode;
-		this.tag = options.tag;
-		this.retryAfterMs = options.retryAfterMs;
-	}
-};
-
 //#endregion
 //#region ../api/src/token.ts
 async function getAuthHeaders(supabase) {
@@ -14430,6 +17058,18 @@ async function getAuthHeaders(supabase) {
 //#region ../surfaces/src/index.ts
 const SURFACE_IDS = ["core", "macadamia"];
 const DEFAULT_SURFACE_ID = "core";
+const SURFACE_ASSISTANT_MARKS = {
+	core: {
+		src: "/logo.svg",
+		width: 22,
+		height: 20
+	},
+	macadamia: {
+		src: "/surfaces/macadamia/assistant-mark.svg",
+		width: 26,
+		height: 26
+	}
+};
 const SURFACE_DOCUMENT_DATA_ATTRIBUTE = "data-dashboard-surface";
 function isSurfaceId(value) {
 	return typeof value === "string" && SURFACE_IDS.includes(value);
@@ -14895,7 +17535,6 @@ function getRevalidateTag() {
 	}
 	return revalidateTag;
 }
-let sdkVersion;
 /**
 * Generate a UUID, with fallback for environments where crypto.randomUUID isn't available.
 */
@@ -14910,19 +17549,6 @@ function generateRequestId() {
 	});
 }
 /**
-* Set the SDK version to be included in API request headers
-* Called by the SDK during initialization
-*/
-function setSdkVersion(version) {
-	sdkVersion = version;
-}
-/**
-* Get the currently set SDK version
-*/
-function getSdkVersion() {
-	return sdkVersion;
-}
-/**
 * Parse the Retry-After header value to milliseconds.
 * The header can be either:
 * - A number of seconds (e.g., "120")
@@ -15145,7 +17771,7 @@ async function createAuthenticatedApiClient(supabase) {
 	}
 	return createCMSClient(authHeaders);
 }
-function createRawCMSClient(getHeaders = () => ({}), baseUrl) {
+function createRawCMSClient(getHeaders = () => ({}), baseUrl, { sdkVersion } = {}) {
 	return ({ endpoint, body, params, options = {} }) => {
 		const plan = buildApiRequestPlan({
 			endpoint,
@@ -15279,8 +17905,8 @@ function createParsedClient(rawClient) {
 		return parseSuccessResponse(endpoint, response, config);
 	};
 }
-function createCMSClient(headers = {}, baseUrl) {
-	return createParsedClient(createRawCMSClient(() => headers, baseUrl));
+function createCMSClient(headers = {}, baseUrl, options) {
+	return createParsedClient(createRawCMSClient(() => headers, baseUrl, options));
 }
 const createServerAPIClient = (apiKey, baseUrl) => {
 	const normalizedApiKey = normalizeCmsApiKey(apiKey);
@@ -15290,11 +17916,11 @@ const createServerAPIClient = (apiKey, baseUrl) => {
 	const authHeaders = { Authorization: `Bearer ${normalizedApiKey}` };
 	return createCMSClient(authHeaders, baseUrl);
 };
-function createInternalAPIClient(baseUrl) {
-	return createCMSClient({}, baseUrl);
+function createInternalAPIClient(baseUrl, options) {
+	return createCMSClient({}, baseUrl, options);
 }
-function createBearerAPIClient(token, baseUrl) {
-	return createParsedClient(createRawCMSClient(() => ({ Authorization: `Bearer ${typeof token === "function" ? token() : token}` }), baseUrl));
+function createBearerAPIClient(token, baseUrl, options) {
+	return createParsedClient(createRawCMSClient(() => ({ Authorization: `Bearer ${typeof token === "function" ? token() : token}` }), baseUrl, options));
 }
 /** Positive receipt evidence is kept distinct from an HTTP or request failure. */
 function requireUsableCommitProjection(response, parsed) {
@@ -15302,13 +17928,6 @@ function requireUsableCommitProjection(response, parsed) {
 	throw new ApiCommittedWriteNotice(pageCommitConfirmationEnvelopeSchema.parse(parsed).data);
 }
 
-//#endregion
-//#region ../api/src/appointmentServiceVisibility.ts
-const APPOINTMENT_SERVICE_VISIBILITY_VALUES = ["public", "unlisted"];
-function isAppointmentServiceVisibility(value) {
-	return value === "public" || value === "unlisted";
-}
-
 //#endregion
 //#region ../api/src/appointmentServiceLocation.ts
 const APPOINTMENT_SERVICE_LOCATION_TYPE_VALUES = [
@@ -15329,67 +17948,23 @@ const APPOINTMENT_RESERVATION_STATUS_VALUES = [
 ];
 
 //#endregion
-//#region ../api/src/utils/isRecord.ts
-function isRecord$5(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-//#endregion
-//#region ../api/src/utils/error-propagation.ts
-/**
-* Extracts an error message from an API error response body.
-* Checks for our standard API error format: { error: { message: "..." } }
-* Also handles legacy formats with `error` or `message` as strings.
-*/
-function extractApiErrorMessage(body) {
-	if (!isRecord$5(body)) {
-		return null;
-	}
-	if (isRecord$5(body.error)) {
-		if (typeof body.error.message === "string" && body.error.message.trim().length > 0) {
-			return body.error.message;
-		}
-	}
-	if (typeof body.error === "string" && body.error.trim().length > 0) {
-		return body.error;
-	}
-	if (typeof body.message === "string" && body.message.trim().length > 0) {
-		return body.message;
-	}
-	return null;
-}
-/**
-* Normalizes various error types and throws with an appropriate message.
-*
-* - For ApiRequestError: extracts message from body.error or body.message
-* - For Error instances: re-throws as-is
-* - For unknown errors: wraps with fallback message
-*
-* @param error - The error to normalize
-* @param fallback - Fallback message if no specific message can be extracted
-* @throws {Error} Always throws - this function never returns
-*/
-function normalizeApiError(error, fallback) {
-	if (error instanceof ApiRequestError) {
-		const message = extractApiErrorMessage(error.body);
-		throw new ApiRequestError(message ?? fallback, {
-			endpoint: error.endpoint,
-			status: error.status,
-			method: error.method,
-			auth: error.auth,
-			requestId: error.requestId,
-			body: error.body,
-			cause: error,
-			errorCode: error.errorCode,
-			tag: error.tag,
-			retryAfterMs: error.retryAfterMs
-		});
-	}
-	if (error instanceof Error) {
-		throw error;
-	}
-	throw new Error(fallback);
+//#region ../api/src/wholeSeriesRuns.ts
+const DELETE_EVENT_OFFERING_CONFLICT_REASONS = [
+	"has_registrations",
+	"has_payments",
+	"published_page",
+	"inconsistent_ownership"
+];
+function isDeleteEventOfferingConflictReason(value) {
+	return DELETE_EVENT_OFFERING_CONFLICT_REASONS.some((reason) => reason === value);
 }
+const EVENT_SERIES_REGISTRATION_STATUSES = [
+	"pending_payment",
+	"enrolled",
+	"waitlist",
+	"cancelled",
+	"completed"
+];
 
 //#endregion
 //#region ../api/src/bookingActivity.ts
@@ -15409,6 +17984,8 @@ const BOOKING_ACTIVITY_TYPE_VALUES = [
 	"event_booking_restored",
 	"waitlist_joined",
 	"balance_paid",
+	"payment_recorded",
+	"payment_waived",
 	"appointment_cancelled",
 	"booking_closure_created",
 	"booking_closure_removed",
@@ -15513,18 +18090,6 @@ const PERSON_DELETION_BLOCKER_CATEGORY_VALUES = [
 	"contact_corrections"
 ];
 
-//#endregion
-//#region ../api/src/wholeSeriesRuns.ts
-const DELETE_EVENT_OFFERING_CONFLICT_REASONS = [
-	"has_registrations",
-	"has_payments",
-	"published_page",
-	"inconsistent_ownership"
-];
-function isDeleteEventOfferingConflictReason(value) {
-	return DELETE_EVENT_OFFERING_CONFLICT_REASONS.some((reason) => reason === value);
-}
-
 //#endregion
 //#region ../api/src/eventAttendanceLabels.ts
 function getEventAttendanceModeLabel(mode) {
@@ -16891,7 +19456,6 @@ async function adminClearSitePublicCache(apiClient, siteId, options) {
 
 //#endregion
 //#region ../api/src/accessAdmin.ts
-const STAFF_OPERATIONAL_CAPABILITIES = ["appointments", "event_ops"];
 function getDefaultStaffCapabilities(surfaces) {
 	if (surfaces.events && !surfaces.appointments) return ["event_ops"];
 	return ["appointments"];
@@ -17056,6 +19620,7 @@ async function acceptSiteInvitation(apiClient, { body, options }) {
 
 //#endregion
 //#region ../api/src/staffAccess.ts
+const STAFF_OPERATIONAL_CAPABILITIES = ["appointments", "event_ops"];
 function roleAtLeast$1(role, minimum) {
 	return SITE_ROLE_PERMISSION_LEVEL[role] >= SITE_ROLE_PERMISSION_LEVEL[minimum];
 }
@@ -17223,6 +19788,22 @@ const FLEXIBLE_BALANCE_ADMIN_ACTION_SOURCES = [
 	"event_attendee_detail",
 	"event_series_registration_detail"
 ];
+const settlementAuditSchema = {
+	operationId: z.string().uuid(),
+	orderItemIds: z.array(z.string().uuid()).nonempty().optional(),
+	amountCents: z.number().int().positive().optional().nullable(),
+	externalReference: z.string().optional().nullable(),
+	note: z.string().optional().nullable()
+};
+const settleShopOrderPaymentSchema = z.union([z.object({
+	...settlementAuditSchema,
+	action: z.enum(["mark_paid", "record_partial_payment"]),
+	method: z.enum(OFFLINE_PAYMENT_METHODS),
+	paidOn: z.iso.date()
+}), z.object({
+	...settlementAuditSchema,
+	action: z.literal("mark_waived")
+})]);
 
 //#endregion
 //#region ../api/src/navigation/visibility.ts
@@ -24898,4 +27479,4 @@ function optionalTitle(data) {
 }
 
 //#endregion
-export { normalizeMediaValueToIdentifierOnly as $, createCommandContext as $t, formatDiffDetail as A, getEnvPrefix as An, navigationIdentity as At, buildFieldChanges as B, portablePageDesignSchema as Bn, preparePushConfigTarget as Bt, reportFromOutcomes as C, requireEnvironmentWriteAuthorization as Cn, fileExists$1 as Ct, normalizeRemoteHomepageReference as D, transportSuggestion as Dn, writeJsonFileAtomic as Dt, createEmptySyncResult as E, formatError as En, writeJsonFile$1 as Et, calculatePullDiff as F, createManagementClient as Fn, navigationCommandItemToManagementInput as Ft, syncLocalMediaForPull as G, APPOINTMENT_SERVICE_VISIBILITY_VALUES as Gt, formatFieldPath as H, API_ENDPOINTS as Hn, extractApiErrorMessage as Ht, buildJsonDiff as I, ManagementApiError as In, normalizeNavigationConfigItemForCommand as It, admitBinaryWriteDestination as J, ApiRequestError as Jt, applyLocalMediaPush as K, createBearerAPIClient as Kt, hasPageOperations as L, sdkEventScheduleSchema as Ln, applyPushConfigPlan as Lt, hasPendingChanges as M, isLocalConfigured as Mn, convertPulledFooterToLocal as Mt, findChangedFieldsWithValues as N, isRemoteConfigured as Nn, convertPulledNavigationToLocal as Nt, calculateDiff as O, CliExit as On, isMediaValue as Ot, formatHumanDiff as P, loadSdkEnvironment as Pn, convertPulledPagesToLocal as Pt, normalizeMediaIdentifierInput as Q, createClientForEnv as Qt, pageMetadataForUpsert as R, sdkSettingsUpdateSchema as Rn, createPushConfigCommand as Rt, planCliCommandBatchForBindings as S, planEnvironmentWriteAuthorization as Sn, ensureDir$1 as St, executeResidualSettingsSyncPlan as T, ErrorCodes as Tn, readJsonFile as Tt, revalidateLocalMediaPushPlan as U, ApiEnvelopeError as Un, normalizeApiError as Ut, formatFieldChange as V, sdkConfiguredBookingVerticalConfigSchema as Vn, revalidatePushConfigPlan as Vt, syncLocalMediaForPush as W, unwrapResponse as Wn, isRecord$5 as Wt, writeBinaryFileAtomic as X, bindRequestTimeout as Xt, readStableBinaryFile as Y, mapEnvironmentExecutionOutcomesJson as Yt, sha256 as Z, confirmAction as Zt, commandExecutionToReport as _, withErrorHandling as _n, metadataFilePath as _t, executeEntryCommandPlanAsReport as a, getOutputContext as an, readEntries as at, executeCompiledCliCommandPlanAsReport as b, parseEnvironmentSelection as bn, writeMetadataFile as bt, titleFromEntryData as c, managementClientConfigFor as cn, readEventsMeta as ct, unsafeAsCliEntryIdentifier as d, parseJsonData as dn, readNavigationMeta as dt, createGetCommand as en, walkLocalContentMedia as et, unsafeAsCliFormSlug as f, parsePaginationOptions as fn, readPagesMeta as ft, commandCompileFailureToReport as g, withConfirmation as gn, ensureMetadataDir as gt, mutationCounterForEffect as h, withCommandContext as hn, writeMediaManifest as ht, entrySiteCommandTypes as i, formatDateShort as in, findLegacyEntryFiles as it, formatDiffSummary as j, getEnvironmentDebugInfo as jn, navigationIdentityMap as jt, calculateFooterDiff as k, createOutput as kn, duplicateNavigationIdentityMessage as kt, unsafeAsCliBlockIdentifier as l, mapEntryForOutput as ln, readFooterMeta as lt, commandReportToSyncResult as m, runWithInvocation as mn, readVenuesMeta as mt, entryCommandCompileErrorToReport as n, createOutputForCommand as nn, downloadMedia as nt, executeEntryCommandPlanAsSyncResult as o, getOutputOnlyContext as on, readAllMeta as ot, unsafeAsCliPageIdentifier as p, resolveCommandPath as pn, readSettingsMeta as pt, prepareLocalMediaForPush as q, deriveCmsApiUrlFromDashboardUrl as qt, entryCommandReportToSyncResult as r, currentInvocationEnvelope as rn, extractMediaIdentifiers as rt, syncResultForEntryCommandCompileError as s, handleCommandError as sn, readEventCategoriesMeta as st, compileEntryPushCommands as t, createListCommand as tn, buildStorageUrl as tt, unsafeAsCliContentTypeKey as u, parseJsonArray as un, readFormsMeta as ut, commandReportHasFailures as v, withOutputOnlyErrorHandling as vn, metadataTargetFromEnvironment as vt, mergeManySyncResults as w, withRiverbankEnv as wn, listFiles as wt, formatManagementError as x, planEnvironmentExecution as xn, writeMetadataRecordMap as xt, executeCliCommandPlan as y, executeEnvironmentPlan as yn, readMetadataFile as yt, calculateEntryDiffs as z, linkPayloadSchema as zn, loadPushConfigTarget as zt };
+export { normalizeMediaValueToIdentifierOnly as $, normalizeApiError as $n, formatDateShort as $t, formatDiffDetail as A, createManagementClient as An, navigationIdentity as At, buildFieldChanges as B, planRepeaterGridColumnChange as Bn, preparePushConfigTarget as Bt, reportFromOutcomes as C, CliExit as Cn, fileExists$1 as Ct, normalizeRemoteHomepageReference as D, isLocalConfigured as Dn, writeJsonFileAtomic as Dt, createEmptySyncResult as E, getEnvironmentDebugInfo as En, writeJsonFile$1 as Et, calculatePullDiff as F, fieldSchema as Fn, navigationCommandItemToManagementInput as Ft, syncLocalMediaForPull as G, resolveRepeaterGridColumnsForBreakpoint as Gn, bindRequestTimeout as Gt, formatFieldPath as H, buildRepeaterGridLayout as Hn, createBearerAPIClient as Ht, buildJsonDiff as I, normalizeSelectSource as In, normalizeNavigationConfigItemForCommand as It, admitBinaryWriteDestination as J, typeBasedLayout as Jn, createCommandContext as Jt, applyLocalMediaPush as K, resolveRepeaterGridRowFieldId as Kn, confirmAction as Kt, hasPageOperations as L, parseFieldDefinition as Ln, applyPushConfigPlan as Lt, hasPendingChanges as M, PUBLIC_FILE_FIELD_KINDS as Mn, convertPulledFooterToLocal as Mt, findChangedFieldsWithValues as N, createSdkSelectField as Nn, convertPulledNavigationToLocal as Nt, calculateDiff as O, isRemoteConfigured as On, isMediaValue as Ot, formatHumanDiff as P, createSiteOptionSelectField as Pn, convertPulledPagesToLocal as Pt, normalizeMediaIdentifierInput as Q, extractApiErrorMessage as Qn, currentInvocationEnvelope as Qt, pageMetadataForUpsert as R, parseFieldDefinitions as Rn, createPushConfigCommand as Rt, planCliCommandBatchForBindings as S, transportSuggestion as Sn, ensureDir$1 as St, executeResidualSettingsSyncPlan as T, getEnvPrefix as Tn, readJsonFile as Tt, revalidateLocalMediaPushPlan as U, parseRepeaterGridInteger as Un, deriveCmsApiUrlFromDashboardUrl as Ut, formatFieldChange as V, projectRepeaterGridLayoutForRendering as Vn, revalidatePushConfigPlan as Vt, syncLocalMediaForPush as W, resolveRepeaterGridColumnFieldId as Wn, mapEnvironmentExecutionOutcomesJson as Wt, writeBinaryFileAtomic as X, bindingSchema as Xn, createListCommand as Xt, readStableBinaryFile as Y, NodeSchema as Yn, createGetCommand as Yt, sha256 as Z, ManagementApiError as Zn, createOutputForCommand as Zt, commandExecutionToReport as _, planEnvironmentWriteAuthorization as _n, metadataFilePath as _t, executeEntryCommandPlanAsReport as a, parseJsonArray as an, portablePageDesignSchema as ar, readEntries as at, executeCompiledCliCommandPlanAsReport as b, ErrorCodes as bn, writeMetadataFile as bt, titleFromEntryData as c, resolveCommandPath as cn, ApiEnvelopeError as cr, readEventsMeta as ct, unsafeAsCliEntryIdentifier as d, withConfirmation as dn, readNavigationMeta as dt, getOutputContext as en, isRecord$5 as er, walkLocalContentMedia as et, unsafeAsCliFormSlug as f, withErrorHandling as fn, readPagesMeta as ft, commandCompileFailureToReport as g, planEnvironmentExecution as gn, ensureMetadataDir as gt, mutationCounterForEffect as h, parseEnvironmentSelection as hn, writeMediaManifest as ht, entrySiteCommandTypes as i, mapEntryForOutput as in, linkPayloadSchema as ir, findLegacyEntryFiles as it, formatDiffSummary as j, DEFAULT_MEDIA_FIELD_KINDS as jn, navigationIdentityMap as jt, calculateFooterDiff as k, loadSdkEnvironment as kn, duplicateNavigationIdentityMessage as kt, unsafeAsCliBlockIdentifier as l, runWithInvocation as ln, unwrapResponse as lr, readFooterMeta as lt, commandReportToSyncResult as m, executeEnvironmentPlan as mn, readVenuesMeta as mt, entryCommandCompileErrorToReport as n, handleCommandError as nn, sdkEventScheduleSchema as nr, downloadMedia as nt, executeEntryCommandPlanAsSyncResult as o, parseJsonData as on, sdkConfiguredBookingVerticalConfigSchema as or, readAllMeta as ot, unsafeAsCliPageIdentifier as p, withOutputOnlyErrorHandling as pn, readSettingsMeta as pt, prepareLocalMediaForPush as q, resolveRepeaterGridSpanFieldId as qn, createClientForEnv as qt, entryCommandReportToSyncResult as r, managementClientConfigFor as rn, sdkSettingsUpdateSchema as rr, extractMediaIdentifiers as rt, syncResultForEntryCommandCompileError as s, parsePaginationOptions as sn, API_ENDPOINTS as sr, readEventCategoriesMeta as st, compileEntryPushCommands as t, getOutputOnlyContext as tn, ApiRequestError as tr, buildStorageUrl as tt, unsafeAsCliContentTypeKey as u, withCommandContext as un, readFormsMeta as ut, commandReportHasFailures as v, requireEnvironmentWriteAuthorization as vn, metadataTargetFromEnvironment as vt, mergeManySyncResults as w, createOutput as wn, listFiles as wt, formatManagementError as x, formatError as xn, writeMetadataRecordMap as xt, executeCliCommandPlan as y, withRiverbankEnv as yn, readMetadataFile as yt, calculateEntryDiffs as z, resolveIconPickerPreset as zn, loadPushConfigTarget as zt };