riverbankcms 0.1.0 → 0.2.0

package/dist/eventUpsertInputSchema-BUeXa6jk.mjs

@@ -0,0 +1,4940 @@
+#!/usr/bin/env node
+import { a as classifySdkEventPricing, i as classifySdkEventSchedule, o as classifySdkEventPaymentTerms, r as sdkEventUpsertOptionalFieldSchemas } from "./sdk-event-upsert-CTqsrhFT.mjs";
+import { z } from "zod";
+
+//#region ../blocks/src/lib/typeGuards.ts
+/**
+* Strict record guard: excludes null, primitives, and arrays.
+*/
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Non-null object guard: includes arrays for behavior parity with legacy helpers.
+*
+* NOTE: This intentionally narrows to UnknownRecord for compatibility with existing
+* callsites even though arrays pass at runtime. Follow-up cleanup should replace
+* this API with a more precise predicate type and migrate consumers.
+*/
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Coerces unknown input into a strict record, returning an empty object fallback.
+*/
+function asRecord(value) {
+	return isRecord$3(value) ? value : {};
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/richTextSchema.ts
+/**
+* Shared Rich Text Schema
+*
+* This module provides a single source of truth for TipTap rich text validation
+* across both the block-form editor and the block rendering system.
+*
+* Rich-text fields use one canonical root shape:
+* `{ type: 'doc', content: [...] }`.
+*/
+/**
+* TipTap document node schema (recursive structure)
+*
+* Supports the full TipTap document structure including:
+* - type: Node type (e.g., 'doc', 'paragraph', 'text')
+* - content: Nested array of child nodes
+* - text: Text content for text nodes
+* - attrs: Node attributes (e.g., alignment, color)
+* - marks: Text formatting marks (e.g., bold, italic)
+*/
+const TipTapMarkSchema = z.object({
+	type: z.string().min(1),
+	attrs: z.record(z.string(), z.unknown()).optional()
+}).strict();
+const TipTapNodeSchema = z.lazy(() => z.object({
+	type: z.string().min(1),
+	content: z.array(TipTapNodeSchema).optional(),
+	text: z.string().optional(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	marks: z.array(TipTapMarkSchema).optional()
+}).strict().superRefine((node, ctx) => {
+	if (node.type === "doc") {
+		ctx.addIssue({
+			code: "custom",
+			path: ["type"],
+			message: "Document nodes are only valid at the rich-text root"
+		});
+	}
+	if (node.type === "text") {
+		if (node.text === undefined || node.text.length === 0) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["text"],
+				message: "Text nodes require a non-empty text value"
+			});
+		}
+		if (node.content !== undefined) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["content"],
+				message: "Text nodes cannot contain child nodes"
+			});
+		}
+		return;
+	}
+	if (node.text !== undefined) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "Only text nodes can contain a text value"
+		});
+	}
+}));
+/**
+* Canonical schema for a TipTap rich-text document root.
+*
+* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
+* `content` is required (possibly empty). This is the shape every producer
+* (dummy content, editor output, migrations) must emit, and the shape every
+* non-legacy consumer can rely on.
+*
+*/
+const RichTextDocSchema = z.object({
+	type: z.literal("doc"),
+	content: z.array(TipTapNodeSchema)
+}).strict();
+/**
+* Type guard for {@link RichTextDoc}.
+*
+* Returns `true` only for the canonical unwrapped form. The shared structural
+* contract lives in `@riverbankcms/core`; parity tests keep its dependency-free
+* guard aligned with this detailed Zod validator.
+*/
+function isRichTextDoc(value) {
+	return RichTextDocSchema.safeParse(value).success;
+}
+/**
+* Build a canonical {@link RichTextDoc} from plain-text paragraphs.
+*
+* Single source of truth for constructing a TipTap doc from strings.
+* Used by:
+*   - `@riverbankcms/dummy-content` (fixture body generators)
+*   - `@riverbankcms/content-model` (default template `cta-full` content)
+*
+* Empty strings produce a paragraph with no `content` array — matching
+* the TipTap convention for empty paragraphs. The shape is exactly what
+* {@link RichTextDocSchema} validates, so the type and runtime check
+* never drift from the constructor.
+*/
+function createRichTextDoc(paragraphs) {
+	return {
+		type: "doc",
+		content: paragraphs.map((text) => text ? {
+			type: "paragraph",
+			content: [{
+				type: "text",
+				text
+			}]
+		} : { type: "paragraph" })
+	};
+}
+function createHardBreakNode() {
+	return { type: "hardBreak" };
+}
+/**
+* Parse a small markdown subset into TipTap inline nodes.
+*
+* This intentionally supports only bold (`**text**`) because the SDK/content
+* import paths use it for lightweight default content, not full markdown.
+*/
+function parseRichTextInlineMarkdown(text) {
+	const out = [];
+	const pushText = (value, marks) => {
+		if (!value) return;
+		out.push(marks && marks.length > 0 ? {
+			type: "text",
+			text: value,
+			marks
+		} : {
+			type: "text",
+			text: value
+		});
+	};
+	let rest = text;
+	while (rest.length > 0) {
+		const start = rest.indexOf("**");
+		if (start === -1) {
+			pushText(rest);
+			break;
+		}
+		const end = rest.indexOf("**", start + 2);
+		if (end === -1) {
+			pushText(rest);
+			break;
+		}
+		pushText(rest.slice(0, start));
+		pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
+		rest = rest.slice(end + 2);
+	}
+	return out;
+}
+function parseRichTextParagraphInlineMarkdown(text) {
+	return text.split("\n").flatMap((line, index) => {
+		const lineNodes = parseRichTextInlineMarkdown(line.trim());
+		return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
+	});
+}
+/**
+* Convert a plain string with a tiny markdown subset to canonical TipTap JSON.
+*
+* Double newlines create semantic paragraphs. Single newlines remain inside the
+* current paragraph as TipTap `hardBreak` nodes for line-oriented content such
+* as addresses, opening hours, and contact details.
+*/
+function createRichTextDocFromMarkdown(markdown) {
+	const normalized = markdown.replace(/\r\n/g, "\n").trim();
+	if (!normalized) return {
+		type: "doc",
+		content: []
+	};
+	const paragraphs = normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+	return {
+		type: "doc",
+		content: paragraphs.map((paragraph) => {
+			const inline = parseRichTextParagraphInlineMarkdown(paragraph);
+			return inline.length > 0 ? {
+				type: "paragraph",
+				content: inline
+			} : { type: "paragraph" };
+		})
+	};
+}
+function buildRichTextSchema(options) {
+	let schema = RichTextDocSchema;
+	if (options?.required) {
+		const label = options.label ?? "This field";
+		schema = schema.refine((val) => {
+			const content = val.content;
+			if (!Array.isArray(content) || content.length === 0) return false;
+			const first = content[0];
+			if (content.length === 1 && isRecord$3(first) && first.type === "paragraph" && (!("content" in first) || first.content == null)) {
+				return false;
+			}
+			return true;
+		}, { message: `${label} is required` });
+	}
+	return schema;
+}
+
+//#endregion
+//#region ../content-model/src/title-resolution.ts
+/**
+* Content title resolution utilities.
+*
+* Provides a single source of truth for resolving display titles from content data.
+*/
+/**
+* Default fields to check when titleField is not configured.
+* Order matters - first match wins.
+*/
+const TITLE_FIELD_CANDIDATES = ["title", "name"];
+/**
+* Resolve title from content data using configured titleField with fallbacks.
+*
+* Resolution order:
+* 1. Explicit titleField (if configured)
+* 2. 'title' field
+* 3. 'name' field
+* 4. Fallback title
+*
+* @param content - Content data object
+* @param titleField - Configured title field ID (optional)
+* @param fallbackTitle - Fallback if no title found
+* @returns Resolved title string
+*/
+function resolveContentTitle(content, titleField, fallbackTitle) {
+	if (!content) return fallbackTitle;
+	const candidates = [titleField?.trim(), ...TITLE_FIELD_CANDIDATES].filter((f) => Boolean(f?.trim()));
+	for (const field of candidates) {
+		const value = content[field];
+		if (typeof value === "string") {
+			const trimmed = value.trim();
+			if (trimmed) return trimmed;
+		}
+	}
+	return fallbackTitle;
+}
+
+//#endregion
+//#region ../content-model/src/metadataConfig.ts
+const ROUTE_METADATA_MANIFEST = {
+	name: "content-entry-metadata",
+	version: "1.0.0",
+	title: "Details",
+	description: "",
+	component: "ContentEntryMetadata",
+	fields: [
+		{
+			id: "draftTitle",
+			type: "text",
+			label: "Title",
+			required: true,
+			multiline: false
+		},
+		{
+			id: "draftSlug",
+			type: "slug",
+			label: "Slug",
+			description: "Used in the URL.",
+			required: true,
+			sourceFieldId: "draftTitle",
+			statusFieldId: "draftStatus",
+			maxLength: 96,
+			ui: { showSlugPreview: true }
+		},
+		{
+			id: "draftStatus",
+			type: "select",
+			label: "Draft status",
+			description: "Schedule to publish automatically, or keep as draft.",
+			required: true,
+			defaultValue: "draft",
+			options: [
+				{
+					value: "draft",
+					label: "Draft"
+				},
+				{
+					value: "scheduled",
+					label: "Scheduled"
+				},
+				{
+					value: "published",
+					label: "Published"
+				},
+				{
+					value: "archived",
+					label: "Archived"
+				}
+			],
+			multiple: false
+		},
+		{
+			id: "scheduledPublishAt",
+			type: "datetime",
+			label: "Publish at",
+			description: "When scheduled, the entry will publish at this time.",
+			required: false,
+			ui: { visibleWhen: {
+				field: "draftStatus",
+				equals: "scheduled"
+			} }
+		},
+		{
+			id: "draftMetaTitle",
+			type: "text",
+			label: "Meta title",
+			description: "Used for SEO and social previews.",
+			multiline: true,
+			required: false,
+			ui: { showCharCount: { max: 60 } }
+		},
+		{
+			id: "draftMetaDescription",
+			type: "text",
+			label: "Meta description",
+			description: "Optional description for SEO and previews.",
+			required: false,
+			multiline: true,
+			ui: { showCharCount: { max: 160 } }
+		},
+		{
+			id: "ogImageId",
+			type: "text",
+			label: "Social image asset ID",
+			description: "Optional media asset ID used for social sharing.",
+			required: false,
+			multiline: false
+		}
+	],
+	slots: []
+};
+const METADATA_WORKFLOW_FIELDS = {
+	title: "draftTitle",
+	slug: "draftSlug",
+	status: "draftStatus",
+	publishAt: "scheduledPublishAt"
+};
+const HOMEPAGE_PAGE_ROUTE_SLUG = { kind: "homepage" };
+function asNonEmptyPageRouteSlug(value) {
+	return value;
+}
+function pageRouteSlugFromEditorValue(value) {
+	const slug = sanitizeSlug(value ?? "");
+	return slug.length > 0 ? {
+		kind: "slug",
+		value: asNonEmptyPageRouteSlug(slug)
+	} : HOMEPAGE_PAGE_ROUTE_SLUG;
+}
+function pageRouteSlugToEditorValue(slug) {
+	return slug.kind === "homepage" ? "" : slug.value;
+}
+function pageRouteSlugToStoredValue(slug) {
+	return slug.kind === "homepage" ? null : slug.value;
+}
+function isHomepagePageRouteSlug(slug) {
+	return slug.kind === "homepage";
+}
+function resolvePageRouteSlug(entry, currentSlug) {
+	if (entry.kind !== "routable") return null;
+	if (entry.draft.path === "/" || entry.published.path === "/") {
+		return HOMEPAGE_PAGE_ROUTE_SLUG;
+	}
+	if (currentSlug !== undefined) {
+		return pageRouteSlugFromEditorValue(currentSlug);
+	}
+	return pageRouteSlugFromEditorValue(entry.draft.slug);
+}
+const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE = {
+	event: [
+		"draftTitle",
+		"draftSlug",
+		"draftStatus",
+		"scheduledPublishAt"
+	],
+	course: [
+		"draftTitle",
+		"draftSlug",
+		"draftStatus",
+		"scheduledPublishAt"
+	],
+	product: [
+		"draftTitle",
+		"draftSlug",
+		"draftStatus",
+		"scheduledPublishAt"
+	],
+	"product-category": [
+		"draftTitle",
+		"draftSlug",
+		"draftStatus",
+		"scheduledPublishAt"
+	],
+	"team-member": [
+		"draftTitle",
+		"draftSlug",
+		"draftStatus",
+		"scheduledPublishAt"
+	]
+};
+const EMPTY_METADATA_FIELDS = [];
+function normalizeContentTypeKey(typeKey) {
+	if (typeof typeKey !== "string") return null;
+	const trimmed = typeKey.trim().toLowerCase();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function getManagedRouteMetadataFieldIdsForType(typeKey) {
+	const normalizedTypeKey = normalizeContentTypeKey(typeKey);
+	if (!normalizedTypeKey) return EMPTY_METADATA_FIELDS;
+	return ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE[normalizedTypeKey] ?? EMPTY_METADATA_FIELDS;
+}
+function isRouteMetadataFieldEditableForType(typeKey, fieldId) {
+	const managedFields = getManagedRouteMetadataFieldIdsForType(typeKey);
+	return !managedFields.includes(fieldId);
+}
+function getEditableRouteMetadataFieldIdsForType(typeKey) {
+	return ROUTE_METADATA_MANIFEST.fields.map((field) => String(field.id)).filter((fieldId) => isRouteMetadataFieldEditableForType(typeKey, fieldId));
+}
+function getRouteMetadataManifestForType(typeKey) {
+	return {
+		...ROUTE_METADATA_MANIFEST,
+		fields: ROUTE_METADATA_MANIFEST.fields.filter((field) => isRouteMetadataFieldEditableForType(typeKey, String(field.id)))
+	};
+}
+function getRouteMetadataManifestForContext(context) {
+	if (context.kind === "content") {
+		return getRouteMetadataManifestForType(context.typeKey);
+	}
+	const fields = isHomepagePageRouteSlug(context.routeSlug) ? ROUTE_METADATA_MANIFEST.fields.filter((field) => String(field.id) !== "draftSlug") : ROUTE_METADATA_MANIFEST.fields;
+	return {
+		...ROUTE_METADATA_MANIFEST,
+		fields
+	};
+}
+function deriveRouteMetadataPresentation(context, options = {}) {
+	const contextManifest = getRouteMetadataManifestForContext(context);
+	const manifest = options.omitTitle ? omitRouteTitleFieldFromManifest(contextManifest) : contextManifest;
+	if (context.kind === "content") {
+		return {
+			kind: "content",
+			manifest,
+			typeKey: normalizeContentTypeKey(context.typeKey)
+		};
+	}
+	if (context.routeSlug.kind === "homepage") {
+		return {
+			kind: "page-homepage",
+			manifest,
+			routeSlug: context.routeSlug
+		};
+	}
+	return {
+		kind: "page-routable",
+		manifest,
+		routeSlug: context.routeSlug
+	};
+}
+/**
+* Remove the legacy route title editor from a route metadata manifest.
+*
+* Entry titles are now derived from entry data (single source of truth) and the route title is a denormalized copy.
+* We still keep `draftTitle` in the underlying manifest for page creation flows, but we omit it from entry editors.
+*/
+function omitRouteTitleFieldFromManifest(manifest) {
+	const fields = (manifest.fields ?? []).filter((field) => String(field.id) !== "draftTitle").map((field) => {
+		if (field && typeof field === "object" && "sourceFieldId" in field) {
+			const sourceFieldId = field.sourceFieldId;
+			if (String(sourceFieldId) === "draftTitle") {
+				return {
+					...field,
+					sourceFieldId: undefined
+				};
+			}
+		}
+		return field;
+	});
+	return {
+		...manifest,
+		fields
+	};
+}
+function sanitizeSlug(value) {
+	if (!value) return "";
+	return value.split("/").map((segment) => normalizeSlugSegment(segment)).filter(Boolean).join("/");
+}
+function normalizeSlugSegment(segment) {
+	const normalized = segment.trim().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return normalized;
+}
+
+//#endregion
+//#region ../content-model/src/referenceFields.ts
+const BUILT_IN_REFERENCE_KINDS = [
+	"post",
+	"form",
+	"bookingForm",
+	"appointmentService",
+	"appointmentResource",
+	"page",
+	"newsletterList",
+	"mailchimpAudience"
+];
+const builtInReferenceKindSet = new Set(BUILT_IN_REFERENCE_KINDS);
+function isBuiltInReferenceKind(referenceKind) {
+	return builtInReferenceKindSet.has(referenceKind);
+}
+function isDynamicContentReferenceKind(referenceKind) {
+	return parseReferenceKind(referenceKind).kind === "dynamicContent";
+}
+function isAdapterReferenceKind(referenceKind) {
+	const parsed = parseReferenceKind(referenceKind);
+	return parsed.kind === "builtIn" || parsed.kind === "dynamicContent";
+}
+function parseReferenceContentTypeKey(contentTypeKey) {
+	const trimmed = contentTypeKey.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parseReferenceKind(referenceKind) {
+	if (isBuiltInReferenceKind(referenceKind)) {
+		return {
+			kind: "builtIn",
+			referenceKind
+		};
+	}
+	if (referenceKind.startsWith("content:")) {
+		const contentTypeKey = parseReferenceContentTypeKey(referenceKind.slice("content:".length));
+		if (contentTypeKey) {
+			return {
+				kind: "dynamicContent",
+				referenceKind: `content:${contentTypeKey}`,
+				contentTypeKey
+			};
+		}
+	}
+	return {
+		kind: "unsupported",
+		referenceKind
+	};
+}
+
+//#endregion
+//#region ../content-model/src/contentManifest.ts
+const CONTENT_MODEL_ICON_PICKER_PRESETS = ["cta", "feature"];
+function assertNever$1(value) {
+	throw new Error(`Unhandled content field mapping decision: ${JSON.stringify(value)}`);
+}
+function resolveContentReferenceKind(field) {
+	return field.referenceKind ?? field.reference?.type ?? null;
+}
+function resolveReferenceFieldMapping(referenceKind, context = {}, valueFrom = "identifier") {
+	if (referenceKind === null) {
+		return { kind: "missingReferenceKind" };
+	}
+	if (isAdapterReferenceKind(referenceKind)) {
+		return {
+			kind: "adapterReference",
+			referenceKind
+		};
+	}
+	if (context.referenceContentTypeKeys && !context.referenceContentTypeKeys.includes(referenceKind)) {
+		return {
+			kind: "unresolvedReference",
+			referenceKind
+		};
+	}
+	return {
+		kind: "contentEntryReference",
+		contentType: referenceKind,
+		valueFrom
+	};
+}
+const DEFAULT_BUTTON_VARIANTS = [
+	{
+		value: "primary",
+		label: "Primary"
+	},
+	{
+		value: "secondary",
+		label: "Secondary"
+	},
+	{
+		value: "outline",
+		label: "Outline"
+	}
+];
+const DISPLAY_MEDIA_KINDS$1 = [
+	"image",
+	"video",
+	"audio"
+];
+function toFieldDefinition(field, context = {}) {
+	const label = field.label ?? startCase(field.id);
+	const base = {
+		id: field.id,
+		label,
+		description: field.description ?? undefined,
+		required: field.required ?? false,
+		visibleRoles: undefined,
+		defaultValue: field.defaultValue,
+		ui: normalizeFieldUi(field.ui)
+	};
+	switch (field.type) {
+		case "text": return {
+			...base,
+			type: "text",
+			multiline: Boolean(field.multiline),
+			maxLength: field.maxLength
+		};
+		case "textarea": return {
+			...base,
+			type: "text",
+			multiline: true,
+			maxLength: field.maxLength
+		};
+		case "number": return {
+			...base,
+			type: "number",
+			min: field.min,
+			max: field.max,
+			step: field.step
+		};
+		case "richText": return {
+			...base,
+			type: "richText"
+		};
+		case "media": return {
+			...base,
+			type: "media",
+			mediaKinds: normalizeDisplayMediaKinds(field.mediaKinds)
+		};
+		case "file": return {
+			...base,
+			type: "file",
+			fileKinds: field.fileKinds && field.fileKinds.length ? field.fileKinds : [
+				"document",
+				"spreadsheet",
+				"archive",
+				"audio"
+			]
+		};
+		case "boolean": return {
+			...base,
+			type: "boolean"
+		};
+		case "date": return {
+			...base,
+			type: "date"
+		};
+		case "datetime": return {
+			...base,
+			type: "datetime"
+		};
+		case "url": return {
+			...base,
+			type: "url",
+			allowRelative: field.allowRelative ?? false
+		};
+		case "select": {
+			const options = field.options ?? [];
+			if (!options.length) return null;
+			return {
+				...base,
+				type: "select",
+				options: options.map((option) => ({
+					value: option.value,
+					label: option.label ?? option.value
+				})),
+				multiple: Boolean(field.multiple)
+			};
+		}
+		case "reference": {
+			const referenceKind = resolveContentReferenceKind(field);
+			const mapping = resolveReferenceFieldMapping(referenceKind, context, field.valueFrom ?? "identifier");
+			switch (mapping.kind) {
+				case "adapterReference":
+				case "unresolvedReference": return {
+					...base,
+					type: "reference",
+					referenceKind: mapping.referenceKind,
+					allowManualEntry: false
+				};
+				case "missingReferenceKind": return null;
+				case "contentEntryReference": return {
+					...base,
+					type: "entryPicker",
+					fixedContentType: mapping.contentType,
+					valueFrom: mapping.valueFrom
+				};
+				default: return assertNever$1(mapping);
+			}
+		}
+		case "link": return {
+			...base,
+			type: "link"
+		};
+		case "button": {
+			const buttonContext = { variants: context.buttonVariants };
+			return expandButtonFieldGroup(field.id, label, buttonContext);
+		}
+		case "group": {
+			const nestedFields$1 = (field.fields ?? field.schema?.fields ?? []).map((f) => toFieldDefinition(f, context)).filter((f) => f !== null);
+			if (!nestedFields$1.length) return null;
+			return {
+				id: field.id,
+				label,
+				description: field.description ?? undefined,
+				required: field.required ?? false,
+				type: "group",
+				ui: normalizeFieldUi(field.ui),
+				schema: { fields: nestedFields$1 }
+			};
+		}
+		case "repeater": {
+			const nestedFields$1 = (field.fields ?? field.schema?.fields ?? []).map((f) => toFieldDefinition(f, context)).filter((f) => f !== null);
+			if (!nestedFields$1.length) return null;
+			return {
+				id: field.id,
+				label,
+				description: field.description ?? undefined,
+				required: field.required ?? false,
+				type: "repeater",
+				ui: normalizeFieldUi(field.ui),
+				itemLabel: field.itemLabel ?? "Item",
+				schema: { fields: nestedFields$1 }
+			};
+		}
+		default: return null;
+	}
+}
+function normalizeDisplayMediaKinds(mediaKinds) {
+	const displayKinds = (mediaKinds ?? []).filter(isDisplayMediaKind$1);
+	return displayKinds.length > 0 ? displayKinds : ["image"];
+}
+function isDisplayMediaKind$1(value) {
+	return DISPLAY_MEDIA_KINDS$1.includes(value);
+}
+function startCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]/g, " ").replace(/\s+/g, " ").replace(/^./, (match) => match.toUpperCase());
+}
+/**
+* Maps a content type schema to form field definitions.
+*
+* @param schema - The content type schema
+* @param context - Optional context with theme variants for button fields
+* @returns Array of field definitions for form rendering
+*/
+function mapContentSchemaToFormFields(schema, context = {}) {
+	const fields = [];
+	for (const field of schema.fields ?? []) {
+		const definition = toFieldDefinition(field, context);
+		if (definition) {
+			fields.push(definition);
+		}
+	}
+	return fields;
+}
+function expandButtonFieldGroup(fieldId, fieldLabel, context = {}) {
+	const variants = context.variants ?? [...DEFAULT_BUTTON_VARIANTS];
+	const mainFields = [
+		{
+			id: "label",
+			type: "text",
+			label: "Label",
+			required: true,
+			multiline: false,
+			ui: { row: "primary" }
+		},
+		{
+			id: "variant",
+			type: "select",
+			label: "Style",
+			options: variants.map((variant) => ({ ...variant })),
+			required: false,
+			multiple: false,
+			ui: { row: "primary" }
+		},
+		{
+			id: "link",
+			type: "link",
+			label: "Link",
+			required: true,
+			ui: { colSpan: 2 }
+		}
+	];
+	return {
+		id: fieldId,
+		type: "group",
+		label: fieldLabel,
+		required: false,
+		ui: {
+			layout: "grid",
+			columns: 2
+		},
+		schema: { fields: [...mainFields, {
+			id: "icons",
+			type: "group",
+			label: "Icons",
+			required: false,
+			ui: {
+				preset: "disclosure",
+				colSpan: 2
+			},
+			schema: { fields: [{
+				id: "iconLeft",
+				type: "text",
+				label: "Left icon",
+				required: false,
+				multiline: false,
+				ui: {
+					widget: "iconPicker",
+					iconPickerPreset: "cta"
+				}
+			}, {
+				id: "iconRight",
+				type: "text",
+				label: "Right icon",
+				required: false,
+				multiline: false,
+				ui: {
+					widget: "iconPicker",
+					iconPickerPreset: "cta"
+				}
+			}] }
+		}] }
+	};
+}
+function normalizeFieldUi(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return value;
+}
+
+//#endregion
+//#region ../content-model/src/routeTemplate.ts
+const ROUTE_TEMPLATE_SLUG_SEGMENT = "{slug}";
+var InvalidRouteTemplateError = class extends Error {
+	constructor(error) {
+		super(describeRouteTemplateParseError(error));
+		this.name = "InvalidRouteTemplateError";
+		this.error = error;
+	}
+};
+function safeParseRouteTemplate(routePattern) {
+	if (routePattern === null || routePattern === "") {
+		return {
+			success: true,
+			routeTemplate: { kind: "fallback-slug" }
+		};
+	}
+	const segments = splitRouteSegments(routePattern);
+	const slugSegmentIndices = segments.flatMap((segment, index) => segment === ROUTE_TEMPLATE_SLUG_SEGMENT ? [index] : []);
+	if (slugSegmentIndices.length > 1) {
+		return {
+			success: false,
+			error: {
+				code: "multiple-slug-segments",
+				routePattern,
+				segment: ROUTE_TEMPLATE_SLUG_SEGMENT
+			}
+		};
+	}
+	const invalidSegment = segments.find((segment) => segment !== ROUTE_TEMPLATE_SLUG_SEGMENT && isUnsupportedDynamicSegment(segment));
+	if (invalidSegment) {
+		return {
+			success: false,
+			error: {
+				code: invalidSegment.startsWith(":") ? "legacy-dynamic-segment" : "unsupported-dynamic-segment",
+				routePattern,
+				segment: invalidSegment
+			}
+		};
+	}
+	if (slugSegmentIndices.length === 1) {
+		const [prefix = "", suffix = ""] = routePattern.split(ROUTE_TEMPLATE_SLUG_SEGMENT);
+		const slugIndex = slugSegmentIndices[0] ?? 0;
+		return {
+			success: true,
+			routeTemplate: {
+				kind: "slug-template",
+				routePattern,
+				prefix,
+				suffix,
+				prefixSegments: segments.slice(0, slugIndex),
+				suffixSegments: segments.slice(slugIndex + 1)
+			}
+		};
+	}
+	return {
+		success: true,
+		routeTemplate: {
+			kind: "fixed-path",
+			routePattern,
+			path: routePattern
+		}
+	};
+}
+function parseRouteTemplate(routePattern) {
+	const result = safeParseRouteTemplate(routePattern);
+	if (result.success) {
+		return result.routeTemplate;
+	}
+	throw new InvalidRouteTemplateError(result.error);
+}
+function isSlugTemplate(routeTemplate) {
+	return routeTemplate.kind === "slug-template";
+}
+function fixedPathOrNull(routeTemplate) {
+	return routeTemplate.kind === "fixed-path" ? routeTemplate.path : null;
+}
+/** Returns the first path segment, or undefined when the template has no fixed prefix segment. */
+function getRouteTemplatePrefix(routeTemplate) {
+	switch (routeTemplate.kind) {
+		case "fallback-slug": return undefined;
+		case "fixed-path": {
+			const fixedSegments = routeTemplate.path.split("/").filter((segment) => segment.length > 0);
+			return fixedSegments[0];
+		}
+		case "slug-template": return routeTemplate.prefixSegments[0];
+	}
+}
+function expandSlug(routeTemplate, slug) {
+	switch (routeTemplate.kind) {
+		case "fallback-slug": return `/${slug}`;
+		case "fixed-path": return routeTemplate.path;
+		case "slug-template": return `${routeTemplate.prefix}${slug}${routeTemplate.suffix}`;
+	}
+}
+function buildContentEntryRoutePath(input) {
+	return expandSlug(parseRouteTemplate(input.routePattern), input.slug);
+}
+function describeRouteTemplateParseError(error) {
+	switch (error.code) {
+		case "legacy-dynamic-segment": return `Route pattern "${error.routePattern}" uses unsupported dynamic segment "${error.segment ?? ":slug"}". Use "${ROUTE_TEMPLATE_SLUG_SEGMENT}" as a full path segment.`;
+		case "multiple-slug-segments": return `Route pattern "${error.routePattern}" must not contain "${ROUTE_TEMPLATE_SLUG_SEGMENT}" more than once.`;
+		case "unsupported-dynamic-segment": return `Route pattern "${error.routePattern}" contains unsupported dynamic segment "${error.segment ?? ""}". Route patterns may only use "${ROUTE_TEMPLATE_SLUG_SEGMENT}" as a full path segment.`;
+	}
+}
+function splitRouteSegments(routePattern) {
+	return routePattern.split("/").filter((segment) => segment.length > 0);
+}
+function isUnsupportedDynamicSegment(segment) {
+	return segment.startsWith(":") || segment.includes("{") || segment.includes("}");
+}
+
+//#endregion
+//#region ../content-model/src/definitions/canonicalizePageRouteMetadata.ts
+function normalizePathInput(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function canonicalizePageRoutePair(input, routing, options) {
+	const normalizedPath = normalizePathInput(input.path);
+	if (normalizedPath !== null) {
+		const slug$1 = routing.toSlug(normalizedPath);
+		return {
+			path: routing.buildRoutePath(slug$1),
+			slug: slug$1
+		};
+	}
+	const trimmedInputSlug = typeof input.slug === "string" ? input.slug.trim() : "";
+	const trimmedFallbackSlug = typeof options.fallbackSlug === "string" ? options.fallbackSlug.trim() : "";
+	const rawSlug = trimmedInputSlug.length > 0 ? trimmedInputSlug : trimmedFallbackSlug;
+	const slug = routing.sanitize(rawSlug);
+	if (slug.length > 0) {
+		return {
+			path: routing.buildRoutePath(slug),
+			slug
+		};
+	}
+	if (options.allowMissing) {
+		return {
+			path: null,
+			slug: null
+		};
+	}
+	return {
+		path: routing.buildRoutePath(""),
+		slug: ""
+	};
+}
+/**
+* Normalize routable page metadata into one editor/store-facing representation.
+*
+* Contract:
+* - Prefer explicit paths when present, deriving slugs from those paths so `/`, `''`, and persisted `NULL` homepage
+*   variants collapse to the same draft/published shape.
+* - Preserve a missing published route as `{ path: null, slug: null }` so callers can distinguish "never published"
+*   from "published homepage".
+* - Always return a concrete draft route for editor state, using `draftFallbackSlug` when both draft path and slug
+*   are absent.
+*
+* This helper intentionally returns homepage slugs as empty strings for editor/store use. DB-facing callers that store
+* homepage slugs as `NULL` should map the output through `toStoredPageRouteSlug()`.
+*/
+function canonicalizePageRouteMetadata(input, routing, options = {}) {
+	const published = canonicalizePageRoutePair({
+		path: input.publishedPath,
+		slug: input.publishedSlug
+	}, routing, { allowMissing: true });
+	const draft = canonicalizePageRoutePair({
+		path: input.draftPath,
+		slug: input.draftSlug ?? published.slug
+	}, routing, {
+		allowMissing: false,
+		fallbackSlug: options.draftFallbackSlug
+	});
+	return {
+		draft: {
+			path: draft.path ?? routing.buildRoutePath(""),
+			slug: draft.slug ?? ""
+		},
+		published
+	};
+}
+/**
+* Convert editor/store-facing page slugs back into the DB storage convention.
+*
+* Homepage slugs are stored as `NULL` in `site_routes`, while editor state uses empty strings to represent the
+* homepage. This helper trims incidental whitespace and returns `null` for empty homepage-equivalent values.
+*/
+function toStoredPageRouteSlug(slug) {
+	return pageRouteSlugToStoredValue(pageRouteSlugFromEditorValue(slug));
+}
+
+//#endregion
+//#region ../content-model/src/definitions/shared.ts
+function createRoutingHelpers(schema, options = {}) {
+	const rawPrefix = schema.routing?.prefix ?? "/";
+	const slugPrefix = ensureSlugPrefix(rawPrefix);
+	const normalizedPrefix = normalizeRoutePrefix(slugPrefix);
+	const routePattern = schema.routing?.pattern ?? (schema.routing?.enabled ? "/{slug}" : undefined) ?? null;
+	const routeTemplate = parseRouteTemplate(routePattern);
+	const defaultSlug = options.slug ?? null;
+	const sanitize = (value) => sanitizeSlug(value ?? "");
+	const toSlug = (input) => {
+		if (!input) return "";
+		let normalized = input.trim();
+		if (!normalized) return "";
+		const sanitized = sanitize(normalized);
+		let result = sanitized;
+		if (result.startsWith(slugPrefix)) {
+			result = result.slice(slugPrefix.length);
+		}
+		const prefixed = normalizedPrefix !== "/" ? `${normalizedPrefix}/` : "/";
+		if (prefixed !== "/" && result.startsWith(prefixed)) {
+			result = result.slice(prefixed.length);
+		}
+		if (normalizedPrefix !== "/" && !result.startsWith("/")) {
+			const prefixWithoutLeadingSlash = normalizedPrefix.slice(1) + "/";
+			if (result.startsWith(prefixWithoutLeadingSlash)) {
+				result = result.slice(prefixWithoutLeadingSlash.length);
+			}
+		}
+		if (prefixed === "/" && result.startsWith("/")) {
+			result = result.slice(1);
+		}
+		return result;
+	};
+	const toPath = (slug) => {
+		const cleaned = sanitize(slug);
+		if (!cleaned) {
+			return normalizedPrefix === "/" ? "/" : normalizedPrefix;
+		}
+		if (normalizedPrefix === "/") {
+			return `/${cleaned}`;
+		}
+		return `${normalizedPrefix}/${cleaned}`;
+	};
+	const buildRoutePath = (slug) => {
+		const cleaned = sanitize(slug);
+		const effectiveSlug = cleaned || defaultSlug || "";
+		if (routePattern) {
+			return expandSlug(routeTemplate, effectiveSlug);
+		}
+		return toPath(effectiveSlug);
+	};
+	return {
+		slugPrefix,
+		normalizedPrefix,
+		routePattern,
+		defaultSlug,
+		toSlug,
+		toPath,
+		buildRoutePath,
+		sanitize
+	};
+}
+function ensureSlugPrefix(prefix) {
+	const base = prefix?.trim();
+	if (!base) {
+		return "/";
+	}
+	const withLeading = base.startsWith("/") ? base : `/${base}`;
+	return withLeading.endsWith("/") ? withLeading : `${withLeading}/`;
+}
+function normalizeRoutePrefix(prefix) {
+	if (prefix === "/") return "/";
+	return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+/**
+* Build snapshot for routable content (content with an associated route)
+*/
+function buildRoutableSnapshot(entry, route, routing, defaults) {
+	const fallbackSlug = defaults.slug ?? routing.defaultSlug ?? "";
+	const rawDraftTitle = route.draftTitle ?? route.publishedTitle ?? null;
+	if (!rawDraftTitle || rawDraftTitle.trim().length === 0) {
+		throw new Error(`Missing draft title in route for entry ${entry.id}. Route data: ${JSON.stringify(route)}`);
+	}
+	const draftTitle = rawDraftTitle.trim();
+	const rawDraftSlug = route.draftSlug ?? fallbackSlug;
+	const draftSlug = routing.sanitize(rawDraftSlug);
+	const draftPath = route.draftPath ?? routing.toPath(draftSlug);
+	const draftStatus = route.draftStatus ?? "draft";
+	const publishAt = route.scheduledPublishAt ?? null;
+	const rawPublishedTitle = route.publishedTitle ?? route.draftTitle;
+	const publishedTitle = rawPublishedTitle ? rawPublishedTitle.trim() : null;
+	const publishedPath = route.publishedPath ?? null;
+	const publishedStatus = route.status ?? null;
+	const publishedAt = route.publishedAt ?? null;
+	const currentStatus = route.status ?? route.draftStatus ?? "draft";
+	return {
+		kind: "routable",
+		id: entry.id,
+		draft: {
+			title: draftTitle,
+			slug: draftSlug,
+			status: draftStatus,
+			publishAt,
+			path: draftPath
+		},
+		published: {
+			title: publishedTitle,
+			path: publishedPath,
+			status: publishedStatus ?? null,
+			publishAt: publishedAt ?? null
+		},
+		status: currentStatus ?? "draft",
+		route: {
+			draftMetaTitle: route.draftMetaTitle ?? null,
+			draftMetaDescription: route.draftMetaDescription ?? null,
+			publishedMetaTitle: route.publishedMetaTitle ?? null,
+			publishedMetaDescription: route.publishedMetaDescription ?? null,
+			ogImageId: route.ogImageId ?? null
+		}
+	};
+}
+/**
+* Build snapshot for non-routable content (content without a route, like testimonials)
+*/
+function buildNonRoutableSnapshot(entry, title) {
+	const safeTitle = title.trim() || "Untitled Entry";
+	const hasBeenPublished = !!entry.publishedVersionId;
+	const hasDraftVersionChanges = !!entry.publishedVersionId && !!entry.draftVersionId;
+	const lifecycleStatus = hasBeenPublished ? "published" : "draft";
+	return {
+		kind: "non-routable",
+		id: entry.id,
+		draft: {
+			title: safeTitle,
+			status: lifecycleStatus,
+			publishAt: null
+		},
+		published: {
+			title: hasBeenPublished ? safeTitle : null,
+			status: hasBeenPublished ? lifecycleStatus : null,
+			publishAt: null
+		},
+		status: lifecycleStatus,
+		hasDraftVersionChanges
+	};
+}
+function buildSnapshot(entry, route, routing, defaults) {
+	if (route !== null && route !== undefined) {
+		return buildRoutableSnapshot(entry, route, routing, defaults);
+	}
+	const title = defaults.title || "Untitled Entry";
+	return buildNonRoutableSnapshot(entry, title);
+}
+function createSnapshotFromContentEntry(data, routing, defaults, titleField) {
+	let resolvedDefaults = defaults;
+	if (!data.route && data.draftContent) {
+		const extractedTitle = resolveContentTitle(data.draftContent, titleField, "");
+		if (extractedTitle) {
+			resolvedDefaults = {
+				...defaults,
+				title: extractedTitle
+			};
+		}
+	}
+	return buildSnapshot(data.entry, data.route ?? null, routing, resolvedDefaults);
+}
+function createSnapshotFromRoutableContent(owner, route, routing, defaults) {
+	return buildSnapshot(owner, route, routing, defaults);
+}
+function createSnapshotFromPageRecord(record, routing, defaults) {
+	const canonicalRoute = canonicalizePageRouteMetadata({
+		draftPath: record.draftPath ?? null,
+		publishedPath: record.path ?? null
+	}, routing, { draftFallbackSlug: defaults.slug ?? null });
+	const routeLike = {
+		draftTitle: record.draftTitle ?? record.title ?? null,
+		draftPath: canonicalRoute.draft.path,
+		draftSlug: canonicalRoute.draft.slug,
+		draftStatus: record.draftStatus ?? null,
+		publishedTitle: record.title ?? null,
+		publishedPath: canonicalRoute.published.path,
+		publishedSlug: canonicalRoute.published.slug,
+		status: record.status ?? null,
+		publishedAt: record.publishedAt ?? null,
+		scheduledPublishAt: record.scheduledPublishAt ?? null,
+		draftMetaTitle: record.draftMetaTitle ?? null,
+		draftMetaDescription: record.draftMetaDescription ?? null,
+		publishedMetaTitle: record.publishedMetaTitle ?? null,
+		publishedMetaDescription: record.publishedMetaDescription ?? null,
+		ogImageId: record.ogImageId ?? null
+	};
+	return buildSnapshot({ id: record.id }, routeLike, routing, defaults);
+}
+function createMetadataStateFromSnapshot(snapshot) {
+	if (snapshot.kind === "non-routable") {
+		const empty = {};
+		return {
+			values: empty,
+			baseline: empty
+		};
+	}
+	const values = {
+		draftTitle: snapshot.draft.title,
+		draftSlug: snapshot.draft.slug,
+		draftStatus: snapshot.draft.status,
+		scheduledPublishAt: snapshot.draft.publishAt,
+		draftMetaTitle: snapshot.route.draftMetaTitle ?? null,
+		draftMetaDescription: snapshot.route.draftMetaDescription ?? null,
+		ogImageId: snapshot.route.ogImageId ?? null
+	};
+	return {
+		values,
+		baseline: { ...values }
+	};
+}
+/**
+* Extract published metadata values from a snapshot.
+* Used to set the publishedBaseline for unpublished changes detection.
+*
+* Returns null if the entry has never been published.
+*/
+function getPublishedMetadataFromSnapshot(snapshot, routing) {
+	if (snapshot.kind === "non-routable") {
+		return null;
+	}
+	const hasPublishedSignal = snapshot.published.status === "published" || Boolean(snapshot.published.publishAt);
+	if (!snapshot.published.title && !hasPublishedSignal) {
+		return null;
+	}
+	const publishedTitle = snapshot.published.title ?? snapshot.draft.title;
+	if (!publishedTitle) return null;
+	const publishedPath = snapshot.published.path ?? snapshot.draft.path ?? "";
+	const publishedSlug = routing ? routing.toSlug(publishedPath) : publishedPath ? publishedPath.replace(/^\//, "").replace(/\/$/, "") : "";
+	return {
+		draftTitle: publishedTitle,
+		draftSlug: publishedSlug,
+		draftStatus: snapshot.published.status ?? snapshot.draft.status ?? "draft",
+		scheduledPublishAt: null,
+		draftMetaTitle: snapshot.route.publishedMetaTitle ?? null,
+		draftMetaDescription: snapshot.route.publishedMetaDescription ?? null,
+		ogImageId: snapshot.route.ogImageId ?? null
+	};
+}
+function buildToolbarState(snapshot, context, options) {
+	const formatPublishMessage = ({ status, publishedAt, scheduledAt }) => {
+		if (status === "published") {
+			if (!publishedAt) return "Published";
+			const date = new Date(publishedAt);
+			if (Number.isNaN(date.getTime())) return "Published";
+			return `Published ${date.toLocaleString()}`;
+		}
+		if (status === "scheduled" && scheduledAt) {
+			const date = new Date(scheduledAt);
+			if (!Number.isNaN(date.getTime())) {
+				return `Scheduled for ${date.toLocaleString()}`;
+			}
+		}
+		return "Not yet published";
+	};
+	const { status: statusField } = METADATA_WORKFLOW_FIELDS;
+	const publishedMessage = formatPublishMessage({
+		status: snapshot.status,
+		publishedAt: snapshot.published.publishAt,
+		scheduledAt: snapshot.draft.publishAt
+	});
+	let publishLabel = `Publish ${options.entityLabel.toLowerCase()}`;
+	if (statusField && context.values[statusField] === "scheduled") {
+		publishLabel = "Schedule publish";
+	}
+	return {
+		currentStatus: snapshot.status,
+		publishLabel,
+		publishedMessage,
+		disablePublish: false,
+		disableDiscard: false,
+		values: context.values
+	};
+}
+
+//#endregion
+//#region ../content-model/src/content-types/schema.ts
+/**
+* Content field types supported in custom content types.
+*
+* - text, textarea, richText: Text-based fields
+* - number: Numeric input
+* - date, datetime: Date/time pickers
+* - media: Image/video uploads
+* - file: Public file uploads/downloads
+* - boolean: Toggle/checkbox
+* - select: Dropdown with options
+* - reference: Link to another content type
+* - link: URL/page link picker
+* - url: Plain URL input
+* - button: Expands to a group with label, variant, link, and icons
+* - group: Nested field container (for advanced use cases)
+*/
+const contentFieldTypes = [
+	"text",
+	"textarea",
+	"richText",
+	"number",
+	"date",
+	"url",
+	"media",
+	"file",
+	"boolean",
+	"select",
+	"reference",
+	"link",
+	"button",
+	"group",
+	"repeater",
+	"datetime"
+];
+const DISPLAY_MEDIA_KINDS = [
+	"image",
+	"video",
+	"audio"
+];
+const FILE_FIELD_KINDS = [
+	"document",
+	"spreadsheet",
+	"archive",
+	"audio"
+];
+const LEGACY_MEDIA_KINDS = [
+	"image",
+	"video",
+	"audio",
+	"document",
+	"spreadsheet",
+	"archive"
+];
+/**
+* Base content field schema (non-recursive properties)
+*/
+const BaseContentFieldSchema = z.object({
+	id: z.string(),
+	type: z.enum(contentFieldTypes),
+	label: z.string().optional(),
+	description: z.string().optional(),
+	required: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	multiline: z.boolean().optional(),
+	rows: z.number().int().positive().optional(),
+	maxLength: z.number().int().positive().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	step: z.number().positive().optional(),
+	mediaKinds: z.array(z.enum(LEGACY_MEDIA_KINDS)).optional(),
+	fileKinds: z.array(z.enum(FILE_FIELD_KINDS)).optional(),
+	allowRelative: z.boolean().optional(),
+	options: z.array(z.object({
+		value: z.string(),
+		label: z.string().optional()
+	})).optional(),
+	multiple: z.boolean().optional(),
+	referenceKind: z.string().trim().optional(),
+	reference: z.object({ type: z.string().trim() }).optional(),
+	valueFrom: z.enum([
+		"id",
+		"identifier",
+		"slug"
+	]).optional(),
+	ui: z.record(z.string(), z.unknown()).optional(),
+	itemLabel: z.string().optional()
+}).superRefine((field, ctx) => {
+	if ((field.type === "media" || field.type === "file") && field.defaultValue !== undefined && field.defaultValue !== null && (typeof field.defaultValue !== "object" || Array.isArray(field.defaultValue) || typeof field.defaultValue.identifier !== "string" || !field.defaultValue.identifier.trim())) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["defaultValue"],
+			message: `${field.type} defaultValue must be null or an object with a non-empty identifier`
+		});
+	}
+	if (field.multiple !== undefined && field.type !== "select") {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["multiple"],
+			message: "multiple is only valid for select fields"
+		});
+	}
+	if (field.type !== "reference") {
+		return;
+	}
+	const referenceKind = field.referenceKind;
+	const legacyReferenceType = field.reference?.type;
+	const effectiveReferenceKind$1 = referenceKind ?? legacyReferenceType;
+	if (field.referenceKind !== undefined && !referenceKind) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["referenceKind"],
+			message: "referenceKind must not be empty"
+		});
+	}
+	if (field.reference?.type !== undefined && !legacyReferenceType) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["reference", "type"],
+			message: "reference.type must not be empty"
+		});
+	}
+	if (referenceKind && legacyReferenceType && referenceKind !== legacyReferenceType) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["referenceKind"],
+			message: "referenceKind must match reference.type when both are provided"
+		});
+	}
+	if (field.valueFrom !== undefined && effectiveReferenceKind$1 && isAdapterReferenceKind(effectiveReferenceKind$1)) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["valueFrom"],
+			message: "valueFrom is only valid for content entry reference fields"
+		});
+	}
+}).passthrough();
+const ContentFieldSchema = BaseContentFieldSchema.extend({
+	fields: z.lazy(() => z.array(ContentFieldSchema)).optional(),
+	schema: z.lazy(() => z.object({ fields: z.array(ContentFieldSchema).optional() }).passthrough()).optional()
+});
+const RoutingSchema = z.object({
+	enabled: z.boolean().default(false),
+	pattern: z.string().optional(),
+	slugField: z.string().optional(),
+	pathField: z.string().optional(),
+	prefix: z.string().optional(),
+	subroutes: z.array(z.object({
+		kind: z.string().min(1),
+		segmentType: z.enum([
+			"uuid",
+			"iso-date",
+			"uuid-or-date",
+			"slug"
+		]),
+		precedence: z.enum(["subroute-first", "content-first"]).optional()
+	})).optional()
+}).superRefine((routing, ctx) => {
+	if (!routing.pattern) {
+		return;
+	}
+	const parseResult = safeParseRouteTemplate(routing.pattern);
+	if (parseResult.success) {
+		return;
+	}
+	ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["pattern"],
+		message: describeRouteTemplateParseError(parseResult.error)
+	});
+});
+const LabelsSchema = z.object({
+	singular: z.string(),
+	plural: z.string()
+});
+const OrderingSchema = z.object({ mode: z.enum(["default", "manual"]).default("default") }).default({ mode: "default" });
+const ContentTypeSchemaZ = z.object({
+	version: z.number().default(1),
+	fields: z.array(ContentFieldSchema).default([]),
+	routing: RoutingSchema.optional(),
+	titleField: z.string().optional(),
+	widgets: z.record(z.string(), z.unknown()).optional(),
+	labels: LabelsSchema.default({
+		singular: "Entry",
+		plural: "Entries"
+	}),
+	ordering: OrderingSchema.optional()
+}).refine((data) => {
+	if (data.titleField) {
+		const fieldExists = data.fields.some((f) => f.id === data.titleField);
+		return fieldExists;
+	}
+	return true;
+}, {
+	message: "titleField must reference an existing field ID in the fields array",
+	path: ["titleField"]
+});
+function parseContentTypeSchema(input) {
+	if (!input || typeof input !== "object") {
+		throw new Error("[content-types] Missing or invalid schema payload");
+	}
+	const result = ContentTypeSchemaZ.safeParse(input);
+	if (!result.success) {
+		const message = result.error?.message ?? "Invalid content type schema";
+		throw new Error(`[content-types] ${message}`);
+	}
+	return {
+		...result.data,
+		fields: normalizeContentFields(result.data.fields ?? [])
+	};
+}
+function isManualEntryOrderingEnabled(schema) {
+	return schema?.ordering?.mode === "manual";
+}
+function normalizeContentFields(fields) {
+	return fields.map((field) => {
+		const schemaFields = field.schema?.fields ?? undefined;
+		const nextFields = field.fields ?? schemaFields;
+		const normalizedFields = nextFields ? normalizeContentFields(nextFields) : undefined;
+		const next = normalizeLegacyFileMediaField({
+			...field,
+			...normalizedFields ? { fields: normalizedFields } : {}
+		});
+		return next;
+	});
+}
+function normalizeLegacyFileMediaField(field) {
+	if (field.type !== "media") return field;
+	const mediaKinds = field.mediaKinds ?? [];
+	const displayKinds = mediaKinds.filter(isDisplayMediaKind);
+	const fileKinds = mediaKinds.filter(isFileFieldKind);
+	if (fileKinds.length === 0 || displayKinds.length > 0) {
+		return {
+			...field,
+			mediaKinds: displayKinds.length > 0 ? displayKinds : field.mediaKinds
+		};
+	}
+	const { mediaKinds: _legacyMediaKinds, ...rest } = field;
+	return {
+		...rest,
+		type: "file",
+		fileKinds
+	};
+}
+function isDisplayMediaKind(value) {
+	return DISPLAY_MEDIA_KINDS.includes(value);
+}
+function isFileFieldKind(value) {
+	return FILE_FIELD_KINDS.includes(value);
+}
+
+//#endregion
+//#region ../content-model/src/content-types/sentinels.ts
+/** Leaf field types that receive a placeholder sentinel (containers recurse). */
+const SENTINEL_LEAF_TYPES = [
+	"text",
+	"textarea",
+	"richText",
+	"number",
+	"date",
+	"datetime",
+	"url",
+	"link",
+	"media",
+	"file",
+	"boolean",
+	"select",
+	"reference"
+];
+/** Matches the closed sentinel shape `"<REQUIRED: …>"`. */
+const SENTINEL_PATTERN = /^<REQUIRED:.*>$/;
+/**
+* True when a value is an unfilled placeholder sentinel. Shared by the emitter
+* (self-check) and the validator (rejection) so recognition can't drift.
+*/
+function isPlaceholderSentinel(value) {
+	return typeof value === "string" && SENTINEL_PATTERN.test(value);
+}
+function effectiveReferenceKind(field) {
+	const kind = field.referenceKind;
+	const legacy = field.reference?.type;
+	return kind ?? legacy;
+}
+function selectOptionValues$1(field) {
+	const options = field.options;
+	return options ? options.map((o) => o.value) : [];
+}
+/**
+* The placeholder sentinel for a leaf field. Container types (group/button/
+* repeater) do not have a leaf sentinel — they expand structurally — and calling
+* this for them returns a generic marker only for completeness.
+*/
+function buildSentinel(field) {
+	switch (field.type) {
+		case "text":
+		case "textarea": return "<REQUIRED: text>";
+		case "richText": return "<REQUIRED: rich-text>";
+		case "number": return "<REQUIRED: number>";
+		case "date": return "<REQUIRED: date (YYYY-MM-DD)>";
+		case "datetime": return "<REQUIRED: datetime (ISO 8601)>";
+		case "url": return "<REQUIRED: url>";
+		case "link": return "<REQUIRED: link>";
+		case "media": return "<REQUIRED: media-identifier>";
+		case "file": return "<REQUIRED: file-identifier>";
+		case "boolean": return "<REQUIRED: boolean>";
+		case "select": {
+			const values = selectOptionValues$1(field);
+			return values.length > 0 ? `<REQUIRED: select (${values.join("|")})>` : "<REQUIRED: select>";
+		}
+		case "reference": {
+			const kind = effectiveReferenceKind(field);
+			return kind ? `<REQUIRED: reference-identifier (${kind})>` : "<REQUIRED: reference-identifier>";
+		}
+		case "group": return "<REQUIRED: group>";
+		case "button": return "<REQUIRED: button>";
+		case "repeater": return "<REQUIRED: repeater>";
+	}
+}
+/**
+* Deep-scan arbitrary entry data for any unfilled placeholder sentinels. Needs no
+* schema, so it powers the CLI's pre-HTTP upsert pre-flight.
+*/
+function findUnfilledSentinels(data, pathPrefix = "") {
+	const found = [];
+	const walk = (value, path) => {
+		if (isPlaceholderSentinel(value)) {
+			found.push({
+				path: path || "(root)",
+				value
+			});
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => walk(item, `${path}[${index}]`));
+			return;
+		}
+		if (value !== null && typeof value === "object") {
+			for (const [key, child] of Object.entries(value)) {
+				walk(child, path ? `${path}.${key}` : key);
+			}
+		}
+	};
+	walk(data, pathPrefix);
+	return found;
+}
+
+//#endregion
+//#region ../content-model/src/content-types/entryValidation.ts
+function subfieldsOf$1(field) {
+	const direct = field.fields;
+	if (direct && direct.length > 0) return direct;
+	const nested = field.schema?.fields;
+	return nested ?? [];
+}
+function repeaterVariantFields(field, item) {
+	const itemTypes = field.itemTypes;
+	if (!itemTypes) return subfieldsOf$1(field);
+	const typeId = item._type;
+	if (typeof typeId !== "string") return null;
+	return itemTypes[typeId]?.fields ?? null;
+}
+function selectOptionValues(field) {
+	const options = field.options;
+	return options ? options.map((o) => o.value) : [];
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const STRING_TYPES = new Set([
+	"text",
+	"textarea",
+	"url",
+	"link",
+	"reference",
+	"date",
+	"datetime",
+	"select"
+]);
+function isAllowedIdentifierBearingMedia(field, value) {
+	if (!isPlainObject(value) || typeof value.identifier !== "string" || value.identifier.trim().length === 0) {
+		return false;
+	}
+	if (value.type === undefined) return true;
+	const allowedKinds = field.type === "media" ? field.mediaKinds : field.fileKinds;
+	if (typeof value.type !== "string") return false;
+	const effectiveAllowedKinds = allowedKinds ?? (field.type === "media" ? ["image"] : ["document"]);
+	return effectiveAllowedKinds.some((kind) => kind === value.type);
+}
+function checkLeafType(field, value, path, errors) {
+	const push = (code, message) => {
+		errors.push({
+			path,
+			fieldType: field.type,
+			code,
+			message
+		});
+	};
+	if (field.type === "number") {
+		if (typeof value !== "number" || Number.isNaN(value)) {
+			push("wrong_type", `"${path}" must be a number.`);
+		}
+		return;
+	}
+	if (field.type === "boolean") {
+		if (typeof value !== "boolean") push("wrong_type", `"${path}" must be a boolean.`);
+		return;
+	}
+	if (field.type === "richText") {
+		if (typeof value !== "string" && !isPlainObject(value)) {
+			push("wrong_type", `"${path}" must be rich-text (string or document object).`);
+		}
+		return;
+	}
+	if (field.type === "media" || field.type === "file") {
+		if (isPlainObject(value) && isPlaceholderSentinel(value.identifier)) {
+			push("unfilled_placeholder", `"${path}" still contains an unfilled placeholder (${value.identifier}).`);
+			return;
+		}
+		if (!isAllowedIdentifierBearingMedia(field, value)) {
+			push("wrong_type", `"${path}" must be a media object with an identifier.`);
+		}
+		return;
+	}
+	if (field.type === "select") {
+		if (typeof value !== "string") {
+			push("wrong_type", `"${path}" must be a string.`);
+			return;
+		}
+		const options = selectOptionValues(field);
+		if (options.length > 0 && !options.includes(value)) {
+			push("invalid_option", `"${path}" must be one of: ${options.join(", ")}.`);
+		}
+		return;
+	}
+	if (STRING_TYPES.has(field.type)) {
+		if (typeof value !== "string") push("wrong_type", `"${path}" must be a string.`);
+	}
+}
+function validateField(field, value, path, errors, allowIncomplete) {
+	const missing = value === undefined || value === null || value === "";
+	if (missing) {
+		if (field.required === true && !allowIncomplete) {
+			errors.push({
+				path,
+				fieldType: field.type,
+				code: "missing_required",
+				message: `Required field "${path}" is missing.`
+			});
+		}
+		return;
+	}
+	if (isPlaceholderSentinel(value)) {
+		errors.push({
+			path,
+			fieldType: field.type,
+			code: "unfilled_placeholder",
+			message: `"${path}" still contains an unfilled placeholder (${value}).`
+		});
+		return;
+	}
+	if (field.type === "group" || field.type === "button") {
+		if (!isPlainObject(value)) {
+			errors.push({
+				path,
+				fieldType: field.type,
+				code: "wrong_type",
+				message: `"${path}" must be an object.`
+			});
+			return;
+		}
+		validateFields(subfieldsOf$1(field), value, path, errors, allowIncomplete);
+		return;
+	}
+	if (field.type === "repeater") {
+		if (!Array.isArray(value)) {
+			errors.push({
+				path,
+				fieldType: field.type,
+				code: "wrong_type",
+				message: `"${path}" must be an array.`
+			});
+			return;
+		}
+		value.forEach((item, index) => {
+			const itemPath = `${path}[${index}]`;
+			if (!isPlainObject(item)) {
+				errors.push({
+					path: itemPath,
+					fieldType: "repeater",
+					code: "wrong_type",
+					message: `"${itemPath}" must be an object.`
+				});
+				return;
+			}
+			const itemFields = repeaterVariantFields(field, item);
+			if (!itemFields) {
+				errors.push({
+					path: itemPath,
+					fieldType: "repeater",
+					code: "invalid_option",
+					message: `"${itemPath}" has an unknown or missing repeater item type.`
+				});
+				return;
+			}
+			validateFields(itemFields, item, itemPath, errors, allowIncomplete);
+		});
+		return;
+	}
+	checkLeafType(field, value, path, errors);
+}
+function validateFields(fields, data, pathPrefix, errors, allowIncomplete) {
+	for (const field of fields) {
+		const path = pathPrefix ? `${pathPrefix}.${field.id}` : field.id;
+		validateField(field, data[field.id], path, errors, allowIncomplete);
+	}
+}
+/**
+* Validate entry data against a content-type schema. Returns all errors so
+* callers can list everything an agent must fix in one pass.
+*/
+function validateEntryInstance(input) {
+	const errors = [];
+	validateFields(input.schema.fields, input.data, "", errors, input.allowIncomplete ?? false);
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+
+//#endregion
+//#region ../content-model/src/content-types/scaffold.ts
+/** Nested subfields for group/repeater/button-style fields (both DSL shapes). */
+function subfieldsOf(field) {
+	const direct = field.fields;
+	if (direct && direct.length > 0) return direct;
+	const nested = field.schema?.fields;
+	return nested ?? [];
+}
+function resourceKindForFieldType(fieldType) {
+	if (fieldType === "media") return "media";
+	if (fieldType === "file") return "file";
+	if (fieldType === "reference") return "reference";
+	return undefined;
+}
+const CONTAINER_TYPES = new Set([
+	"group",
+	"button",
+	"repeater"
+]);
+/**
+* Build the placeholder value for a required field. Group/button fields recurse
+* into their required subfields; repeaters emit a single seed item so agents see
+* the item shape.
+*/
+function buildFieldValue(field) {
+	if (field.type === "repeater") {
+		return [buildObjectFromFields(subfieldsOf(field))];
+	}
+	if (CONTAINER_TYPES.has(field.type)) {
+		const subfields = subfieldsOf(field);
+		if (subfields.length > 0) {
+			return buildObjectFromFields(subfields);
+		}
+		if (field.type === "button") {
+			return {
+				label: "<REQUIRED: text>",
+				link: "<REQUIRED: link>"
+			};
+		}
+		return {};
+	}
+	if (field.type === "media" || field.type === "file") {
+		return { identifier: buildSentinel(field) };
+	}
+	return buildSentinel(field);
+}
+/**
+* Build a template object from a list of fields, stubbing required fields and
+* omitting optional ones.
+*/
+function buildObjectFromFields(fields) {
+	const template = {};
+	for (const field of fields) {
+		if (field.required !== true) continue;
+		template[field.id] = buildFieldValue(field);
+	}
+	return template;
+}
+function diagnosticFromValidationError(error) {
+	const needsResource = resourceKindForFieldType(error.fieldType);
+	const message = needsResource === "media" ? `Provide an existing media identifier for "${error.path}".` : needsResource === "file" ? `Provide an existing file identifier for "${error.path}".` : needsResource === "reference" ? `Provide an existing entry identifier for "${error.path}".` : error.message;
+	return {
+		path: error.path,
+		fieldType: error.fieldType,
+		...needsResource ? { needsResource } : {},
+		message
+	};
+}
+/**
+* Emit a placeholder template + diagnostics for a content type from its field DSL.
+* Diagnostics come from the entry-instance validator run against the template,
+* merged with a sentinel sweep so no emitted placeholder goes unreported.
+*/
+function buildEntryScaffold(input) {
+	const template = buildObjectFromFields(input.schema.fields);
+	const { errors } = validateEntryInstance({
+		schema: input.schema,
+		data: template
+	});
+	const diagnostics = errors.map(diagnosticFromValidationError);
+	const seen = new Set(diagnostics.map((d) => d.path));
+	for (const sentinel of findUnfilledSentinels(template)) {
+		if (!seen.has(sentinel.path)) {
+			seen.add(sentinel.path);
+			diagnostics.push({
+				path: sentinel.path,
+				fieldType: "unknown",
+				message: `Replace the placeholder at "${sentinel.path}" (${sentinel.value}).`
+			});
+		}
+	}
+	return {
+		contentType: input.key,
+		template,
+		diagnostics,
+		ready: diagnostics.length === 0
+	};
+}
+
+//#endregion
+//#region ../content-model/src/content-types/defaults.ts
+function applyContentTypeDefaults(schema) {
+	return {
+		version: schema.version ?? 1,
+		fields: cloneFieldCollection(schema.fields ?? []),
+		routing: schema.routing ? { ...schema.routing } : undefined,
+		widgets: schema.widgets ? { ...schema.widgets } : undefined,
+		labels: schema.labels ? { ...schema.labels } : {
+			singular: "Entry",
+			plural: "Entries"
+		}
+	};
+}
+function getWorkflowFieldIds(schema) {
+	if (!schema.routing?.enabled) {
+		return [
+			null,
+			null,
+			null,
+			null
+		];
+	}
+	return [
+		"title",
+		"slug",
+		"status",
+		"publishAt"
+	];
+}
+function serializeContentTypeSchema(schema) {
+	return JSON.parse(JSON.stringify(applyContentTypeDefaults(schema)));
+}
+function cloneFieldCollection(collection) {
+	return JSON.parse(JSON.stringify(collection));
+}
+
+//#endregion
+//#region ../content-model/src/content-types/builtin-schemas.ts
+const POST_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "image",
+			type: "media",
+			label: "Featured image",
+			description: "Shown in the post hero and previews."
+		},
+		{
+			id: "excerpt",
+			type: "textarea",
+			label: "Excerpt",
+			description: "Short summary shown in listings.",
+			rows: 3
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Body",
+			description: "Write the full post content. Paragraphs are separated automatically.",
+			required: true,
+			ui: { richTextVariant: "media" }
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/blog/{slug}",
+		slugField: "slug",
+		prefix: "/blog/"
+	},
+	labels: {
+		singular: "Blog post",
+		plural: "Blog posts"
+	}
+};
+const EVENT_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "summary",
+			type: "textarea",
+			label: "Summary",
+			description: "Short teaser shown in listings.",
+			rows: 3
+		},
+		{
+			id: "image",
+			type: "media",
+			label: "Listing image",
+			description: "Optional image used for event cards and previews."
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Details",
+			description: "Full event details and agenda."
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/events/{slug}",
+		slugField: "slug",
+		prefix: "/events/",
+		subroutes: [{
+			kind: "event-occurrence",
+			segmentType: "uuid-or-date",
+			precedence: "subroute-first"
+		}]
+	},
+	labels: {
+		singular: "Event",
+		plural: "Events"
+	}
+};
+const COURSE_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "summary",
+			type: "textarea",
+			label: "Summary",
+			description: "Short teaser shown in listings.",
+			rows: 3
+		},
+		{
+			id: "image",
+			type: "media",
+			label: "Listing image",
+			description: "Optional image used for course cards and previews."
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Details",
+			description: "Full course details and curriculum."
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/courses/{slug}",
+		slugField: "slug",
+		prefix: "/courses/"
+	},
+	labels: {
+		singular: "Course",
+		plural: "Courses"
+	}
+};
+const TEAM_MEMBER_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "intro",
+			type: "textarea",
+			label: "Profile intro",
+			description: "A short opening paragraph for the profile page.",
+			rows: 3,
+			maxLength: 360
+		},
+		{
+			id: "bio",
+			type: "richText",
+			label: "Profile body",
+			description: "Longer profile story, approach, experience, and background."
+		},
+		{
+			id: "credentials",
+			type: "textarea",
+			label: "Credentials and training",
+			description: "Qualifications, training, or experience to highlight on the page.",
+			rows: 4
+		},
+		{
+			id: "specialties",
+			type: "textarea",
+			label: "Specialties and focus areas",
+			description: "Areas this team member works with most often.",
+			rows: 4
+		},
+		{
+			id: "pullQuote",
+			type: "textarea",
+			label: "Pull quote",
+			description: "Optional quote or short statement to feature on the page.",
+			rows: 2,
+			maxLength: 240
+		},
+		{
+			id: "ctaLabel",
+			type: "text",
+			label: "Call-to-action label",
+			description: "Optional button label for the profile page.",
+			maxLength: 80
+		},
+		{
+			id: "ctaHref",
+			type: "url",
+			label: "Call-to-action link",
+			description: "Optional internal or external link for the profile page button.",
+			allowRelative: true
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/team/{slug}",
+		slugField: "slug",
+		prefix: "/team/"
+	},
+	labels: {
+		singular: "Team member",
+		plural: "Team members"
+	}
+};
+const PRODUCT_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "summary",
+			type: "textarea",
+			label: "Summary",
+			description: "Short teaser shown in listings.",
+			rows: 3
+		},
+		{
+			id: "gallery",
+			type: "media",
+			label: "Listing image",
+			description: "Optional image used for product cards and previews."
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Details",
+			description: "Full product details and buying notes."
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/products/{slug}",
+		slugField: "slug",
+		prefix: "/products/"
+	},
+	labels: {
+		singular: "Product",
+		plural: "Products"
+	}
+};
+const TESTIMONIAL_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "name",
+			type: "text",
+			label: "Name",
+			description: "Who provided this testimonial?",
+			required: true,
+			maxLength: 120
+		},
+		{
+			id: "jobTitle",
+			type: "text",
+			label: "Job title",
+			description: "Optional title or role for the person.",
+			maxLength: 120
+		},
+		{
+			id: "company",
+			type: "text",
+			label: "Company",
+			description: "Optional company or organisation.",
+			maxLength: 120
+		},
+		{
+			id: "headshot",
+			type: "media",
+			label: "Headshot",
+			description: "Optional portrait or logo for this testimonial.",
+			mediaKinds: ["image"]
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Testimonial",
+			description: "Full testimonial text.",
+			required: true,
+			ui: { richTextVariant: "limited" }
+		}
+	],
+	routing: { enabled: false },
+	titleField: "name",
+	labels: {
+		singular: "Testimonial",
+		plural: "Testimonials"
+	}
+};
+const PAGE_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [],
+	routing: {
+		enabled: true,
+		pattern: "/{slug}",
+		slugField: "slug",
+		prefix: "/"
+	},
+	labels: {
+		singular: "Page",
+		plural: "Pages"
+	}
+};
+const PRODUCT_CATEGORY_CONTENT_TYPE_SCHEMA = {
+	version: 1,
+	fields: [
+		{
+			id: "summary",
+			type: "textarea",
+			label: "Summary",
+			description: "Short teaser shown above category product lists.",
+			rows: 3
+		},
+		{
+			id: "heroImage",
+			type: "media",
+			label: "Hero image",
+			description: "Optional category landing page image."
+		},
+		{
+			id: "body",
+			type: "richText",
+			label: "Body",
+			description: "Long-form category landing page content."
+		}
+	],
+	routing: {
+		enabled: true,
+		pattern: "/shop/{slug}",
+		slugField: "slug",
+		prefix: "/shop/"
+	},
+	labels: {
+		singular: "Product category",
+		plural: "Product categories"
+	}
+};
+
+//#endregion
+//#region ../content-model/src/content-types/builtins.ts
+/**
+* Built-in `ContentTypeSchema` registry. Keyed exhaustively on
+* `BuiltinContentTypeKey` via `satisfies` — adding a new builtin key
+* fails the compile here until a schema is provided. The `as const`
+* import preserves field literals so `BUILTIN_CONTENT_TYPE_FIELD_IDS`
+* below can derive an accurate per-builtin field set.
+*/
+const BUILTIN_CONTENT_TYPE_SCHEMAS = {
+	post: POST_CONTENT_TYPE_SCHEMA,
+	event: EVENT_CONTENT_TYPE_SCHEMA,
+	course: COURSE_CONTENT_TYPE_SCHEMA,
+	"team-member": TEAM_MEMBER_CONTENT_TYPE_SCHEMA,
+	product: PRODUCT_CONTENT_TYPE_SCHEMA,
+	testimonial: TESTIMONIAL_CONTENT_TYPE_SCHEMA,
+	page: PAGE_CONTENT_TYPE_SCHEMA,
+	"product-category": PRODUCT_CATEGORY_CONTENT_TYPE_SCHEMA
+};
+function deriveFieldIdSet(schema) {
+	return new Set(schema.fields.map((f) => f.id));
+}
+/**
+* Field-id sets for every built-in content type — DERIVED from
+* `BUILTIN_CONTENT_TYPE_SCHEMAS`, so adding a field to a schema flows
+* through automatically. The previous hand-maintained registry left
+* drift to a snapshot test; now drift is impossible.
+*
+* Kept exported with the same shape consumers were used to.
+*/
+const BUILTIN_CONTENT_TYPE_FIELD_IDS = {
+	post: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.post),
+	event: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.event),
+	course: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.course),
+	"team-member": deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS["team-member"]),
+	product: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.product),
+	testimonial: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.testimonial),
+	page: deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS.page),
+	"product-category": deriveFieldIdSet(BUILTIN_CONTENT_TYPE_SCHEMAS["product-category"])
+};
+const DOMAIN_BACKED_LINKED_ENTRY_REASON = "Domain-backed entries need a dedicated editor workflow.";
+/**
+* Preview editing support for built-in content entries when they appear as
+* linked data inside a block. Generic editorial content can use the shared
+* content-entry form; domain-backed content stays closed until its workflow
+* can preserve domain invariants such as occurrences, booking, or commerce.
+*/
+const BUILTIN_PREVIEW_LINKED_ENTRY_EDITING = {
+	post: { kind: "generic" },
+	event: {
+		kind: "unsupported-domain-backed",
+		reason: DOMAIN_BACKED_LINKED_ENTRY_REASON
+	},
+	course: {
+		kind: "unsupported-domain-backed",
+		reason: DOMAIN_BACKED_LINKED_ENTRY_REASON
+	},
+	"team-member": { kind: "generic" },
+	product: {
+		kind: "unsupported-domain-backed",
+		reason: DOMAIN_BACKED_LINKED_ENTRY_REASON
+	},
+	testimonial: { kind: "generic" },
+	page: { kind: "generic" },
+	"product-category": {
+		kind: "unsupported-domain-backed",
+		reason: DOMAIN_BACKED_LINKED_ENTRY_REASON
+	}
+};
+function getBuiltinPreviewLinkedEntryEditing(key) {
+	return BUILTIN_PREVIEW_LINKED_ENTRY_EDITING[key] ?? null;
+}
+
+//#endregion
+//#region ../content-model/src/content-types/labels.ts
+function getContentTypeLabelsFromSchema(schema, _fallbackName) {
+	return {
+		singular: schema.labels.singular,
+		plural: schema.labels.plural
+	};
+}
+
+//#endregion
+//#region ../field-primitives/src/bindings/index.ts
+const BINDING_TRANSFORMS = {
+	RICHTEXT_FIRST_PARAGRAPH: "richtext.firstParagraph",
+	DATE_FORMAT_SHORT: "date.formatShort",
+	DATE_FORMAT_LONG: "date.formatLong",
+	TEXT_INLINE_TEXT: "text.inlineText"
+};
+const BINDING_TRANSFORM_VALUES = Object.values(BINDING_TRANSFORMS);
+
+//#endregion
+//#region ../content-model/src/templates/types.ts
+const TEMPLATE_BINDING_TRANSFORMS = BINDING_TRANSFORMS;
+
+//#endregion
+//#region ../content-model/src/templates/bindingBuilders.ts
+function fieldBinding(path) {
+	return {
+		source: "field",
+		path
+	};
+}
+function metaBinding(path) {
+	return {
+		source: "meta",
+		path
+	};
+}
+function literalBinding(value) {
+	return {
+		source: "literal",
+		value
+	};
+}
+function transformBinding(transform, options = {}) {
+	return {
+		source: "transform",
+		transform,
+		...options.input === undefined ? {} : { input: options.input },
+		...options.path === undefined ? {} : { path: options.path }
+	};
+}
+function fallbackBinding(...options) {
+	return {
+		source: "fallback",
+		options: [...options]
+	};
+}
+
+//#endregion
+//#region ../content-model/src/entry-slots/types.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SLOT_KEY_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/;
+function unsafeAsSlotKey(value) {
+	return value;
+}
+function unsafeAsEntryBlockSlotId(value) {
+	return value;
+}
+function unsafeAsEntrySlotContentEntryId(value) {
+	return value;
+}
+function unsafeAsEntrySlotPageSurfaceId(value) {
+	return value;
+}
+function unsafeAsPageSurfaceSlotId(value) {
+	return value;
+}
+function unsafeAsEntrySlotPageId(value) {
+	return value;
+}
+function unsafeAsEntrySlotBlockId(value) {
+	return value;
+}
+function unsafeAsEntrySlotContentVersionId(value) {
+	return value;
+}
+function unsafeAsEntrySlotBlockOrderIndex(value) {
+	return value;
+}
+function parseSlotKey(value) {
+	if (typeof value !== "string") return err({ kind: "not-string" });
+	const normalized = value.trim();
+	if (!normalized) return err({ kind: "empty" });
+	if (!SLOT_KEY_PATTERN.test(normalized)) {
+		return err({
+			kind: "invalid-format",
+			value: normalized
+		});
+	}
+	return ok(unsafeAsSlotKey(normalized));
+}
+function parseEntryBlockSlotId(value) {
+	return parseUuidBrand(value, unsafeAsEntryBlockSlotId);
+}
+function parseEntrySlotPageSurfaceId(value) {
+	return parseUuidBrand(value, unsafeAsEntrySlotPageSurfaceId);
+}
+function parsePageSurfaceSlotId(value) {
+	return parseUuidBrand(value, unsafeAsPageSurfaceSlotId);
+}
+function parseUuidBrand(value, brand) {
+	if (typeof value !== "string") return err({ kind: "not-string" });
+	const normalized = value.trim().toLowerCase();
+	if (!normalized) return err({ kind: "empty" });
+	if (!UUID_PATTERN.test(normalized)) {
+		return err({
+			kind: "invalid-uuid",
+			value: normalized
+		});
+	}
+	return ok(brand(normalized));
+}
+function parseNonEmptyStringBrand(value, brand) {
+	if (typeof value !== "string") return err({ kind: "not-string" });
+	const normalized = value.trim();
+	if (!normalized) return err({ kind: "empty" });
+	return ok(brand(normalized));
+}
+const SYSTEM_ENTRY_SLOT_BLOCK_KIND = "system.entry-slot";
+const DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS = [
+	"block.body-text",
+	"block.rich-text",
+	"block.image-gallery",
+	"block.cta-full"
+];
+const TEMPLATE_ONLY_BLOCK_KINDS = [
+	SYSTEM_ENTRY_SLOT_BLOCK_KIND,
+	"block.event-details",
+	"block.event-registration"
+];
+function parseEntrySlotDefinitions(template) {
+	const definitions = [];
+	const seen = new Map();
+	for (const [blockIndex, block] of template.blocks.entries()) {
+		if (!isEntrySlotTemplateBlock(block)) continue;
+		const parsed = parseEntrySlotDefinition(block, blockIndex);
+		if (!parsed.ok) return parsed;
+		const firstBlockIndex = seen.get(parsed.value.slotKey);
+		if (firstBlockIndex !== undefined) {
+			return err({
+				kind: "duplicate-slot-key",
+				slotKey: parsed.value.slotKey,
+				firstBlockIndex,
+				blockIndex
+			});
+		}
+		seen.set(parsed.value.slotKey, blockIndex);
+		definitions.push(parsed.value);
+	}
+	return ok(definitions);
+}
+function isEntrySlotTemplateBlock(block) {
+	return block.blockKind === SYSTEM_ENTRY_SLOT_BLOCK_KIND;
+}
+function parseEntrySlotDefinition(block, blockIndex) {
+	if (block.scope !== "template") {
+		return err({
+			kind: "invalid-slot-scope",
+			blockIndex,
+			scope: block.scope
+		});
+	}
+	if (!isRecord$2(block.content)) {
+		return err({
+			kind: "invalid-slot-content",
+			blockIndex
+		});
+	}
+	const slotKeyResult = parseSlotKey(block.content.slotKey);
+	if (!slotKeyResult.ok) {
+		return err({
+			kind: "invalid-slot-key",
+			blockIndex,
+			error: slotKeyResult.error
+		});
+	}
+	const label = typeof block.content.label === "string" ? block.content.label.trim() : "";
+	if (!label) {
+		return err({
+			kind: "missing-label",
+			blockIndex,
+			slotKey: slotKeyResult.value
+		});
+	}
+	const allowedBlocks = parseAllowedBlocks(block.content.allowedBlocks, slotKeyResult.value, blockIndex);
+	if (!allowedBlocks.ok) return allowedBlocks;
+	return ok({
+		slotKey: slotKeyResult.value,
+		label,
+		allowedBlocks: allowedBlocks.value
+	});
+}
+function parseAllowedBlocks(value, slotKey, blockIndex) {
+	if (value === undefined) {
+		return ok({
+			kind: "default",
+			blockKinds: DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS
+		});
+	}
+	if (!Array.isArray(value)) {
+		return err({
+			kind: "invalid-allowed-blocks",
+			blockIndex,
+			slotKey
+		});
+	}
+	const allowedBlockValues = value;
+	if (allowedBlockValues.length === 0) {
+		return ok({
+			kind: "none",
+			blockKinds: []
+		});
+	}
+	const blockKinds = [];
+	const seen = new Set();
+	for (const blockKind of allowedBlockValues) {
+		if (typeof blockKind !== "string" || !blockKind.trim()) {
+			return err({
+				kind: "invalid-allowed-block-kind",
+				blockIndex,
+				slotKey,
+				value: blockKind
+			});
+		}
+		const normalized = blockKind.trim();
+		if (isTemplateOnlyBlockKind(normalized)) {
+			return err({
+				kind: "template-only-block-kind",
+				blockIndex,
+				slotKey,
+				blockKind: normalized
+			});
+		}
+		if (seen.has(normalized)) {
+			return err({
+				kind: "duplicate-allowed-block-kind",
+				blockIndex,
+				slotKey,
+				blockKind: normalized
+			});
+		}
+		seen.add(normalized);
+		blockKinds.push(normalized);
+	}
+	return ok({
+		kind: "restricted",
+		blockKinds
+	});
+}
+function validateBlockKindForEntrySlot(definition, blockKind) {
+	const normalized = blockKind.trim();
+	if (isTemplateOnlyBlockKind(normalized)) {
+		return err({
+			kind: "template-only-block-kind",
+			blockKind: normalized
+		});
+	}
+	if (definition.allowedBlocks.kind === "none") {
+		return err({
+			kind: "block-kind-not-allowed",
+			blockKind: normalized,
+			slotKey: definition.slotKey
+		});
+	}
+	if (!definition.allowedBlocks.blockKinds.includes(normalized)) {
+		return err({
+			kind: "block-kind-not-allowed",
+			blockKind: normalized,
+			slotKey: definition.slotKey
+		});
+	}
+	return ok(normalized);
+}
+function isTemplateOnlyBlockKind(blockKind) {
+	return blockKind.startsWith("system.") || TEMPLATE_ONLY_BLOCK_KINDS.includes(blockKind);
+}
+function resolveEntrySlotVisibility(input) {
+	const storedByKey = new Map();
+	for (const slot of input.storedSlots) {
+		storedByKey.set(slot.slotKey, slot);
+	}
+	const visible = input.definitions.map((definition) => ({
+		kind: "defined",
+		definition,
+		entrySlot: storedByKey.get(definition.slotKey) ?? null
+	}));
+	const definedKeys = new Set(input.definitions.map((definition) => definition.slotKey));
+	for (const slot of input.storedSlots) {
+		if (!definedKeys.has(slot.slotKey)) {
+			visible.push({
+				kind: "orphaned",
+				slotKey: slot.slotKey,
+				entrySlot: slot
+			});
+		}
+	}
+	return visible;
+}
+function resolveEntryPageCompositionState(slot) {
+	if (slot.kind === "orphaned") {
+		return {
+			kind: "invalid",
+			reason: "orphaned-slot"
+		};
+	}
+	if (!slot.entrySlot) return { kind: "absent" };
+	const { draftCompositionVersionId, publishedCompositionVersionId } = slot.entrySlot;
+	if (draftCompositionVersionId && publishedCompositionVersionId) {
+		return {
+			kind: "draft-and-published",
+			draftCompositionVersionId,
+			publishedCompositionVersionId
+		};
+	}
+	if (draftCompositionVersionId) return {
+		kind: "draft-only",
+		draftCompositionVersionId
+	};
+	if (publishedCompositionVersionId) return {
+		kind: "published-only",
+		publishedCompositionVersionId
+	};
+	return { kind: "absent" };
+}
+function selectBlocksForDeclaredEntrySlot(input) {
+	return input.entrySlots.find((slot) => slot.slotKey === input.declaredSlotKey)?.blocks ?? [];
+}
+function buildDraftEntrySlotCompositionVersionData(input) {
+	return {
+		schemaVersion: 1,
+		stage: "draft",
+		...input
+	};
+}
+function entrySlotCompositionOwnerFromV1(versionData) {
+	return {
+		kind: "entrySlot",
+		entrySlotId: versionData.entrySlotId,
+		contentEntryId: versionData.contentEntryId
+	};
+}
+function buildDraftSlotCompositionVersionData(input) {
+	return {
+		schemaVersion: 2,
+		stage: "draft",
+		...input
+	};
+}
+function buildPublishedEntrySlotCompositionVersionData(input) {
+	const published = filterPublishedSlotBlocks(input.blockSequence);
+	if (!published.ok) return published;
+	return ok({
+		schemaVersion: 1,
+		stage: "published",
+		entrySlotId: input.entrySlotId,
+		contentEntryId: input.contentEntryId,
+		slotKey: input.slotKey,
+		blockSequence: published.value
+	});
+}
+function buildPublishedSlotCompositionVersionData(input) {
+	const published = filterPublishedSlotBlocks(input.blockSequence);
+	if (!published.ok) return published;
+	return ok({
+		schemaVersion: 2,
+		stage: "published",
+		owner: input.owner,
+		slotKey: input.slotKey,
+		blockSequence: published.value
+	});
+}
+function filterPublishedSlotBlocks(blockSequence) {
+	for (const block of blockSequence) {
+		if (block.kind !== "published-block-content") {
+			return err({
+				kind: "published-composition-contains-unpublished-block",
+				blockId: block.blockId,
+				snapshotKind: block.kind
+			});
+		}
+	}
+	return ok(blockSequence.filter((block) => block.kind === "published-block-content"));
+}
+function parseEntrySlotCompositionVersionData(input) {
+	if (!isRecord$2(input)) return err({ kind: "not-object" });
+	if (input.schemaVersion !== 1) {
+		return err({
+			kind: "unsupported-schema-version",
+			schemaVersion: input.schemaVersion
+		});
+	}
+	const stage = parseSlotCompositionStage(input.stage);
+	if (!stage.ok) {
+		return err({
+			kind: "invalid-stage",
+			stage: input.stage
+		});
+	}
+	const entrySlotId = parseEntryBlockSlotId(input.entrySlotId);
+	if (!entrySlotId.ok) return err({
+		kind: "invalid-entry-slot-id",
+		error: entrySlotId.error
+	});
+	const contentEntryId = parseNonEmptyStringBrand(input.contentEntryId, unsafeAsEntrySlotContentEntryId);
+	if (!contentEntryId.ok) return err({
+		kind: "invalid-content-entry-id",
+		error: contentEntryId.error
+	});
+	const slotKey = parseSlotKey(input.slotKey);
+	if (!slotKey.ok) return err({
+		kind: "invalid-slot-key",
+		error: slotKey.error
+	});
+	const parsedBlockSequence = parseSlotCompositionBlockSequence(stage.value, input.blockSequence);
+	if (!parsedBlockSequence.ok) return parsedBlockSequence;
+	if (parsedBlockSequence.value.stage === "draft") {
+		return ok(buildDraftEntrySlotCompositionVersionData({
+			entrySlotId: entrySlotId.value,
+			contentEntryId: contentEntryId.value,
+			slotKey: slotKey.value,
+			blockSequence: parsedBlockSequence.value.blockSequence
+		}));
+	}
+	return ok({
+		schemaVersion: 1,
+		stage: "published",
+		entrySlotId: entrySlotId.value,
+		contentEntryId: contentEntryId.value,
+		slotKey: slotKey.value,
+		blockSequence: parsedBlockSequence.value.blockSequence
+	});
+}
+function parseSlotCompositionVersionData(input) {
+	if (!isRecord$2(input)) return err({ kind: "not-object" });
+	if (input.schemaVersion === 1) {
+		return parseEntrySlotCompositionVersionData(input);
+	}
+	if (input.schemaVersion !== 2) {
+		return err({
+			kind: "unsupported-schema-version",
+			schemaVersion: input.schemaVersion
+		});
+	}
+	const stage = parseSlotCompositionStage(input.stage);
+	if (!stage.ok) {
+		return err({
+			kind: "invalid-stage",
+			stage: input.stage
+		});
+	}
+	const owner = parseSlotCompositionOwner(input.owner);
+	if (!owner.ok) return err({
+		kind: "invalid-owner",
+		error: owner.error
+	});
+	const slotKey = parseSlotKey(input.slotKey);
+	if (!slotKey.ok) return err({
+		kind: "invalid-slot-key",
+		error: slotKey.error
+	});
+	const parsedBlockSequence = parseSlotCompositionBlockSequence(stage.value, input.blockSequence);
+	if (!parsedBlockSequence.ok) return parsedBlockSequence;
+	if (parsedBlockSequence.value.stage === "draft") {
+		return ok(buildDraftSlotCompositionVersionData({
+			owner: owner.value,
+			slotKey: slotKey.value,
+			blockSequence: parsedBlockSequence.value.blockSequence
+		}));
+	}
+	return ok({
+		schemaVersion: 2,
+		stage: "published",
+		owner: owner.value,
+		slotKey: slotKey.value,
+		blockSequence: parsedBlockSequence.value.blockSequence
+	});
+}
+function parseSlotCompositionStage(value) {
+	return value === "draft" || value === "published" ? ok(value) : err("invalid");
+}
+function parseSlotCompositionBlockSequence(stage, value) {
+	if (!Array.isArray(value)) return err({ kind: "invalid-block-sequence" });
+	const blockSequence = [];
+	const publishedBlockSequence = [];
+	for (const [index, snapshot] of value.entries()) {
+		const parsed = parseEntrySlotBlockSnapshot(snapshot);
+		if (!parsed.ok) return err({
+			kind: "invalid-block-snapshot",
+			index
+		});
+		if (stage === "published" && parsed.value.kind !== "published-block-content") {
+			return err({
+				kind: "published-composition-contains-unpublished-block",
+				index
+			});
+		}
+		if (parsed.value.kind === "published-block-content") {
+			publishedBlockSequence.push(parsed.value);
+		}
+		blockSequence.push(parsed.value);
+	}
+	return stage === "draft" ? ok({
+		stage,
+		blockSequence
+	}) : ok({
+		stage,
+		blockSequence: publishedBlockSequence
+	});
+}
+function parseSlotCompositionOwner(input) {
+	if (!isRecord$2(input)) return err({ kind: "not-object" });
+	if (input.kind === "entrySlot") {
+		const entrySlotId = parseEntryBlockSlotId(input.entrySlotId);
+		if (!entrySlotId.ok) return err({
+			kind: "invalid-entry-slot-id",
+			error: entrySlotId.error
+		});
+		const contentEntryId = parseNonEmptyStringBrand(input.contentEntryId, unsafeAsEntrySlotContentEntryId);
+		if (!contentEntryId.ok) return err({
+			kind: "invalid-content-entry-id",
+			error: contentEntryId.error
+		});
+		return ok({
+			kind: "entrySlot",
+			entrySlotId: entrySlotId.value,
+			contentEntryId: contentEntryId.value
+		});
+	}
+	if (input.kind === "surfaceSlot") {
+		const surfaceSlotId = parsePageSurfaceSlotId(input.surfaceSlotId);
+		if (!surfaceSlotId.ok) return err({
+			kind: "invalid-surface-slot-id",
+			error: surfaceSlotId.error
+		});
+		const pageSurfaceId = parseEntrySlotPageSurfaceId(input.pageSurfaceId);
+		if (!pageSurfaceId.ok) return err({
+			kind: "invalid-page-surface-id",
+			error: pageSurfaceId.error
+		});
+		return ok({
+			kind: "surfaceSlot",
+			surfaceSlotId: surfaceSlotId.value,
+			pageSurfaceId: pageSurfaceId.value
+		});
+	}
+	return err({
+		kind: "unsupported-owner-kind",
+		ownerKind: input.kind
+	});
+}
+function parseEntrySlotBlockSnapshot(input) {
+	if (!isRecord$2(input)) return err("invalid");
+	const blockId = parseNonEmptyStringBrand(input.blockId, unsafeAsEntrySlotBlockId);
+	const orderIndex = parseBlockOrderIndex(input.orderIndex);
+	const blockKind = typeof input.blockKind === "string" && input.blockKind.trim() ? input.blockKind.trim() : null;
+	const purpose = input.purpose === undefined ? "content" : typeof input.purpose === "string" && input.purpose.trim() ? input.purpose.trim() : null;
+	const identifier = input.identifier === null || input.identifier === undefined ? null : typeof input.identifier === "string" ? input.identifier : undefined;
+	if (!blockId.ok || !orderIndex.ok || !blockKind || !purpose || identifier === undefined) return err("invalid");
+	if (input.kind === "published-block-content") {
+		const contentVersionId = parseNonEmptyStringBrand(input.contentVersionId, unsafeAsEntrySlotContentVersionId);
+		if (!contentVersionId.ok) return err("invalid");
+		return ok({
+			kind: "published-block-content",
+			blockId: blockId.value,
+			contentVersionId: contentVersionId.value,
+			identifier,
+			blockKind,
+			purpose,
+			orderIndex: orderIndex.value
+		});
+	}
+	if (input.kind === "draft-block-content") {
+		const contentVersionId = input.contentVersionId === null ? ok(null) : parseNonEmptyStringBrand(input.contentVersionId, unsafeAsEntrySlotContentVersionId);
+		if (!contentVersionId.ok) return err("invalid");
+		return ok({
+			kind: "draft-block-content",
+			blockId: blockId.value,
+			contentVersionId: contentVersionId.value,
+			identifier,
+			blockKind,
+			purpose,
+			orderIndex: orderIndex.value
+		});
+	}
+	if (input.kind === "missing-block-content" && (input.reason === "new-block" || input.reason === "deleted-content-version" || input.reason === "unpublished-block")) {
+		return ok({
+			kind: "missing-block-content",
+			blockId: blockId.value,
+			identifier,
+			blockKind,
+			purpose,
+			orderIndex: orderIndex.value,
+			reason: input.reason
+		});
+	}
+	return err("invalid");
+}
+function parseBlockOrderIndex(value) {
+	if (!Number.isInteger(value) || typeof value !== "number" || value < 0) return err("invalid");
+	return ok(unsafeAsEntrySlotBlockOrderIndex(value));
+}
+function blockContentVersionIdsForEntrySlotCompositionVersionData(versionData) {
+	return blockContentVersionIdsForSlotCompositionVersionData(versionData);
+}
+function blockContentVersionIdsForSlotCompositionVersionData(versionData) {
+	return versionData.blockSequence.flatMap((block) => block.kind === "missing-block-content" || block.contentVersionId === null ? [] : [block.contentVersionId]);
+}
+function planEntrySlotPublish(input) {
+	if (input.slot.kind === "orphaned") {
+		return {
+			kind: "warning-only",
+			slotKey: input.slot.slotKey,
+			warning: "orphaned-slot-hidden"
+		};
+	}
+	const missingBlocks = input.draftBlockSequence.filter((block) => block.kind === "missing-block-content").map((block) => block.blockId);
+	if (missingBlocks.length > 0) {
+		return {
+			kind: "blocked",
+			slotKey: input.slot.definition.slotKey,
+			reason: "missing-block-content",
+			blockIds: missingBlocks
+		};
+	}
+	return {
+		kind: "publishable",
+		slotKey: input.slot.definition.slotKey,
+		needsBlockContentPublish: input.draftBlockSequence.some((block) => block.kind === "draft-block-content")
+	};
+}
+function planEntrySlotDiscard(slot) {
+	return slot.kind === "orphaned" ? {
+		kind: "skip-hidden-orphan",
+		slotKey: slot.slotKey
+	} : {
+		kind: "discardable",
+		slotKey: slot.definition.slotKey
+	};
+}
+function parseSdkEntryBlocksPatch(blocks) {
+	if (blocks === undefined) return ok({ kind: "leave-unchanged" });
+	if (!isRecord$2(blocks)) return err({ kind: "invalid-blocks-object" });
+	const slots = [];
+	for (const [rawSlotKey, rawBlocks] of Object.entries(blocks)) {
+		const slotKey = parseSlotKey(rawSlotKey);
+		if (!slotKey.ok) return err({
+			kind: "invalid-slot-key",
+			key: rawSlotKey,
+			error: slotKey.error
+		});
+		if (!Array.isArray(rawBlocks)) return err({
+			kind: "invalid-slot-blocks",
+			slotKey: slotKey.value
+		});
+		if (rawBlocks.length === 0) {
+			slots.push({
+				kind: "clear-slot",
+				slotKey: slotKey.value
+			});
+			continue;
+		}
+		const parsedBlocks = [];
+		const blockIndexByIdentifier = new Map();
+		for (const [blockIndex, rawBlock] of rawBlocks.entries()) {
+			const parsed = parseSdkEntrySlotBlockInput(rawBlock, slotKey.value, blockIndex);
+			if (!parsed.ok) return parsed;
+			if (parsed.value.identifier) {
+				const firstBlockIndex = blockIndexByIdentifier.get(parsed.value.identifier);
+				if (firstBlockIndex !== undefined) {
+					return err({
+						kind: "duplicate-block-identifier",
+						slotKey: slotKey.value,
+						identifier: parsed.value.identifier,
+						firstBlockIndex,
+						blockIndex
+					});
+				}
+				blockIndexByIdentifier.set(parsed.value.identifier, blockIndex);
+			}
+			parsedBlocks.push(parsed.value);
+		}
+		slots.push({
+			kind: "replace-slot",
+			slotKey: slotKey.value,
+			blocks: parsedBlocks
+		});
+	}
+	return ok({
+		kind: "patch-slots",
+		slots
+	});
+}
+function parseSdkEntrySlotBlockInput(input, slotKey, blockIndex) {
+	if (!isRecord$2(input)) return err({
+		kind: "invalid-block",
+		slotKey,
+		blockIndex
+	});
+	const blockKind = typeof input.kind === "string" ? input.kind.trim() : "";
+	if (!blockKind || !isRecord$2(input.content)) return err({
+		kind: "invalid-block",
+		slotKey,
+		blockIndex
+	});
+	if (isTemplateOnlyBlockKind(blockKind)) {
+		return err({
+			kind: "template-only-block-kind",
+			slotKey,
+			blockIndex,
+			blockKind
+		});
+	}
+	const identifier = input.identifier === undefined || input.identifier === null ? null : typeof input.identifier === "string" ? input.identifier.trim() : undefined;
+	if (identifier === undefined || identifier === "") return err({
+		kind: "invalid-block",
+		slotKey,
+		blockIndex
+	});
+	return ok({
+		identifier,
+		kind: blockKind,
+		content: input.content
+	});
+}
+function describeSdkEntryBlocksPatchParseError(error) {
+	switch (error.kind) {
+		case "invalid-blocks-object": return "Entry slot blocks payload must be an object";
+		case "invalid-slot-key": return `Entry slot key is invalid: ${error.key}`;
+		case "invalid-slot-blocks": return `Entry slot "${error.slotKey}" blocks must be an array`;
+		case "invalid-block": return `Entry slot "${error.slotKey}" block at index ${error.blockIndex} is invalid`;
+		case "duplicate-block-identifier": return `Entry slot "${error.slotKey}" has duplicate block identifier "${error.identifier}" at index ${error.blockIndex}; first used at index ${error.firstBlockIndex}`;
+		case "template-only-block-kind": return `Entry slot "${error.slotKey}" block at index ${error.blockIndex} uses template-only block type: ${error.blockKind}`;
+	}
+	const exhaustive = error;
+	return exhaustive;
+}
+function parseSlotContainerOwner(input) {
+	if (!isRecord$2(input)) return err({ kind: "not-object" });
+	if (input.kind === "contentEntry") {
+		const contentEntryId = parseNonEmptyStringBrand(input.contentEntryId, unsafeAsEntrySlotContentEntryId);
+		if (!contentEntryId.ok) {
+			return err({
+				kind: "invalid-content-entry-id",
+				error: contentEntryId.error
+			});
+		}
+		return ok({
+			kind: "contentEntry",
+			contentEntryId: contentEntryId.value
+		});
+	}
+	if (input.kind === "pageSurface") {
+		const pageSurfaceId = parseEntrySlotPageSurfaceId(input.pageSurfaceId);
+		if (!pageSurfaceId.ok) {
+			return err({
+				kind: "invalid-page-surface-id",
+				error: pageSurfaceId.error
+			});
+		}
+		return ok({
+			kind: "pageSurface",
+			pageSurfaceId: pageSurfaceId.value
+		});
+	}
+	return err({
+		kind: "unsupported-owner-kind",
+		ownerKind: input.kind
+	});
+}
+function slotContainerOwnerToContentVersionOwner(owner) {
+	return {
+		kind: "entry",
+		contentEntryId: owner.contentEntryId
+	};
+}
+function slotContainerOwnerToEntrySlotLookup(owner) {
+	return { contentEntryId: owner.contentEntryId };
+}
+function planSlotCompositionMutation(input) {
+	switch (input.mutation.kind) {
+		case "leaveUnchanged": return {
+			kind: "noChange",
+			owner: input.owner,
+			slotKey: input.slotKey
+		};
+		case "replaceDraftComposition": return {
+			kind: "replaceDraftComposition",
+			owner: input.owner,
+			slotKey: input.slotKey,
+			blocks: input.mutation.blocks
+		};
+		case "publishDraftComposition": return {
+			kind: "publishDraftComposition",
+			owner: input.owner,
+			slotKey: input.slotKey,
+			draftVersionId: input.mutation.draftVersionId
+		};
+		default: return assertNever(input.mutation);
+	}
+}
+function planSlotCompositionTransfer(input) {
+	if (sameSlotCompositionOwner(input.from, input.to)) {
+		return {
+			kind: "noChange",
+			owner: input.to,
+			slotKey: input.slotKey
+		};
+	}
+	if (input.to.kind !== "surfaceSlot") {
+		return {
+			kind: "manualReviewRequired",
+			reason: {
+				kind: "target-is-not-surface-slot",
+				targetKind: input.to.kind
+			}
+		};
+	}
+	switch (input.from.kind) {
+		case "entrySlot": return {
+			kind: "copyEntrySlotToSurfaceSlot",
+			from: input.from,
+			to: input.to,
+			slotKey: input.slotKey
+		};
+		case "surfaceSlot": return {
+			kind: "forkSurfaceSlotComposition",
+			from: input.from,
+			to: input.to,
+			slotKey: input.slotKey
+		};
+		default: return assertNever(input.from);
+	}
+}
+function sameSlotCompositionOwner(left, right) {
+	switch (left.kind) {
+		case "entrySlot": return right.kind === "entrySlot" && right.entrySlotId === left.entrySlotId && right.contentEntryId === left.contentEntryId;
+		case "surfaceSlot": return right.kind === "surfaceSlot" && right.surfaceSlotId === left.surfaceSlotId && right.pageSurfaceId === left.pageSurfaceId;
+		default: return assertNever(left);
+	}
+}
+const ENTRY_SLOT_TEMPLATE_LIFECYCLE_DECISION = {
+	publicTemplateDefinitions: "effective-current",
+	previewTemplateDefinitions: "draft-current",
+	removedSlotData: "retained-hidden-until-slot-reintroduced"
+};
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNever(value) {
+	throw new Error(`Unhandled entry-slot variant: ${JSON.stringify(value)}`);
+}
+
+//#endregion
+//#region ../content-model/src/templates/defaults.ts
+const POST_EXCERPT_FALLBACK = fallbackBinding(fieldBinding("excerpt"), transformBinding(TEMPLATE_BINDING_TRANSFORMS.RICHTEXT_FIRST_PARAGRAPH, { input: fieldBinding("body") }));
+const EVENT_SUBHEADLINE_FALLBACK = fallbackBinding(fieldBinding("summary"), transformBinding(TEMPLATE_BINDING_TRANSFORMS.RICHTEXT_FIRST_PARAGRAPH, { input: fieldBinding("body") }));
+const COURSE_SUMMARY_FALLBACK = fallbackBinding(fieldBinding("summary"), transformBinding(TEMPLATE_BINDING_TRANSFORMS.RICHTEXT_FIRST_PARAGRAPH, { input: fieldBinding("body") }));
+const ENTRY_TITLE_INLINE_TEXT = transformBinding(TEMPLATE_BINDING_TRANSFORMS.TEXT_INLINE_TEXT, { input: metaBinding("title") });
+const POST_BODY_TEXT_BINDINGS = {
+	body: fieldBinding("body"),
+	alignment: literalBinding("left")
+};
+const EVENT_BODY_TEXT_BINDINGS = {
+	body: fieldBinding("body"),
+	alignment: literalBinding("left")
+};
+const TEAM_MEMBER_BODY_TEXT_BINDINGS = {
+	body: fieldBinding("bio"),
+	alignment: literalBinding("left")
+};
+const TESTIMONIAL_BODY_TEXT_BINDINGS = {
+	body: fieldBinding("body"),
+	alignment: literalBinding("center")
+};
+/**
+* Built-in content type keys that intentionally ship without a default
+* template — they use the block editor directly rather than a templated
+* render. Single source of truth for the carve-out so callers and tests
+* don't drift on which keys are "missing on purpose".
+*/
+const CONTENT_TYPES_WITHOUT_DEFAULT_TEMPLATE = ["page", "product-category"];
+const DEFAULT_TEMPLATE_DEFINITIONS = {
+	post: {
+		templateKey: "default",
+		name: "Blog post detail",
+		description: "Default article layout for blog posts.",
+		metadata: {},
+		blocks: [
+			{
+				blockKind: "block.hero",
+				scope: "entry",
+				content: { _sectionStyles: { background: { type: "image" } } },
+				bindings: {
+					eyebrow: literalBinding("Article"),
+					headline: metaBinding("title"),
+					headlineInline: ENTRY_TITLE_INLINE_TEXT,
+					subheadline: POST_EXCERPT_FALLBACK,
+					"_sectionStyles.background.image": fieldBinding("image")
+				}
+			},
+			{
+				blockKind: "block.body-text",
+				scope: "entry",
+				bindings: POST_BODY_TEXT_BINDINGS
+			},
+			{
+				blockKind: "block.cta-full",
+				scope: "template",
+				content: {
+					eyebrow: "Stay in the loop",
+					title: "Get the latest updates",
+					content: createRichTextDoc(["Subscribe to our newsletter to receive new articles and resources right in your inbox."]),
+					ctas: [{
+						label: "Subscribe now",
+						link: {
+							kind: "url",
+							href: "/contact"
+						}
+					}, {
+						label: "View all posts",
+						link: {
+							kind: "url",
+							href: "/blog"
+						}
+					}]
+				}
+			}
+		]
+	},
+	event: {
+		templateKey: "default",
+		name: "Event detail",
+		description: "Standard detail page for events.",
+		metadata: {},
+		blocks: [
+			{
+				blockKind: "block.hero",
+				scope: "entry",
+				bindings: {
+					eyebrow: literalBinding("Event"),
+					headline: metaBinding("title"),
+					headlineInline: ENTRY_TITLE_INLINE_TEXT,
+					subheadline: EVENT_SUBHEADLINE_FALLBACK
+				}
+			},
+			{
+				blockKind: "block.event-details",
+				scope: "entry",
+				content: {
+					heading: "Event details",
+					showVenue: true,
+					showMap: true,
+					showOtherDates: true,
+					otherDatesLimit: "5"
+				}
+			},
+			{
+				blockKind: "block.body-text",
+				scope: "entry",
+				bindings: EVENT_BODY_TEXT_BINDINGS
+			},
+			{
+				blockKind: SYSTEM_ENTRY_SLOT_BLOCK_KIND,
+				scope: "template",
+				content: {
+					slotKey: "main",
+					label: "Page content"
+				}
+			},
+			{
+				blockKind: "block.event-registration",
+				scope: "entry",
+				content: {
+					heading: "Register for this event",
+					maxTickets: "5",
+					showVenue: true,
+					showCapacity: true,
+					successMessage: "Thank you for registering! Check your email for confirmation details.",
+					waitlistMessage: "You've been added to the waitlist. We'll email you a claim link if a spot opens up.",
+					buttonText: "Complete Registration",
+					buttonVariant: "primary"
+				},
+				bindings: {
+					occurrenceContext: { $bind: { from: "$root.occurrenceContext" } },
+					contentEntry: { $bind: { from: "$root.contentEntry" } }
+				}
+			}
+		]
+	},
+	course: {
+		templateKey: "default",
+		name: "Course detail",
+		description: "Standard landing page for multi-session courses.",
+		metadata: {},
+		blocks: [
+			{
+				blockKind: "block.hero",
+				scope: "entry",
+				bindings: {
+					eyebrow: literalBinding("Course"),
+					headline: metaBinding("title"),
+					headlineInline: ENTRY_TITLE_INLINE_TEXT,
+					subheadline: COURSE_SUMMARY_FALLBACK
+				}
+			},
+			{
+				blockKind: "block.course-details",
+				scope: "entry",
+				content: {
+					heading: "Course details",
+					showTitle: false,
+					showDescription: false,
+					showSessions: true,
+					sessionsLimit: "10",
+					showVenue: true,
+					showPrice: true,
+					showCapacity: true,
+					showEnrollmentStatus: true,
+					showMembershipNote: true
+				}
+			},
+			{
+				blockKind: SYSTEM_ENTRY_SLOT_BLOCK_KIND,
+				scope: "template",
+				content: {
+					slotKey: "main",
+					label: "Page content"
+				}
+			},
+			{
+				blockKind: "block.course-registration",
+				scope: "entry",
+				content: {
+					heading: "Enroll in this course",
+					showSessions: true,
+					showPrice: true,
+					showCapacity: true,
+					showVenue: true,
+					successMessage: "You're enrolled! Check your email for confirmation and session details.",
+					waitlistMessage: "You've been added to the waitlist. We'll email you a claim link if a spot opens up.",
+					membershipMessage: "Enrolled using your membership! Check your email for session details.",
+					buttonText: "Complete Enrollment",
+					buttonVariant: "primary"
+				}
+			}
+		]
+	},
+	"team-member": {
+		templateKey: "default",
+		name: "Team member profile",
+		description: "Default layout for team member profile pages.",
+		metadata: {},
+		blocks: [{
+			blockKind: "block.hero",
+			scope: "entry",
+			bindings: {
+				eyebrow: literalBinding("About"),
+				headline: metaBinding("title"),
+				headlineInline: ENTRY_TITLE_INLINE_TEXT,
+				subheadline: fieldBinding("intro")
+			}
+		}, {
+			blockKind: "block.body-text",
+			scope: "entry",
+			bindings: TEAM_MEMBER_BODY_TEXT_BINDINGS
+		}]
+	},
+	product: {
+		templateKey: "default",
+		name: "Product detail",
+		description: "Standard landing page for shop products.",
+		metadata: {},
+		blocks: [{
+			blockKind: "block.product-detail",
+			scope: "entry",
+			content: {
+				heading: "",
+				showSummary: true,
+				showBody: true,
+				addButtonText: "Add to cart",
+				emptyStateText: "Product unavailable."
+			}
+		}]
+	},
+	testimonial: {
+		templateKey: "default",
+		name: "Testimonial detail",
+		description: "Rich layout for individual testimonials.",
+		metadata: {},
+		blocks: [{
+			blockKind: "block.hero",
+			scope: "entry",
+			bindings: {
+				eyebrow: literalBinding("Customer story"),
+				headline: metaBinding("title"),
+				headlineInline: ENTRY_TITLE_INLINE_TEXT,
+				subheadline: fallbackBinding(fieldBinding("jobTitle"), fieldBinding("company"))
+			}
+		}, {
+			blockKind: "block.body-text",
+			scope: "entry",
+			bindings: TESTIMONIAL_BODY_TEXT_BINDINGS
+		}]
+	}
+};
+function getDefaultTemplateDefinition(contentTypeKey) {
+	return DEFAULT_TEMPLATE_DEFINITIONS[contentTypeKey] ?? null;
+}
+const DEFAULT_TEMPLATE_KEYS = Object.freeze(Object.keys(DEFAULT_TEMPLATE_DEFINITIONS));
+
+//#endregion
+//#region ../content-model/src/templates/bindingTypeCompatibility.ts
+const SCALAR_BLOCK_FIELD_TYPES = [
+	"text",
+	"inlineText",
+	"number",
+	"slug",
+	"url",
+	"richText",
+	"media",
+	"file",
+	"boolean",
+	"select",
+	"reference",
+	"link",
+	"date",
+	"datetime"
+];
+function isScalarBlockFieldType(type) {
+	return SCALAR_BLOCK_FIELD_TYPES.includes(type);
+}
+/**
+* Compatibility matrix: content field type → compatible block field types
+*/
+const CONTENT_TO_BLOCK_COMPATIBILITY = {
+	text: [
+		"text",
+		"inlineText",
+		"slug",
+		"url"
+	],
+	textarea: ["text", "inlineText"],
+	number: [
+		"number",
+		"text",
+		"inlineText"
+	],
+	date: [
+		"date",
+		"datetime",
+		"text",
+		"inlineText"
+	],
+	url: [
+		"url",
+		"text",
+		"inlineText"
+	],
+	richText: ["richText"],
+	media: ["media"],
+	file: ["file"],
+	boolean: ["boolean"],
+	select: [
+		"text",
+		"inlineText",
+		"select"
+	],
+	reference: ["reference", "link"],
+	link: ["link", "reference"],
+	button: ["link"],
+	group: [],
+	repeater: ["repeater"],
+	datetime: [
+		"datetime",
+		"date",
+		"text",
+		"inlineText"
+	]
+};
+/**
+* Canonical meta-field registry.
+*
+* Single source of truth for "what entry meta fields exist and what content-field
+* type they resolve to". Other modules derive their meta-related tables from
+* this one to prevent the three-source-of-truth drift that previously existed
+* across `META_FIELD_COMPATIBILITY` (this file), `getAvailableFieldPaths`
+* (fieldPaths.ts), and `resolveMetaPathType` (bindingValidation.ts).
+*/
+const META_FIELDS = {
+	title: "text",
+	slug: "text",
+	status: "text",
+	publishedAt: "date",
+	createdAt: "date",
+	updatedAt: "date"
+};
+/** Set of all known meta-field keys, derived from {@link META_FIELDS}. */
+const META_FIELD_IDS = new Set(Object.keys(META_FIELDS));
+/**
+* Resolve a meta path to its content-field type. Returns `null` for unknown paths.
+*
+* Use this when validating bindings; the returned type participates in the
+* standard `isCompatibleBinding` matrix. For target-aware compatibility
+* (which adds aliases like `title → slug → url`), use
+* {@link isCompatibleMetaBinding}.
+*/
+function resolveMetaFieldType(path) {
+	return isMetaFieldPath(path) ? META_FIELDS[path] : null;
+}
+/** Type guard narrowing `string` to the union of declared meta-field paths. */
+function isMetaFieldPath(path) {
+	return path in META_FIELDS;
+}
+/**
+* Meta field → compatible block targets.
+*
+* Includes target-specific aliases that the generic field-type matrix
+* doesn't (e.g. `title` is text but is also a valid `slug`/`url` source).
+* Indexed by the same keys as {@link META_FIELDS} — adding a new meta field
+* means updating both maps.
+*/
+const META_FIELD_COMPATIBILITY = {
+	title: [
+		"text",
+		"inlineText",
+		"slug",
+		"url"
+	],
+	slug: [
+		"text",
+		"inlineText",
+		"slug",
+		"url"
+	],
+	status: [
+		"text",
+		"inlineText",
+		"select"
+	],
+	publishedAt: [
+		"text",
+		"inlineText",
+		"date",
+		"datetime"
+	],
+	createdAt: [
+		"text",
+		"inlineText",
+		"date",
+		"datetime"
+	],
+	updatedAt: [
+		"text",
+		"inlineText",
+		"date",
+		"datetime"
+	]
+};
+/**
+* Nested path suffixes and their compatible types (for example media.url).
+*/
+const NESTED_PATH_COMPATIBILITY = {
+	"media.url": [
+		"text",
+		"inlineText",
+		"url"
+	],
+	"media.alt": ["text", "inlineText"],
+	"file.url": [
+		"text",
+		"inlineText",
+		"url"
+	],
+	"file.filename": ["text", "inlineText"]
+};
+/**
+* Check if a content field type is compatible with a block field type
+*/
+function isCompatibleBinding(sourceType, targetType) {
+	if (targetType === "repeater") {
+		return sourceType === "repeater";
+	}
+	const compatibleTypes = CONTENT_TO_BLOCK_COMPATIBILITY[sourceType];
+	if (compatibleTypes) {
+		return compatibleTypes.includes(targetType);
+	}
+	return false;
+}
+/**
+* Check if a meta field is compatible with a block field type
+*/
+function isCompatibleMetaBinding(metaFieldName, targetType) {
+	if (targetType === "repeater") return false;
+	if (!isMetaFieldPath(metaFieldName)) return false;
+	const compatibleTypes = META_FIELD_COMPATIBILITY[metaFieldName];
+	return compatibleTypes.includes(targetType);
+}
+/**
+* Check if a nested path is compatible with a block field type
+*/
+function isCompatibleNestedPath(parentType, nestedSuffix, targetType) {
+	if (targetType === "repeater") return false;
+	const pathKey = `${parentType}.${nestedSuffix}`;
+	const compatibleTypes = NESTED_PATH_COMPATIBILITY[pathKey];
+	if (compatibleTypes) {
+		return compatibleTypes.includes(targetType);
+	}
+	return false;
+}
+/**
+* Get compatible block field types for a given content field type
+*/
+function getCompatibleBlockTypes(sourceType) {
+	return CONTENT_TO_BLOCK_COMPATIBILITY[sourceType] || [];
+}
+/**
+* Get all compatible content field types for a given block field type (reverse lookup)
+*/
+function getCompatibleContentTypes(targetType) {
+	const compatible = [];
+	for (const [contentType, blockTypes] of Object.entries(CONTENT_TO_BLOCK_COMPATIBILITY)) {
+		if (blockTypes.includes(targetType)) {
+			compatible.push(contentType);
+		}
+	}
+	return compatible;
+}
+
+//#endregion
+//#region ../content-model/src/templates/fieldPaths.ts
+const META_FIELD_LABELS = {
+	title: "Title",
+	slug: "Slug",
+	status: "Status",
+	publishedAt: "Published Date",
+	createdAt: "Created Date",
+	updatedAt: "Updated Date"
+};
+/**
+* Extract all available field paths from a content type schema
+* for use in binding editor autocomplete.
+*/
+function getAvailableFieldPaths(schema) {
+	const paths = [];
+	for (const [path, type] of Object.entries(META_FIELDS)) {
+		paths.push({
+			path,
+			label: META_FIELD_LABELS[path],
+			type,
+			category: "meta"
+		});
+	}
+	paths.push(...contentFieldPaths(schema.fields ?? []));
+	return paths;
+}
+function contentFieldPaths(fields, parentPath = "", parentLabel = "") {
+	const paths = [];
+	for (const field of fields) {
+		const basePath = parentPath ? `${parentPath}.${field.id}` : field.id;
+		const fieldLabel = field.label ?? field.id;
+		const baseLabel = parentLabel ? `${parentLabel} / ${fieldLabel}` : fieldLabel;
+		if (field.type === "group") {
+			paths.push(...contentFieldPaths(nestedFields(field), basePath, baseLabel));
+			continue;
+		}
+		if (field.type === "repeater") {
+			continue;
+		}
+		if (field.type === "richText") {
+			paths.push({
+				path: basePath,
+				label: baseLabel,
+				type: "richText",
+				category: "content"
+			});
+			continue;
+		}
+		if (field.type === "media") {
+			paths.push({
+				path: basePath,
+				label: baseLabel,
+				type: "media",
+				category: "content"
+			}, {
+				path: `${basePath}.url`,
+				label: `${baseLabel} (URL)`,
+				type: "media.url",
+				category: "content"
+			}, {
+				path: `${basePath}.alt`,
+				label: `${baseLabel} (Alt Text)`,
+				type: "media.alt",
+				category: "content"
+			});
+			continue;
+		}
+		if (field.type === "file") {
+			paths.push({
+				path: basePath,
+				label: baseLabel,
+				type: "file",
+				category: "content"
+			}, {
+				path: `${basePath}.url`,
+				label: `${baseLabel} (URL)`,
+				type: "file.url",
+				category: "content"
+			}, {
+				path: `${basePath}.filename`,
+				label: `${baseLabel} (Filename)`,
+				type: "file.filename",
+				category: "content"
+			});
+			continue;
+		}
+		paths.push({
+			path: basePath,
+			label: baseLabel,
+			type: field.type,
+			category: "content"
+		});
+	}
+	return paths;
+}
+function nestedFields(field) {
+	const record = field;
+	return record.fields ?? record.schema?.fields ?? [];
+}
+/**
+* Get field type from path for validation
+*/
+function getFieldTypeFromPath(schema, path) {
+	const descriptor = getFieldDescriptorFromPath(schema, path);
+	return descriptor?.kind === "scalar" ? descriptor.type : descriptor?.kind ?? null;
+}
+function getFieldDescriptorFromPath(schema, path) {
+	const paths = getAvailableFieldPaths(schema);
+	const match = paths.find((p) => p.path === path);
+	if (match) return {
+		kind: "scalar",
+		type: match.type
+	};
+	const field = findContentFieldByPath(schema.fields ?? [], path.split("."));
+	if (!field || field.type !== "repeater") return null;
+	return {
+		kind: "repeater",
+		shape: buildRepeaterFieldShape(field)
+	};
+}
+function findContentFieldByPath(fields, segments) {
+	if (segments.length === 0) return null;
+	const [head, ...tail] = segments;
+	const field = fields.find((candidate) => candidate.id === head);
+	if (!field) return null;
+	if (tail.length === 0) return field;
+	if (field.type !== "group") return null;
+	return findContentFieldByPath(nestedFields(field), tail);
+}
+function buildRepeaterFieldShape(field) {
+	const record = field;
+	if (record.polymorphic || record.itemTypes) {
+		return {
+			kind: "unsupported",
+			reason: "polymorphic_unsupported"
+		};
+	}
+	const fields = nestedFields(field);
+	if (fields.length === 0) {
+		return {
+			kind: "unsupported",
+			reason: "missing_item_schema"
+		};
+	}
+	const itemFields = [];
+	for (const child of fields) {
+		if (child.type === "repeater") {
+			return {
+				kind: "unsupported",
+				reason: "nested_repeater_unsupported"
+			};
+		}
+		if (!isRepeaterItemScalarType(child.type)) {
+			return {
+				kind: "unsupported",
+				reason: "unsupported_item_field"
+			};
+		}
+		itemFields.push({
+			id: child.id,
+			type: child.type,
+			required: Boolean(child.required)
+		});
+	}
+	return {
+		kind: "supported",
+		itemFields
+	};
+}
+function isRepeaterItemScalarType(type) {
+	switch (type) {
+		case "text":
+		case "textarea":
+		case "richText":
+		case "number":
+		case "date":
+		case "url":
+		case "media":
+		case "file":
+		case "boolean":
+		case "select":
+		case "reference":
+		case "link":
+		case "button":
+		case "datetime": return true;
+		case "group":
+		case "repeater": return false;
+		default: {
+			const _exhaustive = type;
+			return _exhaustive;
+		}
+	}
+}
+/**
+* Validate if a path exists in the schema
+*/
+function isValidFieldPath(schema, path) {
+	const paths = getAvailableFieldPaths(schema);
+	return paths.some((fieldPath) => fieldPath.path === path);
+}
+/**
+* Get field paths compatible with a specific block field type
+*
+* Filters available paths to only show those that can be safely bound
+* to the target field type without requiring transforms.
+*/
+function getCompatibleFieldPaths(schema, targetFieldType) {
+	const allPaths = getAvailableFieldPaths(schema);
+	return allPaths.filter((fieldPath) => {
+		if (fieldPath.category === "meta") {
+			return isCompatibleMetaBinding(fieldPath.path, targetFieldType);
+		}
+		if (fieldPath.type.includes(".")) {
+			const parts = fieldPath.type.split(".");
+			const parentType = parts[0];
+			const nestedSuffix = parts[1];
+			if (parentType && nestedSuffix) {
+				return isCompatibleNestedPath(parentType, nestedSuffix, targetFieldType);
+			}
+			return false;
+		}
+		return isCompatibleBinding(fieldPath.type, targetFieldType);
+	});
+}
+
+//#endregion
+//#region ../content-model/src/templates/bindingValidation.ts
+/**
+* What each transform accepts and produces. The `satisfies` clause forces
+* every `TemplateBindingTransformName` to have an entry — adding a new
+* transform name without an IO declaration is a compile error rather than
+* a runtime "unknown transform" error.
+*
+* Source-of-truth status:
+*   - The names live in three places (`TRANSFORMS` in blocks, `BINDING_TRANSFORMS`
+*     in sdk, `TEMPLATE_BINDING_TRANSFORMS` here) for package-boundary
+*     reasons — blocks doesn't depend on content-model. A cross-package
+*     equivalence test (`bindingValidation.test.ts`) pins the three sets
+*     so drift fails CI rather than going unnoticed.
+*   - The IO declaration lives only here; the runtime implementations in
+*     `blocks/bindings/index.ts:applyTransform` are checked against this
+*     table by the same cross-package test.
+*/
+const TRANSFORM_IO = {
+	[TEMPLATE_BINDING_TRANSFORMS.RICHTEXT_FIRST_PARAGRAPH]: {
+		acceptsInputTypes: ["richText"],
+		outputType: "text"
+	},
+	[TEMPLATE_BINDING_TRANSFORMS.DATE_FORMAT_SHORT]: {
+		acceptsInputTypes: ["date", "datetime"],
+		outputType: "text"
+	},
+	[TEMPLATE_BINDING_TRANSFORMS.DATE_FORMAT_LONG]: {
+		acceptsInputTypes: ["date", "datetime"],
+		outputType: "text"
+	},
+	[TEMPLATE_BINDING_TRANSFORMS.TEXT_INLINE_TEXT]: {
+		acceptsInputTypes: [
+			"text",
+			"textarea",
+			"select"
+		],
+		outputType: "text"
+	}
+};
+function getTransformIO(name) {
+	return name in TRANSFORM_IO ? TRANSFORM_IO[name] : undefined;
+}
+/**
+* Resolve a meta path to its content-field type. Returns `null` for unknown
+* meta paths. Delegates entirely to the canonical {@link resolveMetaFieldType}
+* registry, which {@link getAvailableFieldPaths} also reads.
+*/
+function resolveMetaPathType(path) {
+	return resolveMetaFieldType(path);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBindingDescriptor(value) {
+	if (!isRecord$1(value)) return false;
+	const source = value.source;
+	return source === "field" || source === "meta" || source === "literal" || source === "transform" || source === "fallback";
+}
+/**
+* Detect a root-context (`{$bind: {from: '$root.X'}}`) binding.
+*
+* These are block-internal data-wiring bindings, not user-authored entry-field
+* bindings. They appear on blocks like `block.event-registration` to plumb
+* ambient context (occurrence, content entry root, portal token) from the
+* renderer's data context into the block. The validator should NOT flag them
+* as `invalidBindingKey` — they're never expected to live on the manifest's
+* additionalFields list. Phase 9 will migrate this stored shape away.
+*
+* Matches:
+*   - `{ $bind: { from: '$root.foo' } }`
+*   - `{ $bind: { from: '$root.foo.bar' } }`
+*
+* Does NOT match field/meta-source bindings whose path happens to start with
+* `$root` — those use a `source` discriminator, not the `$bind` envelope.
+*/
+function isRootContextBinding(value) {
+	if (!isRecord$1(value)) return false;
+	const bind = value.$bind;
+	if (!isRecord$1(bind)) return false;
+	return typeof bind.from === "string" && bind.from.startsWith("$root.");
+}
+/**
+* Check compatibility between a resolved source type (for example `'text'`,
+* `'richText'`, or `'media.url'`) and a target block field type.
+*
+* Handles three shapes of source type:
+*   - plain content-field type (e.g. `'text'`)
+*   - dotted nested suffix (e.g. `'media.url'`)
+*   - meta-typed value (treated as plain content type, since meta types
+*     already map cleanly into the matrix)
+*/
+function isSourceCompatibleWithTarget(sourceType, targetType) {
+	if (sourceType.includes(".")) {
+		const [parent, suffix] = sourceType.split(".", 2);
+		if (!parent || !suffix) return false;
+		return isCompatibleNestedPath(parent, suffix, targetType);
+	}
+	return isCompatibleBinding(sourceType, targetType);
+}
+function resolveFieldSource(path, context) {
+	const descriptor = getFieldDescriptorFromPath(context.schema, path);
+	if (descriptor === null) {
+		return {
+			kind: "invalidPath",
+			error: {
+				kind: "invalidFieldPath",
+				blockIdentifier: context.blockIdentifier,
+				fieldKey: context.fieldKey,
+				path
+			}
+		};
+	}
+	if (descriptor.kind === "repeater") {
+		return {
+			kind: "ok",
+			type: "repeater",
+			path,
+			shape: descriptor.shape
+		};
+	}
+	return {
+		kind: "ok",
+		type: descriptor.type,
+		path
+	};
+}
+function resolveMetaSource(path, context) {
+	const type = resolveMetaPathType(path);
+	if (type === null) {
+		return {
+			kind: "invalidPath",
+			error: {
+				kind: "invalidMetaPath",
+				blockIdentifier: context.blockIdentifier,
+				fieldKey: context.fieldKey,
+				path
+			}
+		};
+	}
+	return {
+		kind: "ok",
+		type,
+		path
+	};
+}
+/**
+* Check a resolved source type against the target. Meta paths get the
+* target-aware aliases (e.g. `title` → `slug`/`url`); plain field paths use
+* the generic compatibility matrix.
+*/
+function checkDirectCompatibility(resolved, context, isMetaSource) {
+	if (isMetaSource) {
+		if (isCompatibleMetaBinding(resolved.path, context.target.type)) return null;
+		return {
+			kind: "typeIncompatible",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			sourceType: `meta.${resolved.path}`,
+			sourcePath: resolved.path,
+			targetType: context.target.type,
+			via: "direct"
+		};
+	}
+	if (context.target.type === "repeater") {
+		const mismatch = checkRepeaterCompatibility(resolved, context);
+		return mismatch;
+	}
+	if (resolved.type === "repeater") {
+		return {
+			kind: "typeIncompatible",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			sourceType: describeResolvedSourceType(resolved),
+			sourcePath: resolved.path,
+			targetType: context.target.type,
+			via: "direct"
+		};
+	}
+	if (isSourceCompatibleWithTarget(resolved.type, context.target.type)) return null;
+	return {
+		kind: "typeIncompatible",
+		blockIdentifier: context.blockIdentifier,
+		fieldKey: context.fieldKey,
+		sourceType: resolved.type,
+		sourcePath: resolved.path,
+		targetType: context.target.type,
+		via: "direct"
+	};
+}
+function describeResolvedSourceType(resolved) {
+	if (resolved.type !== "repeater") return resolved.type;
+	return resolved.shape?.kind === "unsupported" ? `repeater(${resolved.shape.reason})` : "repeater";
+}
+function describeTargetType(target) {
+	return target.type;
+}
+function checkRepeaterCompatibility(resolved, context) {
+	if (context.target.type !== "repeater") return null;
+	const incompatible = (sourceType) => ({
+		kind: "typeIncompatible",
+		blockIdentifier: context.blockIdentifier,
+		fieldKey: context.fieldKey,
+		sourceType,
+		sourcePath: resolved.path,
+		targetType: describeTargetType(context.target),
+		via: "direct"
+	});
+	if (resolved.type !== "repeater" || !resolved.shape) {
+		return incompatible(describeResolvedSourceType(resolved));
+	}
+	const sourceShape = resolved.shape;
+	const targetShape = context.target.shape;
+	if (sourceShape.kind === "unsupported") {
+		return incompatible(`repeater(${sourceShape.reason})`);
+	}
+	if (targetShape.kind === "unsupported") {
+		return incompatible(`target-repeater(${targetShape.reason})`);
+	}
+	const sourceById = new Map(sourceShape.itemFields.map((field) => [field.id, field]));
+	for (const targetField of targetShape.itemFields) {
+		const sourceField = sourceById.get(targetField.id);
+		if (!sourceField) {
+			if (targetField.required) return incompatible("repeater(missing_required_target_field)");
+			continue;
+		}
+		if (targetField.required && !sourceField.required) {
+			return incompatible("repeater(requiredness_mismatch)");
+		}
+		if (!isScalarBlockFieldType(targetField.type) || !isSourceCompatibleWithTarget(sourceField.type, targetField.type)) {
+			return incompatible(`repeater(type_mismatch:${sourceField.id})`);
+		}
+	}
+	return null;
+}
+/**
+* Validate one binding value against one target field.
+*
+* Handles every shape `TemplateBindingValue` can take:
+*   - descriptor (`field`/`meta`/`literal`/`transform`/`fallback`)
+*   - string shorthand (treated as a `field` path)
+*   - nested object (each key maps to a nested manifest target at
+*     `${parentKey}.${childKey}`; missing nested targets are reported as
+*     `invalidBindingKey` rather than silently inheriting the parent's type)
+*/
+function validateBinding(binding, context) {
+	if (typeof binding === "string") {
+		const resolved = resolveFieldSource(binding, context);
+		if (resolved.kind === "invalidPath") return [resolved.error];
+		const mismatch = checkDirectCompatibility(resolved, context, false);
+		return mismatch ? [mismatch] : [];
+	}
+	if (!isRecord$1(binding)) {
+		return [{
+			kind: "typeIncompatible",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			sourceType: typeof binding,
+			targetType: context.target.type,
+			via: "direct"
+		}];
+	}
+	if (isBindingDescriptor(binding)) {
+		return validateDescriptor(binding, context);
+	}
+	const errors = [];
+	for (const [childKey, child] of Object.entries(binding)) {
+		if (child === null || child === undefined) continue;
+		const nestedKey = `${context.fieldKey}.${childKey}`;
+		const nestedTarget = context.targetByKey.get(nestedKey);
+		if (!nestedTarget) {
+			errors.push({
+				kind: "invalidBindingKey",
+				blockIdentifier: context.blockIdentifier,
+				blockKind: context.blockKind,
+				fieldKey: nestedKey
+			});
+			continue;
+		}
+		errors.push(...validateBinding(child, {
+			...context,
+			fieldKey: nestedKey,
+			target: nestedTarget
+		}));
+	}
+	return errors;
+}
+function validateDescriptor(binding, context) {
+	switch (binding.source) {
+		case "field": {
+			const resolved = resolveFieldSource(binding.path, context);
+			if (resolved.kind === "invalidPath") return [resolved.error];
+			const mismatch = checkDirectCompatibility(resolved, context, false);
+			return mismatch ? [mismatch] : [];
+		}
+		case "meta": {
+			const resolved = resolveMetaSource(binding.path, context);
+			if (resolved.kind === "invalidPath") return [resolved.error];
+			const mismatch = checkDirectCompatibility(resolved, context, true);
+			return mismatch ? [mismatch] : [];
+		}
+		case "literal": return [];
+		case "transform": return validateTransform(binding, context);
+		case "fallback": return readFallbackOptions(binding).flatMap((option) => validateBinding(option, { ...context }).map((err$1) => err$1.kind === "typeIncompatible" && err$1.via === "direct" ? {
+			...err$1,
+			via: "fallbackOption"
+		} : err$1));
+		default: {
+			const _exhaustive = binding;
+			return _exhaustive;
+		}
+	}
+}
+function validateTransform(binding, context) {
+	const io = getTransformIO(binding.transform);
+	if (!io) {
+		return [{
+			kind: "unknownTransform",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			transform: binding.transform
+		}];
+	}
+	const inputDescriptor = resolveTransformInput(binding);
+	if (inputDescriptor === null) {
+		return [{
+			kind: "typeIncompatible",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			sourceType: "transform(no input)",
+			targetType: context.target.type,
+			via: "transformOutput"
+		}];
+	}
+	const resolved = inputDescriptor.source === "field" ? resolveFieldSource(inputDescriptor.path, context) : inputDescriptor.source === "meta" ? resolveMetaSource(inputDescriptor.path, context) : null;
+	if (resolved && resolved.kind === "invalidPath") {
+		return [resolved.error];
+	}
+	const errors = [];
+	if (resolved && resolved.kind === "ok") {
+		const inputType = resolved.type;
+		if (!io.acceptsInputTypes.includes(inputType)) {
+			errors.push({
+				kind: "transformInputIncompatible",
+				blockIdentifier: context.blockIdentifier,
+				fieldKey: context.fieldKey,
+				transform: binding.transform,
+				inputType,
+				acceptedTypes: io.acceptsInputTypes
+			});
+		}
+	}
+	if (!isCompatibleBinding(io.outputType, context.target.type)) {
+		errors.push({
+			kind: "typeIncompatible",
+			blockIdentifier: context.blockIdentifier,
+			fieldKey: context.fieldKey,
+			sourceType: io.outputType,
+			targetType: context.target.type,
+			via: "transformOutput"
+		});
+	}
+	return errors;
+}
+function isTemplateBindingValueArray(value) {
+	return Array.isArray(value);
+}
+function readFallbackOptions(binding) {
+	if (isTemplateBindingValueArray(binding.options)) return binding.options;
+	const legacy = binding.sources;
+	return isTemplateBindingValueArray(legacy) ? legacy : [];
+}
+function resolveTransformInput(binding) {
+	if (binding.input !== undefined) {
+		if (typeof binding.input === "string") {
+			return {
+				source: "field",
+				path: binding.input
+			};
+		}
+		return binding.input;
+	}
+	if (typeof binding.path === "string") {
+		return {
+			source: "field",
+			path: binding.path
+		};
+	}
+	return null;
+}
+/**
+* Validate every binding on one block and assert that every required manifest
+* field has a binding present.
+*/
+function validateBlockBindings(block, schema, manifest) {
+	const blockIdentifier = block.identifier ?? block.blockKind;
+	if (block.scope === "template") return [];
+	const errors = [];
+	const bindings = block.bindings ?? {};
+	const targetByKey = new Map(manifest.fields.map((target) => [target.id, target]));
+	for (const [fieldKey, binding] of Object.entries(bindings)) {
+		if (binding === null || binding === undefined) continue;
+		if (isRootContextBinding(binding)) continue;
+		const target = targetByKey.get(fieldKey);
+		if (!target) {
+			errors.push({
+				kind: "invalidBindingKey",
+				blockIdentifier,
+				blockKind: block.blockKind,
+				fieldKey
+			});
+			continue;
+		}
+		errors.push(...validateBinding(binding, {
+			blockIdentifier,
+			fieldKey,
+			target,
+			schema,
+			targetByKey,
+			blockKind: block.blockKind
+		}));
+	}
+	for (const target of manifest.fields) {
+		if (!target.required) continue;
+		const value = bindings[target.id];
+		if (value === undefined || value === null) {
+			errors.push({
+				kind: "requiredBindingMissing",
+				blockIdentifier,
+				blockKind: block.blockKind,
+				fieldKey: target.id
+			});
+		}
+	}
+	return errors;
+}
+/**
+* Validate every block in a template definition.
+*
+* Unknown block kinds are surfaced as `unknownBlockKind` errors and that
+* block is skipped for further checks (the rest of the template is still
+* validated, so callers see all problems at once).
+*/
+function validateTemplateBindings(template, schema, getManifest) {
+	const errors = [];
+	for (const [index, block] of template.blocks.entries()) {
+		const blockIdentifier = block.identifier ?? `${block.blockKind}#${index}`;
+		if (block.scope === "template") continue;
+		const manifest = getManifest(block.blockKind);
+		if (!manifest) {
+			errors.push({
+				kind: "unknownBlockKind",
+				blockIdentifier,
+				blockKind: block.blockKind
+			});
+			continue;
+		}
+		errors.push(...validateBlockBindings({
+			...block,
+			identifier: blockIdentifier
+		}, schema, manifest));
+	}
+	return errors;
+}
+function matchBindingError(error, handlers) {
+	const handler = handlers[error.kind];
+	return handler(error);
+}
+/**
+* Human-readable rendering of a validation error. Suitable for editor
+* inline-error display and audit reports. Server-side error mappers should
+* use the error's `kind` discriminator (via `matchBindingError`) instead
+* of string-matching the message.
+*/
+function bindingValidationErrorMessage(error) {
+	return matchBindingError(error, {
+		unknownBlockKind: (e) => `Unknown block kind "${e.blockKind}"`,
+		invalidBindingKey: (e) => `Binding key "${e.fieldKey}" is not a field of block "${e.blockKind}"`,
+		invalidFieldPath: (e) => `Field path "${e.path}" does not exist in the content type`,
+		invalidMetaPath: (e) => `Meta path "${e.path}" is not a known entry meta field`,
+		typeIncompatible: (e) => {
+			const ctx = e.via === "transformOutput" ? " (transform output)" : e.via === "fallbackOption" ? " (fallback option)" : "";
+			const pathSuffix = e.sourcePath ? ` (path "${e.sourcePath}")` : "";
+			return `Source type "${e.sourceType}" is not compatible with target field type "${e.targetType}"${pathSuffix}${ctx}`;
+		},
+		unknownTransform: (e) => `Unknown transform "${e.transform}"`,
+		transformInputIncompatible: (e) => `Transform "${e.transform}" does not accept input type "${e.inputType}" (accepts: ${e.acceptedTypes.join(", ")})`,
+		requiredBindingMissing: (e) => `Required field "${e.fieldKey}" of block "${e.blockKind}" has no binding`
+	});
+}
+
+//#endregion
+//#region ../content-model/src/templates/manifestAdapter.ts
+const FIELD_TYPE_CLASSIFICATION = {
+	text: "leaf",
+	inlineText: "leaf",
+	number: "leaf",
+	slug: "leaf",
+	url: "leaf",
+	richText: "leaf",
+	media: "leaf",
+	file: "leaf",
+	boolean: "leaf",
+	select: "leaf",
+	reference: "leaf",
+	link: "leaf",
+	date: "leaf",
+	datetime: "leaf",
+	group: "composite",
+	modal: "composite",
+	tabGroup: "composite",
+	repeater: "whole",
+	presetOrCustom: "opaque",
+	contentTypeSelect: "opaque",
+	entryPicker: "opaque",
+	time: "opaque"
+};
+function classify(type) {
+	return FIELD_TYPE_CLASSIFICATION[type] ?? "unknown";
+}
+function leafToBlockFieldType(type) {
+	return classify(type) === "leaf" ? type : null;
+}
+/**
+* Recursively collect every bindable leaf in a field tree, emitting
+* dot-notated ids. `prefix` carries the parent path during recursion.
+*/
+function collectLeaves(fields, prefix, out) {
+	if (!fields) return;
+	for (const field of fields) {
+		const id = prefix ? `${prefix}.${field.id}` : field.id;
+		const cls = classify(field.type);
+		if (cls === "leaf") {
+			out.push({
+				id,
+				type: field.type,
+				required: Boolean(field.required)
+			});
+			continue;
+		}
+		if (cls === "whole") {
+			out.push({
+				id,
+				type: "repeater",
+				required: Boolean(field.required),
+				shape: buildManifestRepeaterShape(field)
+			});
+			continue;
+		}
+		if (cls === "composite") {
+			const groupChildren = field.schema?.fields;
+			if (groupChildren) collectLeaves(groupChildren, id, out);
+			for (const tab of field.tabs ?? []) {
+				if (tab.fields) collectLeaves(tab.fields, id, out);
+			}
+		}
+		void leafToBlockFieldType;
+	}
+}
+function buildManifestRepeaterShape(field) {
+	if (field.polymorphic || field.itemTypes) {
+		return {
+			kind: "unsupported",
+			reason: "polymorphic_unsupported"
+		};
+	}
+	const fields = field.repeatedItem?.fields ?? field.schema?.fields;
+	if (!fields || fields.length === 0) {
+		return {
+			kind: "unsupported",
+			reason: "missing_item_schema"
+		};
+	}
+	const itemFields = [];
+	for (const child of fields) {
+		if (child.type === "repeater") {
+			return {
+				kind: "unsupported",
+				reason: "nested_repeater_unsupported"
+			};
+		}
+		const type = leafToBlockFieldType(child.type);
+		if (!type) {
+			return {
+				kind: "unsupported",
+				reason: "unsupported_item_field"
+			};
+		}
+		itemFields.push({
+			id: child.id,
+			type,
+			required: Boolean(child.required)
+		});
+	}
+	return {
+		kind: "supported",
+		itemFields
+	};
+}
+/**
+* Build the validator-facing shape from a block manifest. Composite fields
+* are walked; their leaves emerge with dot-notated ids. Opaque/unknown
+* fields are skipped.
+*
+* Accepts any value satisfying {@link AdaptableManifest}.
+*/
+function manifestToValidationShape(manifest) {
+	const fields = [];
+	collectLeaves(manifest.fields, "", fields);
+	return {
+		id: manifest.name,
+		fields
+	};
+}
+
+//#endregion
+//#region ../content-model/src/templates/auditBindings.ts
+/**
+* Build a zero-initialised counter map keyed on every error variant.
+*
+* The literal *is* the source of truth: adding a new variant to
+* `BindingValidationError` without a key here is a compile error. The
+* `ALL_ERROR_KINDS` derived list and the runtime exhaustiveness in
+* `emptyByKind` both flow from this single declaration.
+*/
+function emptyByKind() {
+	const counters = {
+		unknownBlockKind: 0,
+		invalidBindingKey: 0,
+		invalidFieldPath: 0,
+		invalidMetaPath: 0,
+		typeIncompatible: 0,
+		unknownTransform: 0,
+		transformInputIncompatible: 0,
+		requiredBindingMissing: 0
+	};
+	return counters;
+}
+const ALL_ERROR_KINDS = Object.keys(emptyByKind());
+/**
+* Audit one site's templates. Returns a report with every finding from
+* every template, plus a per-`kind` summary. Pure function: no I/O, no side
+* effects.
+*/
+function auditSite(input, getManifest) {
+	const findings = [];
+	const byKind = emptyByKind();
+	for (const ct of input.contentTypes) {
+		for (const template of ct.templates) {
+			const errors = validateTemplateBindings(template, ct.schema, getManifest);
+			for (const error of errors) {
+				findings.push({
+					siteId: input.siteId,
+					contentTypeKey: ct.contentTypeKey,
+					templateKey: template.templateKey,
+					templateName: template.name,
+					error
+				});
+				byKind[error.kind] += 1;
+			}
+		}
+	}
+	return {
+		siteId: input.siteId,
+		findings,
+		byKind
+	};
+}
+function auditSites(inputs, getManifest) {
+	const reports = inputs.map((input) => auditSite(input, getManifest));
+	const totalsByKind = emptyByKind();
+	let totalFindings = 0;
+	for (const report of reports) {
+		totalFindings += report.findings.length;
+		for (const kind of ALL_ERROR_KINDS) {
+			totalsByKind[kind] += report.byKind[kind];
+		}
+	}
+	return {
+		reports,
+		totalFindings,
+		totalsByKind
+	};
+}
+/**
+* Render a `MultiSiteAuditReport` as a markdown document suitable for
+* committing to `.project/audits/`. Stable ordering: sites by id, findings
+* within a site by content-type → template → block-identifier → kind.
+*/
+function formatAuditReportMarkdown(report, options) {
+	const lines = [];
+	const iso = options.generatedAt.toISOString();
+	lines.push(`# Template binding audit — ${options.environment}`);
+	lines.push("");
+	lines.push(`Generated: ${iso}`);
+	lines.push(`Total findings: **${report.totalFindings}**`);
+	lines.push("");
+	if (report.totalFindings === 0) {
+		lines.push("No binding violations found. ✅");
+		lines.push("");
+		return lines.join("\n");
+	}
+	lines.push("## Summary by error kind");
+	lines.push("");
+	lines.push("| Kind | Count |");
+	lines.push("| --- | ---: |");
+	for (const kind of ALL_ERROR_KINDS) {
+		const count = report.totalsByKind[kind];
+		if (count > 0) lines.push(`| \`${kind}\` | ${count} |`);
+	}
+	lines.push("");
+	for (const site of [...report.reports].sort((a, b) => a.siteId.localeCompare(b.siteId))) {
+		if (site.findings.length === 0) continue;
+		lines.push(`## Site \`${site.siteId}\` (${site.findings.length} finding${site.findings.length === 1 ? "" : "s"})`);
+		lines.push("");
+		const grouped = groupFindings(site.findings);
+		for (const [contentTypeKey, templates] of grouped) {
+			lines.push(`### Content type \`${contentTypeKey}\``);
+			lines.push("");
+			for (const [templateKey, findings] of templates) {
+				const templateName = findings[0]?.templateName ?? "";
+				lines.push(`**Template \`${templateKey}\`** — ${templateName}`);
+				lines.push("");
+				lines.push("| Block | Field | Kind | Detail |");
+				lines.push("| --- | --- | --- | --- |");
+				for (const finding of findings) {
+					const err$1 = finding.error;
+					const blockId = "blockIdentifier" in err$1 ? err$1.blockIdentifier : "-";
+					const fieldKey = "fieldKey" in err$1 ? err$1.fieldKey : "-";
+					const detail = describeError(err$1).replace(/\|/g, "\\|");
+					lines.push(`| \`${blockId}\` | \`${fieldKey}\` | \`${err$1.kind}\` | ${detail} |`);
+				}
+				lines.push("");
+			}
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Group findings by content type → template, preserving stable ordering
+* inside each group. Pure helper for the formatter; exposed for tests.
+*/
+function groupFindings(findings) {
+	const byContentType = new Map();
+	for (const finding of findings) {
+		const inner = byContentType.get(finding.contentTypeKey) ?? new Map();
+		const list = inner.get(finding.templateKey) ?? [];
+		list.push(finding);
+		inner.set(finding.templateKey, list);
+		byContentType.set(finding.contentTypeKey, inner);
+	}
+	const ctEntries = [...byContentType.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+	return ctEntries.map(([ctKey, tplMap]) => {
+		const tplEntries = [...tplMap.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+		return [ctKey, tplEntries.map(([tplKey, list]) => [tplKey, [...list].sort((a, b) => "blockIdentifier" in a.error && "blockIdentifier" in b.error ? a.error.blockIdentifier.localeCompare(b.error.blockIdentifier) || a.error.kind.localeCompare(b.error.kind) : a.error.kind.localeCompare(b.error.kind))])];
+	});
+}
+/**
+* Audit-report rendering of a validation error.
+*
+* Delegates to the canonical `bindingValidationErrorMessage` so a single
+* source of truth covers both editor inline-display and audit report
+* surfaces — adding a new error variant updates both consumers from one
+* exhaustive switch.
+*/
+const describeError = bindingValidationErrorMessage;
+
+//#endregion
+//#region ../content-model/src/templates/editorState.ts
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isTemplateEditorBindingDescriptor(value) {
+	return typeof value === "string" || isRecord(value);
+}
+function normalizeTemplateEditorBindings(bindings) {
+	const next = {};
+	for (const [key, value] of Object.entries(bindings ?? {})) {
+		if (!isTemplateEditorBindingDescriptor(value)) continue;
+		next[key] = value;
+	}
+	return next;
+}
+function serializeTemplateEditorBindingsJson(bindings) {
+	return JSON.stringify(bindings, null, 2);
+}
+function parseTemplateEditorBindingsJson(jsonValue) {
+	try {
+		const parsed = JSON.parse(jsonValue);
+		if (!isRecord(parsed)) {
+			return {
+				ok: false,
+				message: "Bindings must be an object"
+			};
+		}
+		const bindings = normalizeTemplateEditorBindings(parsed);
+		if (Object.keys(bindings).length !== Object.keys(parsed).length) {
+			return {
+				ok: false,
+				message: "Binding values must be strings or objects"
+			};
+		}
+		return {
+			ok: true,
+			bindings
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error instanceof Error ? error.message : "Invalid JSON"
+		};
+	}
+}
+function mergeTemplateBindingEdits(currentBindings, editedBindings) {
+	return {
+		...currentBindings,
+		...editedBindings
+	};
+}
+function setTemplateEditorBinding(bindings, propId, binding) {
+	return {
+		...bindings,
+		[propId]: binding
+	};
+}
+function removeTemplateEditorBinding(bindings, propId) {
+	const next = { ...bindings };
+	delete next[propId];
+	return next;
+}
+function createEntryTemplateBindingRecords(blocks) {
+	const next = {};
+	for (const block of blocks) {
+		if (block.scope !== "entry") continue;
+		next[block.id] = normalizeTemplateEditorBindings(block.bindings);
+	}
+	return next;
+}
+function setTemplateBlockBinding(allBindings, blockId, propId, binding) {
+	return {
+		...allBindings,
+		[blockId]: setTemplateEditorBinding(allBindings[blockId] ?? {}, propId, binding)
+	};
+}
+function removeTemplateBlockBinding(allBindings, blockId, propId) {
+	return {
+		...allBindings,
+		[blockId]: removeTemplateEditorBinding(allBindings[blockId] ?? {}, propId)
+	};
+}
+
+//#endregion
+//#region ../content-model/src/entry-slots/sdkBlocks.ts
+const defaultContentSchema = z.record(z.string(), z.unknown());
+function createSdkEntrySlotBlockInputSchema(contentSchema = defaultContentSchema) {
+	return z.object({
+		identifier: z.string().nullable().optional(),
+		kind: z.string().min(1, "Block kind is required"),
+		content: contentSchema
+	});
+}
+function createSdkEntrySlotBlocksInputSchema(contentSchema) {
+	return z.record(z.string(), z.array(createSdkEntrySlotBlockInputSchema(contentSchema)));
+}
+const sdkEntrySlotBlockInputSchema = createSdkEntrySlotBlockInputSchema();
+const sdkEntrySlotBlocksInputSchema = createSdkEntrySlotBlocksInputSchema();
+
+//#endregion
+//#region src/commands/eventUpsertInputSchema.ts
+const eventScheduleInputSchema = z.object({
+	recurrenceRule: z.string().nullable().optional(),
+	startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+	defaultStartTime: z.string().min(1).optional(),
+	durationMinutes: z.number().int().positive().optional(),
+	startsAt: z.string().min(1).optional(),
+	endsAt: z.string().min(1).optional()
+}).superRefine((schedule, ctx) => {
+	const result = classifySdkEventSchedule(schedule, { requireCanonicalFields: true });
+	if (result.ok) return;
+	result.issues.forEach((issue) => ctx.addIssue({
+		code: "custom",
+		path: [...issue.path],
+		message: issue.message
+	}));
+}).transform((schedule) => {
+	const result = classifySdkEventSchedule(schedule, { requireCanonicalFields: true });
+	if (!result.ok) throw new Error("Unreachable invalid event schedule");
+	if (result.kind === "start-end") {
+		if (typeof schedule.startsAt !== "string" || typeof schedule.endsAt !== "string") throw new Error("Unreachable invalid start/end event schedule");
+		return {
+			startsAt: schedule.startsAt,
+			endsAt: schedule.endsAt
+		};
+	}
+	if (result.kind === "start-duration") {
+		if (typeof schedule.startsAt !== "string" || typeof schedule.durationMinutes !== "number") throw new Error("Unreachable invalid start/duration event schedule");
+		return {
+			startsAt: schedule.startsAt,
+			durationMinutes: schedule.durationMinutes
+		};
+	}
+	return result.canonical;
+});
+function classifiedSchema(classify$1) {
+	return z.unknown().superRefine((input, ctx) => {
+		const result = classify$1(input);
+		if (result.ok) return;
+		result.issues.forEach((issue) => ctx.addIssue({
+			code: "custom",
+			path: issue.path.map(String),
+			message: issue.message
+		}));
+	}).transform((input) => {
+		const result = classify$1(input);
+		if (!result.ok) throw new Error("Unreachable invalid classified input");
+		return result.value;
+	});
+}
+const eventPricingInputSchema = classifiedSchema((input) => {
+	const result = classifySdkEventPricing(input);
+	return result.ok ? {
+		ok: true,
+		value: result.pricing
+	} : result;
+});
+const eventPaymentTermsInputSchema = classifiedSchema((input) => {
+	const result = classifySdkEventPaymentTerms(input);
+	return result.ok ? {
+		ok: true,
+		value: result.paymentTerms
+	} : result;
+});
+const eventRunInputSchema = z.object({
+	identifier: z.string().min(1),
+	eventRef: z.string().min(1),
+	name: z.string().nullable().optional(),
+	status: sdkEventUpsertOptionalFieldSchemas.status,
+	visibility: sdkEventUpsertOptionalFieldSchemas.visibility,
+	bookingScope: z.enum(["single_occurrence", "whole_series"]),
+	occurrences: sdkEventUpsertOptionalFieldSchemas.occurrences.unwrap(),
+	schedule: eventScheduleInputSchema.optional(),
+	pricing: eventPricingInputSchema.optional(),
+	paymentTerms: eventPaymentTermsInputSchema.optional(),
+	capacity: sdkEventUpsertOptionalFieldSchemas.capacity,
+	venueRef: z.string().nullable().optional(),
+	categoryRef: z.string().nullable().optional(),
+	formRef: z.string().nullable().optional(),
+	settings: z.record(z.string(), z.unknown()).optional(),
+	presentation: z.record(z.string(), z.unknown()).nullable().optional(),
+	tags: z.array(z.string()).optional()
+});
+const eventUpsertInputSchema = z.object({
+	identifier: z.string().min(1).optional(),
+	title: z.string().min(1, "title is required"),
+	slug: z.string().min(1).optional(),
+	content: z.record(z.string(), z.unknown()).optional(),
+	blocks: sdkEntrySlotBlocksInputSchema.optional(),
+	preset: z.enum([
+		"event",
+		"class",
+		"course",
+		"workshop",
+		"retreat",
+		"performance"
+	]),
+	runRefs: z.tuple([z.string().min(1)], z.string().min(1)),
+	runs: z.tuple([eventRunInputSchema], eventRunInputSchema)
+}).superRefine((input, ctx) => input.runs.forEach((run, index) => {
+	if (new Set(run.occurrences.map((item) => item.timeZone)).size <= 1) return;
+	ctx.addIssue({
+		code: "custom",
+		path: [
+			"runs",
+			index,
+			"occurrences"
+		],
+		message: "all occurrences must use the same timeZone"
+	});
+}));
+
+//#endregion
+export { RichTextDocSchema as a, isRecord$3 as c, findUnfilledSentinels as i, buildEntryScaffold as n, isRichTextDoc as o, validateEntryInstance as r, isObjectRecord as s, eventUpsertInputSchema as t };