riverbankcms 0.19.0 → 0.21.0

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

@@ -1,6 +1,6 @@
 #!/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 { _ as normalizeLinkValue, a as classifySdkEventSchedule, g as linkSchema, i as sdkEventUpsertOptionalFieldSchemas, n as sdkCourseBookingSettingsSchema, o as classifySdkEventBookingOffer } from "./sdk-event-upsert-CrOuJrxo.mjs";
+import { u as EVENT_PRESET_VALUES } from "./src-BENi4Q5k.mjs";
 import { z } from "zod";
 
 //#region ../blocks/src/lib/typeGuards.ts
@@ -449,6 +449,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 +837,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 +963,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 +1005,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 +1525,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 +1536,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 +1685,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 +1802,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). */
@@ -4324,13 +4332,14 @@ const FIELD_TYPE_CLASSIFICATION = {
 	repeater: "whole",
 	presetOrCustom: "opaque",
 	contentTypeSelect: "opaque",
-	entryPicker: "opaque",
+	entryPicker: "leaf",
 	time: "opaque"
 };
 function classify(type) {
 	return FIELD_TYPE_CLASSIFICATION[type] ?? "unknown";
 }
 function leafToBlockFieldType(type) {
+	if (type === "entryPicker") return "reference";
 	return classify(type) === "leaf" ? type : null;
 }
 /**
@@ -4342,10 +4351,11 @@ function collectLeaves(fields, prefix, out) {
 	for (const field of fields) {
 		const id = prefix ? `${prefix}.${field.id}` : field.id;
 		const cls = classify(field.type);
-		if (cls === "leaf") {
+		const leafType = leafToBlockFieldType(field.type);
+		if (leafType) {
 			out.push({
 				id,
-				type: field.type,
+				type: leafType,
 				required: Boolean(field.required)
 			});
 			continue;
@@ -4366,7 +4376,6 @@ function collectLeaves(fields, prefix, out) {
 				if (tab.fields) collectLeaves(tab.fields, id, out);
 			}
 		}
-		void leafToBlockFieldType;
 	}
 }
 function buildManifestRepeaterShape(field) {
@@ -4754,15 +4763,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 +4778,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(),