@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/validation-3pggwcnm.js

@@ -0,0 +1,396 @@
+import { h as issue } from "./Seo-CjNUtUkj.js";
+import { i as MediaId, u as MediaSelection } from "./Media-DSyvd14o.js";
+import { t as LinkTarget } from "./Links-CJYyy7rC.js";
+import { a as validateObjectDefinition, n as inspectObjectValues, o as fieldPath, s as walk } from "./validation-DpUwPC8Y.js";
+import { a as FormOption, c as FormSteps, i as FormFieldType } from "./contracts-rprW3ZOB.js";
+import { n as checkedBody } from "./EditorSchema-wrDv-id6.js";
+import { i as studioErrorReason } from "./StudioErrors-T5zLGQ1M.js";
+import { n as BlockId } from "./Blocks-BrxSemnd.js";
+import { Result, Schema } from "effect";
+//#region ../model/src/internal/fields/operations.ts
+const ImageReference = Schema.Struct({
+	kind: Schema.Literal("image"),
+	mediaId: MediaId
+});
+function initialFieldValues(collection, title) {
+	return Object.assign({ title }, initialObjectValues(collection.fields));
+}
+function initialObjectValues(fields) {
+	const values = {};
+	for (const field of fields) if ("defaultValue" in field && field.defaultValue !== void 0) values[field.name] = structuredClone(field.defaultValue);
+	else if (field.required) values[field.name] = defaultValue(field);
+	return values;
+}
+function defaultValue(field) {
+	switch (field.kind) {
+		case "object": return initialObjectValues(field.fields);
+		case "list": return [];
+		case "link": return {
+			kind: "url",
+			href: ""
+		};
+		case "multi-select": return [];
+		case "number": return 0;
+		case "boolean": return false;
+		case "select": return field.options[0]?.value ?? "";
+		default: return "";
+	}
+}
+function allFieldDefinitions(fields) {
+	return fields.flatMap((field) => field.kind === "object" || field.kind === "list" ? [field, ...allFieldDefinitions(field.fields)] : [field]);
+}
+function documentReferences(fields, values) {
+	const found = [];
+	for (const location of walk(fields, values)) {
+		if (location.kind !== "field") continue;
+		const { field, value, path, label } = location;
+		if (field.kind === "document") found.push({
+			path: fieldPath(path),
+			label,
+			value,
+			collections: field.collections
+		});
+		else if (field.kind === "link" && Schema.is(LinkTarget)(value) && value.kind === "document") found.push({
+			path: fieldPath(path),
+			label,
+			value: value.documentId
+		});
+	}
+	return found;
+}
+/** Retention is strict about asset identity, but does not require valid image framing. */
+function mediaSelections(value, fields) {
+	if (!Schema.is(Schema.JsonObject)(value)) return [];
+	const found = [];
+	for (const location of walk(fields, value)) {
+		if (location.kind !== "field" || location.value === void 0 || location.value === "") continue;
+		const { field, value: selection } = location;
+		if (field.kind === "image") {
+			if (!Schema.is(ImageReference)(selection)) throw new Error("Structured image needs a valid asset ID.");
+			found.push({
+				kind: "media",
+				mediaId: selection.mediaId,
+				mediaKind: "image"
+			});
+		} else if (field.kind === "media") {
+			if (!Schema.is(MediaSelection)(selection)) throw new Error("Structured media needs a valid asset ID and kind.");
+			found.push(selection);
+		}
+	}
+	return found;
+}
+function copyFieldValues(fields, input, nextId) {
+	const copied = structuredClone(input);
+	for (const location of walk(fields, copied)) if (location.kind === "object" && location.listItem) Object.assign(location.values, { id: nextId() });
+	return copied;
+}
+//#endregion
+//#region ../model/src/internal/forms/structure.ts
+const DraftFormField = Schema.Struct({
+	id: Schema.NonEmptyString,
+	label: Schema.NonEmptyString,
+	answerKey: Schema.optionalKey(Schema.NonEmptyString),
+	type: FormFieldType,
+	help: Schema.optionalKey(Schema.String),
+	required: Schema.optionalKey(Schema.Boolean),
+	minLength: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+	maxLength: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+	min: Schema.optionalKey(Schema.Finite),
+	max: Schema.optionalKey(Schema.Finite),
+	options: Schema.optionalKey(Schema.Array(FormOption))
+});
+const DraftFormSteps = Schema.Array(Schema.Struct({
+	id: Schema.NonEmptyString,
+	title: Schema.NonEmptyString,
+	fields: Schema.Array(DraftFormField).check(Schema.isMinLength(1), Schema.isMaxLength(100))
+})).check(Schema.isMinLength(1), Schema.isMaxLength(20));
+function formRevision(name, capabilities, steps) {
+	return revisionSource(name, capabilities, steps);
+}
+function formStructureIssues(input, capabilities, name) {
+	const parsed = parseFormSteps(input, capabilities, name);
+	return Result.isFailure(parsed) ? parsed.failure : [];
+}
+function parseFormSteps(input, capabilities, name) {
+	const decoded = Schema.decodeUnknownResult(DraftFormSteps)(input, { onExcessProperty: "error" });
+	if (Result.isFailure(decoded)) return Result.fail([studioErrorReason("errors.form.structure")]);
+	const issues = [];
+	if (new TextEncoder().encode(revisionSource(name, capabilities, decoded.success)).byteLength > 6e4) issues.push(studioErrorReason("errors.form.size"));
+	const ids = /* @__PURE__ */ new Set();
+	const keys = /* @__PURE__ */ new Set();
+	for (const step of decoded.success) {
+		if (ids.has(step.id)) issues.push(studioErrorReason("errors.form.identity"));
+		ids.add(step.id);
+		for (const field of step.fields) {
+			if (ids.has(field.id)) issues.push(studioErrorReason("errors.form.identity"));
+			ids.add(field.id);
+			const key = field.answerKey ?? field.id;
+			if (keys.has(key)) issues.push(studioErrorReason("errors.form.answerKeys"));
+			keys.add(key);
+			if ([
+				"_form",
+				"__proto__",
+				"constructor",
+				"prototype"
+			].includes(key)) issues.push(studioErrorReason("errors.form.answerKeyReserved"));
+			if (!capabilities.fieldTypes.includes(field.type)) issues.push(studioErrorReason("errors.form.typeUnavailable", { label: field.label }));
+			for (const rule of [
+				"required",
+				"minLength",
+				"maxLength",
+				"min",
+				"max"
+			]) if (field[rule] !== void 0 && !capabilities.rules.includes(rule)) issues.push(studioErrorReason(`errors.form.${rule}Unavailable`, { label: field.label }));
+			if (field.type !== "text" && field.type !== "email" && field.type !== "textarea") {
+				if (field.minLength !== void 0 || field.maxLength !== void 0) issues.push(studioErrorReason("errors.form.textLimits", { label: field.label }));
+			}
+			if (field.type !== "number" && (field.min !== void 0 || field.max !== void 0)) issues.push(studioErrorReason("errors.form.numberLimits", { label: field.label }));
+			if (field.min !== void 0 && field.max !== void 0 && field.min > field.max) issues.push(studioErrorReason("errors.form.range", { label: field.label }));
+			if (field.minLength !== void 0 && field.maxLength !== void 0 && field.minLength > field.maxLength) issues.push(studioErrorReason("errors.form.lengthRange", { label: field.label }));
+			if (field.type === "select") {
+				if (!field.options?.length || new Set(field.options.map((option) => option.id)).size !== field.options.length) issues.push(studioErrorReason("errors.form.options", { label: field.label }));
+			} else if (field.options?.length) issues.push(studioErrorReason("errors.form.selectOptions", { label: field.label }));
+		}
+	}
+	if (issues.length) return Result.fail(issues);
+	return Schema.decodeUnknownResult(FormSteps)(decoded.success, { onExcessProperty: "error" }).pipe(Result.mapError(() => [studioErrorReason("errors.form.structure")]));
+}
+function revisionSource(name, capabilities, steps) {
+	return JSON.stringify([
+		name,
+		capabilities.fieldTypes,
+		capabilities.rules,
+		steps
+	]);
+}
+//#endregion
+//#region ../model/src/internal/blocks/seed.ts
+/** One editable block with named content regions and stable identity. */
+function seedBlock(block) {
+	const props = block.form ? { steps: seedFormSteps(block.form) } : initialObjectValues(block.fields);
+	return {
+		type: "cmsBlock",
+		attrs: {
+			id: crypto.randomUUID(),
+			name: block.name,
+			props
+		},
+		content: block.slots.filter((slot) => slot.required || slot.initial !== void 0).map(seedSlot)
+	};
+}
+/** One named content region, also used when an optional region is added later. */
+function seedSlot(slot) {
+	return {
+		type: "cmsSlot",
+		attrs: { name: slot.name },
+		content: slot.initial?.length ? structuredClone(slot.initial) : slot.kind === "blocks" ? [] : [{ type: "paragraph" }]
+	};
+}
+function seedFormSteps(capabilities) {
+	const firstType = capabilities.fieldTypes[0];
+	const question = firstType === "select" ? {
+		id: crypto.randomUUID(),
+		label: "Your answer",
+		type: firstType,
+		options: [{
+			id: crypto.randomUUID(),
+			label: "First choice"
+		}]
+	} : {
+		id: crypto.randomUUID(),
+		label: "Your answer",
+		type: firstType ?? "text"
+	};
+	return [{
+		id: crypto.randomUUID(),
+		title: "Your details",
+		fields: [question]
+	}];
+}
+//#endregion
+//#region ../model/src/internal/blocks/validation.ts
+function allowedBlocks(blocks, policy) {
+	if (!policy) return blocks;
+	return blocks.filter((block) => policy.blocks?.includes(block.name) || block.group && policy.groups?.includes(block.group));
+}
+function validateBlockConfiguration(blocks, collections) {
+	const issues = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const block of blocks) {
+		if (names.has(block.name)) issues.push(`Block "${block.name}" is configured twice.`);
+		names.add(block.name);
+		issues.push(...validateObjectDefinition(block.fields, block.label));
+		if (block.form) {
+			if (block.fields.length || block.slots.length) issues.push(`Form block "${block.name}" cannot define ordinary fields or content regions.`);
+			if (new Set(block.form.fieldTypes).size !== block.form.fieldTypes.length) issues.push(`Form block "${block.name}" repeats a question type.`);
+			if (new Set(block.form.rules).size !== block.form.rules.length) issues.push(`Form block "${block.name}" repeats a rule.`);
+		}
+		const slots = /* @__PURE__ */ new Set();
+		for (const slot of block.slots) {
+			if (slots.has(slot.name)) issues.push(`Block "${block.name}" repeats slot "${slot.name}".`);
+			slots.add(slot.name);
+			if (slot.kind === "text" || slot.kind === "inline-text" || slot.kind === "rich-text") {
+				if (slot.blocks || slot.groups) issues.push(`Slot "${block.name}.${slot.name}" cannot select blocks.`);
+			} else if (slot.features) issues.push(`Slot "${block.name}.${slot.name}" cannot select text features.`);
+			if (slot.kind === "text" && slot.features?.length) issues.push(`Text slot "${block.name}.${slot.name}" must be plain text.`);
+			if (slot.kind === "inline-text" && slot.features?.includes("bullet-list")) issues.push(`Inline text slot "${block.name}.${slot.name}" cannot allow lists.`);
+			issues.push(...selectorIssues(slot, blocks, `slot "${block.name}.${slot.name}"`));
+		}
+		try {
+			const initial = checkedBody({
+				type: "doc",
+				content: [seedBlock(block)]
+			});
+			issues.push(...bodyBlockIssues(initial, blocks, void 0, "working").map((issue) => `Block "${block.name}" initial content: ${issue}`));
+		} catch (cause) {
+			issues.push(`Block "${block.name}" initial content is invalid: ${cause instanceof Error ? cause.message : String(cause)}`);
+		}
+	}
+	for (const collection of collections) if (collection.body) issues.push(...selectorIssues(collection.body, blocks, `collection "${collection.collection}"`));
+	return issues;
+}
+function selectorIssues(selector, blocks, owner) {
+	const issues = [];
+	for (const name of selector.blocks ?? []) if (!blocks.some((block) => block.name === name)) issues.push(`Unknown block "${name}" in ${owner}.`);
+	for (const group of selector.groups ?? []) if (!blocks.some((block) => block.group === group)) issues.push(`Unknown block group "${group}" in ${owner}.`);
+	return issues;
+}
+/** Check block identities, properties, content regions, and nested placement against one collection. */
+function inspectBodyBlocks(document, blocks, policy, purpose) {
+	const issues = [];
+	const permitted = new Set(allowedBlocks(blocks, policy).map((block) => block.name));
+	const byName = new Map(blocks.map((block) => [block.name, block]));
+	const ids = /* @__PURE__ */ new Set();
+	function visit(content, allowed, location) {
+		content.forEach((node, _offset, index) => {
+			const path = `${location}[${index}]`;
+			if (node.type.name === "cmsBlock") visitBlock(node, allowed, path);
+			else if (node.type.name === "cmsSlot") issues.push(issue("body.region", { kind: "body" }, `${path} is a content region outside a block.`, { path }));
+			else visit(node, allowed, path);
+		});
+	}
+	function visitBlock(node, allowed, path) {
+		const name = node.attrs.name;
+		const id = node.attrs.id;
+		const location = Schema.is(BlockId)(id) ? {
+			kind: "block",
+			blockId: id,
+			path: []
+		} : {
+			kind: "block",
+			path: []
+		};
+		const problem = (code, message) => {
+			const blockName = Schema.is(Schema.String)(name) ? name : "";
+			const label = byName.get(blockName)?.label;
+			return issue(code, location, message, {
+				name: blockName,
+				...label !== void 0 && { label }
+			});
+		};
+		if (!Schema.is(BlockId)(id) || ids.has(id)) issues.push(problem("block.identity", `${path} needs a unique block ID.`));
+		else ids.add(id);
+		if (!Schema.is(Schema.String)(name)) {
+			issues.push(problem("block.name", `${path} needs a block name.`));
+			return;
+		}
+		const definition = byName.get(name);
+		if (!definition) {
+			issues.push(problem("block.unknown", `Block "${name}" is not configured.`));
+			return;
+		}
+		if (!allowed.has(name)) issues.push(problem("block.placement", `${definition.label} is not allowed in this content region.`));
+		const props = node.attrs.props;
+		const form = definition.form;
+		if (!Schema.is(Schema.JsonObject)(props)) issues.push(problem("block.properties.type", `${definition.label} properties must be an object.`));
+		else if (form) {
+			if (purpose === "publish") {
+				if (Object.keys(props).some((key) => key !== "steps")) issues.push(problem("block.properties.unknown", `${definition.label} has unknown properties.`));
+				issues.push(...formStructureIssues(props.steps, form, definition.name).map((problem) => issue(problem.code, {
+					...location,
+					path: ["steps"]
+				}, problem.message, {
+					fieldTypes: form.fieldTypes,
+					rules: form.rules,
+					...problem.details
+				})));
+			}
+		} else issues.push(...inspectObjectValues(definition.fields, props, purpose, definition.label).map((problem) => ({
+			...problem,
+			location: {
+				...location,
+				path: "path" in problem.location ? problem.location.path ?? [] : []
+			}
+		})));
+		const usedSlots = /* @__PURE__ */ new Set();
+		node.forEach((region) => {
+			const slotName = region.attrs.name;
+			if (!Schema.is(Schema.String)(slotName)) {
+				issues.push(problem("block.slot.name", `${definition.label} has an unnamed content region.`));
+				return;
+			}
+			if (usedSlots.has(slotName)) issues.push(issue("block.slot.duplicate", {
+				...location,
+				path: ["slots", slotName]
+			}, `${definition.label} repeats content region "${slotName}".`, { label: definition.label }));
+			usedSlots.add(slotName);
+			const slot = definition.slots.find((candidate) => candidate.name === slotName);
+			if (!slot) {
+				issues.push(issue("block.slot.unknown", {
+					...location,
+					path: ["slots", slotName]
+				}, `${definition.label} has unknown content region "${slotName}".`, { label: definition.label }));
+				return;
+			}
+			validateSlot(region, slot, `${definition.label} → ${slot.label}`, {
+				...location,
+				path: ["slots", slot.name]
+			});
+		});
+		if (purpose === "publish") {
+			for (const slot of definition.slots) if (slot.required && !usedSlots.has(slot.name)) issues.push(issue("block.slot.required", {
+				...location,
+				path: ["slots", slot.name]
+			}, `${definition.label} → ${slot.label} is required.`, { label: `${definition.label} → ${slot.label}` }));
+		}
+	}
+	function validateSlot(region, slot, label, location) {
+		const problem = (code, message) => issue(code, location, message, {
+			label,
+			kind: slot.kind,
+			features: slot.features ?? []
+		});
+		let containsContent = false;
+		region.descendants((node) => {
+			if (node.type.name === "cmsBlock" || slot.kind === "content" && ["image", "video"].includes(node.type.name)) containsContent = true;
+		});
+		if (purpose === "publish" && slot.required && !region.textContent.trim() && !containsContent) issues.push(problem("block.slot.required", `${label} is required.`));
+		if (slot.kind === "text" || slot.kind === "inline-text" || slot.kind === "rich-text") {
+			if (slot.kind !== "rich-text" && region.childCount > 1) issues.push(problem("block.slot.paragraphs", `${label} allows one paragraph.`));
+			region.forEach((child) => {
+				if (child.type.name === "paragraph") return;
+				if (slot.kind === "rich-text" && child.type.name === "bulletList" && slot.features?.includes("bullet-list")) return;
+				issues.push(problem("block.slot.content", `${label} allows text only.`));
+			});
+			region.descendants((child) => {
+				if (child.type.name !== "paragraph" && child.type.name !== "text" && child.type.name !== "hardBreak" && !(slot.kind === "rich-text" && slot.features?.includes("bullet-list") && (child.type.name === "bulletList" || child.type.name === "listItem"))) issues.push(problem("block.slot.content", `${label} allows text only.`));
+				for (const mark of child.marks) {
+					const name = mark.type.name;
+					if (slot.kind === "text" || !slot.features?.some((feature) => feature === name)) issues.push(problem("block.slot.format", `${label} does not allow ${mark.type.name} formatting.`));
+				}
+			});
+			return;
+		}
+		if (slot.kind === "blocks") region.forEach((child) => {
+			if (child.type.name !== "cmsBlock") issues.push(problem("block.slot.content", `${label} allows blocks only.`));
+		});
+		visit(region, new Set(allowedBlocks(blocks, slot.blocks === void 0 && slot.groups === void 0 ? void 0 : slot).map((block) => block.name).filter((name) => permitted.has(name))), label);
+	}
+	visit(document, permitted, "Body");
+	return issues;
+}
+function bodyBlockIssues(...args) {
+	return inspectBodyBlocks(...args).map((issue) => issue.message);
+}
+//#endregion
+export { parseFormSteps as a, documentReferences as c, formRevision as i, initialFieldValues as l, inspectBodyBlocks as n, allFieldDefinitions as o, validateBlockConfiguration as r, copyFieldValues as s, bodyBlockIssues as t, mediaSelections as u };

package/src/validation-DpUwPC8Y.js

@@ -0,0 +1,224 @@
+import { f as isCalendarDate, h as issue, p as IssuePath } from "./Seo-CjNUtUkj.js";
+import { u as MediaSelection } from "./Media-DSyvd14o.js";
+import { l as DocumentId } from "./Document-CKXMSEf1.js";
+import { n as safeLinkHref, t as LinkTarget } from "./Links-CJYyy7rC.js";
+import { t as AuthoredImage } from "./Image-CJWPLnhP.js";
+import { r as ListItemId } from "./Fields-ioGaMEh9.js";
+import { Predicate, Result, Schema, SchemaIssue } from "effect";
+//#region ../model/src/internal/fields/walk.ts
+/** Traverse only configured containers; shape alone never makes ordinary data a managed reference. */
+function* walk(fields, values, path = [], label = "", listItem = false) {
+	yield {
+		kind: "object",
+		fields,
+		values,
+		path,
+		label,
+		listItem
+	};
+	for (const field of fields) {
+		const value = values[field.name];
+		const currentPath = [...path, field.name];
+		const currentLabel = label ? label + " → " + field.label : field.label;
+		yield {
+			kind: "field",
+			field,
+			value,
+			path: currentPath,
+			label: currentLabel
+		};
+		if (field.kind === "object" && Schema.is(Schema.JsonObject)(value)) yield* walk(field.fields, value, currentPath, currentLabel);
+		else if (field.kind === "list" && Array.isArray(value)) {
+			for (const [index, item] of value.entries()) if (Schema.is(Schema.JsonObject)(item)) yield* walk(field.fields, item, [...currentPath, index], currentLabel + " item " + (index + 1), true);
+		}
+	}
+}
+function fieldPath(path) {
+	return path.reduce((result, segment) => result + (Schema.is(Schema.Finite)(segment) ? "[" + segment + "]" : (result ? "." : "") + segment), "");
+}
+//#endregion
+//#region ../model/src/internal/fields/validation.ts
+function validateCollectionDefinition(collection) {
+	const issues = definitionIssues(collection.fields, collection.collection, true);
+	if (collection.title && !ordered(collection.title.minLength, collection.title.maxLength)) issues.push("Title bounds must be ordered.");
+	return issues;
+}
+function validateObjectDefinition(fields, label) {
+	return definitionIssues(fields, label);
+}
+function definitionIssues(fields, scope, topLevel = false) {
+	const issues = [];
+	const names = new Set(topLevel ? ["title"] : ["id"]);
+	for (const field of fields) {
+		if (names.has(field.name)) issues.push(`${topLevel ? `Collection "${scope}"` : scope} repeats field "${field.name}".`);
+		names.add(field.name);
+		if (field.kind === "text" || field.kind === "textarea") {
+			if (!ordered(field.minLength, field.maxLength)) issues.push(field.label + " bounds must be ordered.");
+		} else if (field.kind === "number" && !ordered(field.min, field.max)) issues.push(field.label + " bounds must be ordered.");
+		if (field.kind === "select" || field.kind === "multi-select") {
+			const values = field.options.map((option) => option.value);
+			if (field.kind === "select" && values.length === 0 || new Set(values).size !== values.length) issues.push(`Field "${field.label}" needs unique choices.`);
+		}
+		if (field.kind === "document" && field.collections) {
+			if (field.collections.length === 0) issues.push(`Field "${field.label}" needs an allowed collection.`);
+			if (new Set(field.collections).size !== field.collections.length) issues.push(`Field "${field.label}" repeats an allowed collection.`);
+		}
+		if (field.kind === "object" || field.kind === "list") {
+			if (field.fields.length === 0) issues.push(`Field "${field.label}" needs child fields.`);
+			issues.push(...definitionIssues(field.fields, field.label));
+		} else if ("defaultValue" in field && field.defaultValue !== void 0) {
+			const issue = fieldIssues({
+				...field,
+				required: field.kind === "link" && field.required
+			}, field.defaultValue, "publish")[0];
+			if (issue) issues.push(`Invalid default for ${field.label}: ${issue.message}`);
+		}
+	}
+	return issues;
+}
+function inspectFieldValues(collection, values, purpose) {
+	const issues = [];
+	const title = values.title;
+	if (!Schema.is(Schema.String)(title) || !title.trim()) issues.push(issue("field.required", {
+		kind: "field",
+		path: ["title"]
+	}, "Document title is required."));
+	else if (collection.title) issues.push(...fieldIssues({
+		name: "title",
+		kind: "text",
+		label: "Title",
+		required: true,
+		...collection.title
+	}, title, purpose));
+	issues.push(...objectIssues(collection.fields, values, purpose, collection.label, true));
+	return issues;
+}
+function ordered(min, max) {
+	return min === void 0 || max === void 0 || min <= max;
+}
+function objectIssues(fields, values, purpose, label, topLevel = false) {
+	const issues = [];
+	for (const location of walk(fields, values, [], topLevel ? "" : label)) {
+		if (location.kind === "field") {
+			issues.push(...fieldIssues(location.field, location.value, purpose, location.path, location.label));
+			continue;
+		}
+		const root = topLevel && location.path.length === 0;
+		const names = /* @__PURE__ */ new Set([...root ? ["title"] : [], ...location.fields.map((field) => field.name)]);
+		for (const name of Object.keys(location.values)) {
+			if (names.has(name) || location.listItem && name === "id") continue;
+			issues.push(issue("field.unknown", {
+				kind: "field",
+				path: [...location.path, name]
+			}, root ? "Field \"" + name + "\" is not configured for " + label + "." : location.label + " contains unconfigured field \"" + name + "\"."));
+		}
+	}
+	return issues;
+}
+function fieldIssues(field, value, purpose, path = [field.name], label = field.label) {
+	const details = field.kind === "select" || field.kind === "multi-select" ? {
+		kind: field.kind,
+		label: field.label,
+		choices: field.options.map((option) => option.value).sort()
+	} : {
+		kind: field.kind,
+		label: field.label,
+		...field.kind === "media" && { mediaKind: field.mediaKind },
+		...(field.kind === "text" || field.kind === "textarea") && {
+			...field.minLength !== void 0 && { minLength: field.minLength },
+			...field.maxLength !== void 0 && { maxLength: field.maxLength }
+		},
+		...field.kind === "number" && {
+			...field.integer !== void 0 && { integer: field.integer },
+			...field.min !== void 0 && { min: field.min },
+			...field.max !== void 0 && { max: field.max }
+		}
+	};
+	const problem = (code, message, at = path) => issue(code, {
+		kind: "field",
+		path: at
+	}, message, details);
+	if (value === void 0) return field.required && purpose === "publish" ? [problem("field.required", `${label} is required.`)] : [];
+	if (field.kind === "object") {
+		if (!Schema.is(Schema.JsonObject)(value)) return [problem("field.type", `${label} must be an object.`)];
+		return [];
+	}
+	if (field.kind === "list") {
+		if (!Array.isArray(value)) return [problem("field.type", `${label} must be a list.`)];
+		if (field.required && purpose === "publish" && value.length === 0) return [problem("field.required", `${label} is required.`)];
+		const issues = [];
+		const ids = /* @__PURE__ */ new Set();
+		value.forEach((item, index) => {
+			const itemLabel = `${label} item ${index + 1}`;
+			if (!Schema.is(Schema.JsonObject)(item)) {
+				issues.push(problem("field.type", `${itemLabel} must be an object.`, [...path, index]));
+				return;
+			}
+			if (!Schema.is(ListItemId)(item.id) || ids.has(item.id)) issues.push(problem("field.identity", `${itemLabel} needs a unique ID.`, [...path, index]));
+			else ids.add(item.id);
+		});
+		return issues;
+	}
+	if (field.kind === "multi-select") {
+		if (!Array.isArray(value)) return [problem("field.type", `${label} must be a list of text.`)];
+		const values = value.filter(Schema.is(Schema.String));
+		if (values.length !== value.length) return [problem("field.type", `${label} must be a list of text.`)];
+		if (field.required && purpose === "publish" && values.length === 0) return [problem("field.required", `${label} is required.`)];
+		if (values.some((item) => !item.trim()) || new Set(values).size !== values.length) return [problem("field.format", `${label} needs unique, nonempty values.`)];
+		if (field.options.length && values.some((item) => !field.options.some((option) => option.value === item))) return [problem("field.choice", `${label} must use available choices.`)];
+		return [];
+	}
+	if (field.kind === "document") {
+		if (value === "" && (purpose === "working" || !field.required)) return [];
+		return Schema.is(DocumentId)(value) ? [] : [problem("field.format", `${label} needs a valid document.`)];
+	}
+	if (field.kind === "link") {
+		if (!Schema.is(LinkTarget)(value)) return [problem("field.format", `${label} needs a valid link.`)];
+		if (value.kind === "url") {
+			if (!value.href) return field.required && purpose === "publish" ? [problem("field.required", `${label} is required.`)] : [];
+			return purpose === "working" || safeLinkHref(value.href) ? [] : [problem("field.format", `${label} needs a valid link.`)];
+		}
+		return value.path.startsWith("/") && safeLinkHref(value.path) ? [] : [problem("field.format", `${label} needs a valid page route.`)];
+	}
+	if (field.kind === "media") {
+		if (value === "" && (purpose === "working" || !field.required)) return [];
+		return Schema.is(MediaSelection)(value) && value.mediaKind === field.mediaKind ? [] : [problem("field.format", `${label} needs a valid ${field.mediaKind}.`)];
+	}
+	if (field.kind === "image") {
+		if (value === "" && (purpose === "working" || !field.required)) return [];
+		const result = Schema.decodeUnknownResult(AuthoredImage, { errors: "all" })(value);
+		if (Result.isSuccess(result)) return [];
+		return SchemaIssue.makeFormatterStandardSchemaV1()(result.failure.issue).issues.map((failure) => {
+			const suffix = failure.path?.map((segment) => Predicate.isObject(segment) ? segment.key : segment) ?? [];
+			return problem("field.format", label + " needs a valid image.", [...path, ...Schema.is(IssuePath)(suffix) ? suffix : []]);
+		});
+	}
+	if (field.kind === "number") {
+		if (!Schema.is(Schema.Finite)(value)) return [problem("field.type", label + " must be a number.")];
+		if (purpose === "publish") {
+			if (field.integer && !Number.isSafeInteger(value)) return [problem("field.integer", label + ": Needs a whole number.")];
+			if (field.min !== void 0 && value < field.min) return [problem("field.minimum", label + ": Needs a value of at least " + field.min + ".")];
+			if (field.max !== void 0 && value > field.max) return [problem("field.maximum", label + ": Needs a value of at most " + field.max + ".")];
+		}
+		return [];
+	}
+	if (field.kind === "boolean") return Schema.is(Schema.Boolean)(value) ? [] : [problem("field.type", `${label} must be a toggle.`)];
+	if (!Schema.is(Schema.String)(value)) return [problem("field.type", `${label} must be text.`)];
+	if (purpose === "publish" && field.required && !value.trim()) return [problem("field.required", `${label} is required.`)];
+	if (purpose === "publish" && (field.kind === "text" || field.kind === "textarea")) {
+		if (field.minLength !== void 0 && value.trim().length < field.minLength) return [problem("field.minimumLength", label + ": Needs at least " + field.minLength + " characters.")];
+		if (field.maxLength !== void 0 && value.length > field.maxLength) return [problem("field.maximumLength", label + ": Needs at most " + field.maxLength + " characters.")];
+	}
+	if (field.kind === "select" && value && !field.options.some((option) => option.value === value)) return [problem("field.choice", `${label} must use an available choice.`)];
+	if (field.kind === "icon" && value && !/^i-lucide-[a-z0-9-]+$/u.test(value)) return [problem("field.format", `${label} needs a Lucide icon.`)];
+	if (field.kind === "date" && value && !isCalendarDate(value)) return [problem("field.format", `${label} needs a valid date.`)];
+	return [];
+}
+function inspectObjectValues(fields, values, purpose, label) {
+	return objectIssues(fields, values, purpose, label);
+}
+function validateFieldValues(collection, values, purpose) {
+	return inspectFieldValues(collection, values, purpose).map((issue) => issue.message);
+}
+//#endregion
+export { validateObjectDefinition as a, validateFieldValues as i, inspectObjectValues as n, fieldPath as o, validateCollectionDefinition as r, walk as s, inspectFieldValues as t };