riverbankcms 0.19.0 → 0.20.0

package/dist/{eventUpsertInputSchema-Bkafrrjw.mjs → eventUpsertInputSchema-VVBVGA6x.mjs}

@@ -1,233 +1,8 @@
 #!/usr/bin/env node
-import { a as classifySdkEventSchedule, i as sdkEventUpsertOptionalFieldSchemas, n as sdkCourseBookingSettingsSchema, o as classifySdkEventBookingOffer } from "./sdk-event-upsert-BdvfnCyV.mjs";
-import { u as EVENT_PRESET_VALUES } from "./src-yL0DBH7S.mjs";
+import { S as normalizeLinkValue, d as classifySdkEventBookingOffer, l as sdkEventUpsertOptionalFieldSchemas, n as createRichTextDoc, s as sdkCourseBookingSettingsSchema, u as classifySdkEventSchedule, x as linkSchema } from "./richTextSchema-DTvrDDF5.mjs";
+import { u as EVENT_PRESET_VALUES } from "./src-Dixcv4PB.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.
@@ -449,6 +224,294 @@ function normalizeSlugSegment(segment) {
 	return normalized;
 }
 
+//#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
+/**
+* Entry-instance validator, compiled from the content-type field DSL.
+*
+* `ContentTypeSchemaZ` validates schema DOCUMENTS; this validates entry DATA
+* against a schema: required-field presence, rejection of unfilled placeholder
+* sentinels (shared vocabulary in `sentinels.ts`), and basic per-type shape
+* checks. It is intentionally lightweight — enough to power scaffold diagnostics
+* and a CLI pre-flight — not a replacement for server-side write validation.
+*/
+function subfieldsOf$1(field) {
+	const direct = field.fields;
+	if (direct && direct.length > 0) return direct;
+	const nested = field.schema?.fields;
+	return nested ?? [];
+}
+function hasRepeaterVariants(field) {
+	return field.itemTypes !== undefined;
+}
+function resolveRepeaterVariantFields(field, item) {
+	if (!hasRepeaterVariants(field)) return subfieldsOf$1(field);
+	const itemTypes = field.itemTypes;
+	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);
+}
+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 assertNever$2(type) {
+	throw new Error(`Unsupported entry field type: ${String(type)}`);
+}
+function scalarRule(type) {
+	switch (type) {
+		case "text":
+		case "textarea":
+		case "url":
+		case "reference":
+		case "date":
+		case "datetime":
+		case "select": return {
+			accepts: (value) => typeof value === "string",
+			expected: "a string"
+		};
+		case "link": return {
+			accepts: (value) => linkSchema.safeParse(normalizeLinkValue(value)).success,
+			expected: "a valid link"
+		};
+		case "number": return {
+			accepts: (value) => typeof value === "number" && !Number.isNaN(value),
+			expected: "a number"
+		};
+		case "boolean": return {
+			accepts: (value) => typeof value === "boolean",
+			expected: "a boolean"
+		};
+		case "richText": return {
+			accepts: (value) => typeof value === "string" || isPlainObject(value),
+			expected: "rich-text (string or document object)"
+		};
+		case "group":
+		case "button":
+		case "media":
+		case "file": return {
+			accepts: isPlainObject,
+			expected: "an object"
+		};
+		case "repeater": return {
+			accepts: Array.isArray,
+			expected: "an array"
+		};
+		default: return assertNever$2(type);
+	}
+}
+function leafTypeErrors(field, value, path) {
+	if (field.type === "media" || field.type === "file") return mediaLeafErrors(field, value, path);
+	if (field.type === "select") return selectLeafErrors(field, value, path);
+	const rule = scalarRule(field.type);
+	return rule.accepts(value) ? [] : [{
+		path,
+		fieldType: field.type,
+		code: "wrong_type",
+		message: `"${path}" must be ${rule.expected}.`
+	}];
+}
+function mediaLeafErrors(field, value, path) {
+	if (isPlainObject(value) && isPlaceholderSentinel(value.identifier)) {
+		return [{
+			path,
+			fieldType: field.type,
+			code: "unfilled_placeholder",
+			message: `"${path}" still contains an unfilled placeholder (${value.identifier}).`
+		}];
+	}
+	return isAllowedIdentifierBearingMedia(field, value) ? [] : [{
+		path,
+		fieldType: field.type,
+		code: "wrong_type",
+		message: `"${path}" must be a media object with an identifier.`
+	}];
+}
+function selectLeafErrors(field, value, path) {
+	if (typeof value !== "string") return [{
+		path,
+		fieldType: field.type,
+		code: "wrong_type",
+		message: `"${path}" must be a string.`
+	}];
+	const options = selectOptionValues(field);
+	return options.length > 0 && !options.includes(value) ? [{
+		path,
+		fieldType: field.type,
+		code: "invalid_option",
+		message: `"${path}" must be one of: ${options.join(", ")}.`
+	}] : [];
+}
+function validateField(field, value, path, allowIncomplete) {
+	const missing = value === undefined || value === null || value === "";
+	if (missing) return field.required === true && !allowIncomplete ? [{
+		path,
+		fieldType: field.type,
+		code: "missing_required",
+		message: `Required field "${path}" is missing.`
+	}] : [];
+	if (isPlaceholderSentinel(value)) return [{
+		path,
+		fieldType: field.type,
+		code: "unfilled_placeholder",
+		message: `"${path}" still contains an unfilled placeholder (${value}).`
+	}];
+	return validatePresentField(field, value, path, allowIncomplete);
+}
+function validatePresentField(field, value, path, allowIncomplete) {
+	if (field.type === "group" || field.type === "button") {
+		return isPlainObject(value) ? validateFields(subfieldsOf$1(field), value, path, allowIncomplete) : [{
+			path,
+			fieldType: field.type,
+			code: "wrong_type",
+			message: `"${path}" must be an object.`
+		}];
+	}
+	if (field.type === "repeater") {
+		return Array.isArray(value) ? value.flatMap((item, index) => validateRepeaterItem(field, item, `${path}[${index}]`, allowIncomplete)) : [{
+			path,
+			fieldType: field.type,
+			code: "wrong_type",
+			message: `"${path}" must be an array.`
+		}];
+	}
+	return leafTypeErrors(field, value, path);
+}
+function validateRepeaterItem(field, item, path, allowIncomplete) {
+	if (!isPlainObject(item)) return [{
+		path,
+		fieldType: "repeater",
+		code: "wrong_type",
+		message: `"${path}" must be an object.`
+	}];
+	const fields = resolveRepeaterVariantFields(field, item);
+	return fields ? validateFields(fields, item, path, allowIncomplete) : [{
+		path,
+		fieldType: "repeater",
+		code: "invalid_option",
+		message: `"${path}" has an unknown or missing repeater item type.`
+	}];
+}
+function validateFields(fields, data, pathPrefix, allowIncomplete) {
+	return fields.flatMap((field) => validateField(field, data[field.id], pathPrefix ? `${pathPrefix}.${field.id}` : field.id, allowIncomplete));
+}
+/** Validate all entry fields, returning every error so callers can fix them in one pass. */
+function validateEntryInstance(input) {
+	const errors = validateFields(input.schema.fields, input.data, "", input.allowIncomplete ?? false);
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+
 //#endregion
 //#region ../content-model/src/referenceFields.ts
 const BUILT_IN_REFERENCE_KINDS = [
@@ -549,6 +612,9 @@ const DISPLAY_MEDIA_KINDS$1 = [
 	"video",
 	"audio"
 ];
+function mapContentFields(fields, context) {
+	return fields.map((field) => toFieldDefinition(field, context)).filter((field) => field !== null);
+}
 function toFieldDefinition(field, context = {}) {
 	const label = field.label ?? startCase(field.id);
 	const base = {
@@ -672,18 +738,26 @@ function toFieldDefinition(field, context = {}) {
 			};
 		}
 		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,
+			const repeater = {
+				...base,
 				type: "repeater",
-				ui: normalizeFieldUi(field.ui),
-				itemLabel: field.itemLabel ?? "Item",
-				schema: { fields: nestedFields$1 }
+				itemLabel: field.itemLabel ?? "Item"
 			};
+			if (hasRepeaterVariants(field)) {
+				return {
+					...repeater,
+					polymorphic: true,
+					itemTypes: Object.fromEntries(Object.entries(field.itemTypes).map(([typeId, variant]) => [typeId, {
+						label: typeof variant.label === "string" ? variant.label : startCase(typeId),
+						fields: mapContentFields(variant.fields ?? [], context)
+					}]))
+				};
+			}
+			const fields = mapContentFields(field.fields ?? field.schema?.fields ?? [], context);
+			return fields.length ? {
+				...repeater,
+				schema: { fields }
+			} : null;
 		}
 		default: return null;
 	}
@@ -706,14 +780,7 @@ function startCase(value) {
 * @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;
+	return mapContentFields(schema.fields ?? [], context);
 }
 function expandButtonFieldGroup(fieldId, fieldLabel, context = {}) {
 	const variants = context.variants ?? [...DEFAULT_BUTTON_VARIANTS];
@@ -1233,26 +1300,7 @@ function getPublishedMetadataFromSnapshot(snapshot, routing) {
 	};
 }
 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 publishedMessage = formatPublishMessage({
-		status: snapshot.status,
-		publishedAt: snapshot.published.publishAt,
-		scheduledAt: snapshot.draft.publishAt
-	});
+	const publishedMessage = formatPublishMessage(snapshot, options.formatPublicationDate);
 	const publishLabel = routeLifecycleContext(snapshot)?.draftStatus === "scheduled" ? "Publish now" : `Publish ${options.entityLabel.toLowerCase()}`;
 	return {
 		currentStatus: snapshot.status,
@@ -1263,6 +1311,15 @@ function buildToolbarState(snapshot, context, options) {
 		values: context.values
 	};
 }
+/** Sentence adapter only; date admission and typography belong to the shared formatter. */
+function formatPublishMessage(snapshot, formatDate) {
+	if (snapshot.status === "published") {
+		const date = snapshot.published.publishAt ? formatDate(snapshot.published.publishAt) : null;
+		return date ? `Published ${date}` : "Published";
+	}
+	const scheduled = snapshot.status === "scheduled" && snapshot.draft.publishAt ? formatDate(snapshot.draft.publishAt) : null;
+	return scheduled ? `Scheduled for ${scheduled}` : "Not yet published";
+}
 
 //#endregion
 //#region ../content-model/src/content-types/schema.ts
@@ -1403,6 +1460,10 @@ const BaseContentFieldSchema = z.object({
 	}
 }).passthrough();
 const ContentFieldSchema = BaseContentFieldSchema.extend({
+	itemTypes: z.lazy(() => z.record(z.string(), z.object({
+		label: z.string().optional(),
+		fields: z.array(ContentFieldSchema).optional()
+	}).passthrough())).optional(),
 	fields: z.lazy(() => z.array(ContentFieldSchema)).optional(),
 	schema: z.lazy(() => z.object({ fields: z.array(ContentFieldSchema).optional() }).passthrough()).optional()
 });
@@ -1516,284 +1577,6 @@ 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). */
@@ -4754,15 +4537,14 @@ const eventBookingOfferInputSchema = classifiedSchema((input) => {
 		}]
 	} : result;
 });
-const eventRunInputSchema = z.object({
+const eventRunCommonInputSchema = 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(),
+	attendeeMigration: sdkEventUpsertOptionalFieldSchemas.attendeeMigration,
 	bookingOffer: eventBookingOfferInputSchema.optional(),
 	capacity: sdkEventUpsertOptionalFieldSchemas.capacity,
 	venueRef: z.string().nullable().optional(),
@@ -4770,6 +4552,10 @@ const eventRunInputSchema = z.object({
 	settings: z.record(z.string(), z.unknown()).optional(),
 	tags: z.array(z.string()).optional()
 }).strict();
+const eventRunInputSchema = z.discriminatedUnion("bookingScope", [eventRunCommonInputSchema.extend({ bookingScope: z.literal("single_occurrence") }).strict(), eventRunCommonInputSchema.extend({
+	bookingScope: z.literal("whole_series"),
+	name: z.string().nullable().optional()
+}).strict()]);
 const eventUpsertInputSchema = z.object({
 	identifier: z.string().min(1).optional(),
 	courseBooking: sdkCourseBookingSettingsSchema.optional(),
@@ -4795,4 +4581,4 @@ const eventUpsertInputSchema = z.object({
 }));
 
 //#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 };
+export { findUnfilledSentinels as i, buildEntryScaffold as n, validateEntryInstance as r, eventUpsertInputSchema as t };