@contentrain/mcp 1.2.1 → 1.4.0

package/dist/validator-B0nNRFeU.mjs

@@ -0,0 +1,906 @@
+import { i as metaFilePath, n as contentFilePath, r as documentFilePath, t as contentDirPath } from "./paths-CYl5vCBD.mjs";
+import { c as writeText, s as writeJson } from "./fs-DLbVB-Ek.mjs";
+import { t as readConfig } from "./config-BIl5Ybj0.mjs";
+import { C as LocalReader, f as parseFrontmatter, g as resolveLocaleStrategy, o as listModels, s as readModel } from "./model-manager-BhLsUgaB.mjs";
+import { r as writeMeta } from "./meta-manager-C900rEyG.mjs";
+import { join } from "node:path";
+import { detectSecrets, validateFieldValue } from "@contentrain/types";
+import { rm } from "node:fs/promises";
+//#region src/core/validator/entry.ts
+/**
+* Validate a single content entry against its model's field schema.
+*
+* Merges the rule sets from MCP's legacy `validator.ts` (secret detection,
+* schema validation, unique constraints) with Studio's `content-validation.ts`
+* (email/url heuristics, polymorphic relation structure, nested object and
+* array-of-object recursion). The union is the authoritative per-entry
+* validator — both MCP's project validator and Studio's save path should
+* converge on this function over time.
+*
+* Asynchronous relation-integrity checks (does the referenced entry exist?)
+* live in `relation-integrity.ts` because they require I/O.
+*/
+function validateContent(data, fields, modelId, locale, entryId, ctx) {
+	const errors = [];
+	for (const [fieldId, def] of Object.entries(fields)) {
+		const value = data[fieldId];
+		errors.push(...validateField(value, def, modelId, locale, entryId, fieldId, ctx));
+	}
+	return {
+		valid: errors.filter((e) => e.severity === "error").length === 0,
+		errors
+	};
+}
+function validateField(value, def, modelId, locale, entryId, fieldId, ctx) {
+	const errors = [];
+	const errCtx = {
+		model: modelId,
+		locale,
+		entry: entryId,
+		field: fieldId
+	};
+	if (value !== null && value !== void 0 && value !== "") {
+		const secretErrors = detectSecrets(value);
+		for (const e of secretErrors) errors.push({
+			...e,
+			...errCtx
+		});
+	}
+	if (!(def.type === "relation" || def.type === "relations")) {
+		const fieldErrors = validateFieldValue(value, def);
+		if (fieldErrors.length > 0) {
+			for (const e of fieldErrors) errors.push({
+				...e,
+				...errCtx
+			});
+			if (fieldErrors.some((e) => e.severity === "error")) return errors;
+		}
+	} else if (def.required && (value === null || value === void 0 || value === "")) {
+		errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId} is required`
+		});
+		return errors;
+	}
+	if (value === null || value === void 0) return errors;
+	if (def.unique && ctx?.allEntries) {
+		const valueKey = String(value);
+		for (const [otherId, otherEntry] of Object.entries(ctx.allEntries)) {
+			if (otherId === ctx.currentEntryId) continue;
+			const otherValue = otherEntry[fieldId];
+			if (otherValue !== null && otherValue !== void 0 && String(otherValue) === valueKey) {
+				errors.push({
+					severity: "error",
+					...errCtx,
+					message: `${fieldId} must be unique — "${String(value)}" already exists in entry ${otherId}`
+				});
+				break;
+			}
+		}
+	}
+	if (def.type === "email" && typeof value === "string" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) errors.push({
+		severity: "warning",
+		...errCtx,
+		message: `${fieldId} may not be a valid email`
+	});
+	if (def.type === "url" && typeof value === "string" && !/^https?:\/\/.+/.test(value) && !value.startsWith("/")) errors.push({
+		severity: "warning",
+		...errCtx,
+		message: `${fieldId} may not be a valid URL`
+	});
+	if (def.type === "relation" && def.model) {
+		const targets = Array.isArray(def.model) ? def.model : [def.model];
+		if (targets.length > 1) if (typeof value !== "object" || value === null || !("model" in value) || !("ref" in value)) errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId} must be { model, ref } for polymorphic relation`
+		});
+		else {
+			const polyVal = value;
+			if (!targets.includes(polyVal.model)) errors.push({
+				severity: "error",
+				...errCtx,
+				message: `${fieldId} target model "${polyVal.model}" must be one of: ${targets.join(", ")}`
+			});
+		}
+		else if (typeof value !== "string") errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId} must be a string (entry ID or slug)`
+		});
+	}
+	if (def.type === "relations") if (!Array.isArray(value)) errors.push({
+		severity: "error",
+		...errCtx,
+		message: `${fieldId} must be an array`
+	});
+	else {
+		if (def.min !== void 0 && value.length < def.min) errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId} must have at least ${def.min} items`
+		});
+		if (def.max !== void 0 && value.length > def.max) errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId} must have at most ${def.max} items`
+		});
+		for (let i = 0; i < value.length; i++) if (typeof value[i] !== "string") errors.push({
+			severity: "error",
+			...errCtx,
+			message: `${fieldId}[${i}] must be a string (entry ID or slug)`
+		});
+	}
+	if (def.type === "array" && Array.isArray(value) && def.items && typeof def.items === "string") for (let i = 0; i < value.length; i++) errors.push(...validateArrayItemType(value[i], def.items, errCtx, `${fieldId}[${i}]`));
+	if (def.type === "object" && def.fields && typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const nested = validateContent(value, def.fields, modelId, locale, entryId);
+		errors.push(...nested.errors);
+	}
+	if (def.type === "array" && Array.isArray(value) && def.items && typeof def.items === "object" && def.items.type === "object" && def.items.fields) {
+		for (let i = 0; i < value.length; i++) if (typeof value[i] === "object" && value[i] !== null) {
+			const nested = validateContent(value[i], def.items.fields, modelId, locale, entryId);
+			for (const e of nested.errors) errors.push({
+				...e,
+				field: `${fieldId}[${i}].${e.field}`
+			});
+		}
+	}
+	return errors;
+}
+function validateArrayItemType(value, itemType, errCtx, fieldPath) {
+	const ctx = {
+		...errCtx,
+		field: fieldPath
+	};
+	switch (itemType) {
+		case "string":
+		case "email":
+		case "url":
+		case "slug":
+		case "image":
+		case "video":
+		case "file":
+			if (typeof value !== "string") return [{
+				severity: "error",
+				...ctx,
+				message: `${fieldPath} must be a string`
+			}];
+			break;
+		case "number":
+		case "integer":
+		case "decimal":
+			if (typeof value !== "number") return [{
+				severity: "error",
+				...ctx,
+				message: `${fieldPath} must be a number`
+			}];
+			if (itemType === "integer" && !Number.isInteger(value)) return [{
+				severity: "error",
+				...ctx,
+				message: `${fieldPath} must be an integer`
+			}];
+			break;
+		case "boolean":
+			if (typeof value !== "boolean") return [{
+				severity: "error",
+				...ctx,
+				message: `${fieldPath} must be a boolean`
+			}];
+			break;
+	}
+	return [];
+}
+//#endregion
+//#region src/core/validator/relation-integrity.ts
+/**
+* Verify that relation and relations fields reference targets that actually
+* exist. Two severities are supported — Studio's per-save flow emits
+* `warning` (the referenced entry may still be drafted), while MCP's
+* project-wide validator emits `error` and additionally flags missing
+* target models via `resolveTarget`.
+*
+* The loader abstraction keeps this function I/O-agnostic: MCP wires it
+* to filesystem reads through LocalReader, Studio wires it to a
+* `GitProvider.readFile`-backed loader, mocks pass in-memory maps.
+*/
+async function checkRelationIntegrity(data, fields, modelId, locale, entryId, loadContent, opts = {}) {
+	const errors = [];
+	const severity = opts.severity ?? "warning";
+	const resolve = opts.resolveTarget ?? (async (id, loc) => {
+		return {
+			exists: true,
+			content: await loadContent(id, loc)
+		};
+	});
+	for (const [fieldId, def] of Object.entries(fields)) {
+		const value = data[fieldId];
+		if (value === null || value === void 0) continue;
+		if (def.type === "relation" && def.model) {
+			const targets = Array.isArray(def.model) ? def.model : [def.model];
+			if (targets.length > 1 && typeof value === "object" && value !== null) {
+				const polyVal = value;
+				if (polyVal.model && polyVal.ref) {
+					const resolved = await resolve(polyVal.model, locale);
+					if (!resolved.exists) errors.push({
+						severity,
+						model: modelId,
+						locale,
+						entry: entryId,
+						field: fieldId,
+						message: `Broken relation: target model "${polyVal.model}" not found`
+					});
+					else if (resolved.content && !(polyVal.ref in resolved.content)) errors.push({
+						severity,
+						model: modelId,
+						locale,
+						entry: entryId,
+						field: fieldId,
+						message: `Broken relation: "${polyVal.ref}" not found in ${polyVal.model}`
+					});
+				}
+			} else if (typeof value === "string" && targets[0]) {
+				const resolved = await resolve(targets[0], locale);
+				if (!resolved.exists) errors.push({
+					severity,
+					model: modelId,
+					locale,
+					entry: entryId,
+					field: fieldId,
+					message: `Broken relation: target model "${targets[0]}" not found`
+				});
+				else if (resolved.content && !(value in resolved.content)) errors.push({
+					severity,
+					model: modelId,
+					locale,
+					entry: entryId,
+					field: fieldId,
+					message: `Broken relation: "${value}" not found in ${targets[0]}`
+				});
+			}
+		}
+		if (def.type === "relations" && def.model && Array.isArray(value)) {
+			const target = Array.isArray(def.model) ? def.model[0] : def.model;
+			if (target) {
+				const resolved = await resolve(target, locale);
+				if (!resolved.exists) errors.push({
+					severity,
+					model: modelId,
+					locale,
+					entry: entryId,
+					field: fieldId,
+					message: `Broken relation: target model "${target}" not found`
+				});
+				else if (resolved.content) {
+					for (const ref of value) if (typeof ref === "string" && !(ref in resolved.content)) errors.push({
+						severity,
+						model: modelId,
+						locale,
+						entry: entryId,
+						field: fieldId,
+						message: `Broken relation: "${ref}" not found in ${target}`
+					});
+				}
+			}
+		}
+	}
+	return errors;
+}
+//#endregion
+//#region src/core/validator/schedule.ts
+/**
+* Validate `publish_at` and `expire_at` meta fields.
+*
+* Rules (matches legacy `validator.ts:validateScheduleFields`):
+* - `publish_at` must parse as a valid Date
+* - `expire_at` must parse as a valid Date
+* - When both are present, `expire_at` must be strictly after `publish_at`
+*/
+function validateScheduleFields(meta, ctx, issues) {
+	if (meta.publish_at !== void 0) {
+		const d = new Date(meta.publish_at);
+		if (Number.isNaN(d.getTime())) issues.push({
+			severity: "error",
+			...ctx,
+			message: `Invalid publish_at date: "${meta.publish_at}". Must be a valid ISO 8601 date string.`
+		});
+	}
+	if (meta.expire_at !== void 0) {
+		const d = new Date(meta.expire_at);
+		if (Number.isNaN(d.getTime())) issues.push({
+			severity: "error",
+			...ctx,
+			message: `Invalid expire_at date: "${meta.expire_at}". Must be a valid ISO 8601 date string.`
+		});
+	}
+	if (meta.publish_at !== void 0 && meta.expire_at !== void 0) {
+		const pubDate = new Date(meta.publish_at);
+		const expDate = new Date(meta.expire_at);
+		if (!Number.isNaN(pubDate.getTime()) && !Number.isNaN(expDate.getTime()) && expDate <= pubDate) issues.push({
+			severity: "error",
+			...ctx,
+			message: `expire_at ("${meta.expire_at}") must be after publish_at ("${meta.publish_at}").`
+		});
+	}
+}
+//#endregion
+//#region src/core/validator/project.ts
+async function readJsonViaReader(reader, path) {
+	try {
+		return JSON.parse(await reader.readFile(path));
+	} catch {
+		return null;
+	}
+}
+async function readTextViaReader(reader, path) {
+	try {
+		return await reader.readFile(path);
+	} catch {
+		return null;
+	}
+}
+/**
+* Build a `resolveTarget` adapter for `checkRelationIntegrity` that walks
+* the project's content store via the shared {@link RepoReader}. Mirrors
+* the target-resolution shape the legacy `checkRelation` used — collection
+* targets return their entry object-map, documents return a "slug exists"
+* marker map, singletons and dictionaries return null content so the
+* checker skips key enforcement for them.
+*/
+function buildProjectTargetResolver(reader) {
+	return async (targetModelId, targetLocale) => {
+		const targetModel = await readModel(reader, targetModelId);
+		if (!targetModel) return { exists: false };
+		if (targetModel.kind === "document") {
+			const slugs = await discoverDocumentSlugs(reader, contentDirPath(targetModel), targetModel);
+			return {
+				exists: true,
+				content: Object.fromEntries(slugs.map((s) => [s, true]))
+			};
+		}
+		if (targetModel.kind === "singleton" || targetModel.kind === "dictionary") return {
+			exists: true,
+			content: null
+		};
+		return {
+			exists: true,
+			content: await readJsonViaReader(reader, contentFilePath(targetModel, targetLocale)) ?? {}
+		};
+	};
+}
+/**
+* Scan an entry's data fields for detected secrets in UNDECLARED keys —
+* the legacy validator also flagged stray/rogue fields that were not in
+* `model.fields`. `validateContent` only knows about declared fields, so
+* this complementary pass preserves that coverage.
+*/
+function scanUndeclaredFieldsForSecrets(data, declared, ctx, issues) {
+	for (const [fieldName, value] of Object.entries(data)) {
+		if (declared && fieldName in declared) continue;
+		if (detectSecrets(value).length > 0) issues.push({
+			severity: "error",
+			...ctx,
+			field: fieldName,
+			message: `Potential secret detected in field "${fieldName}"`
+		});
+	}
+}
+async function validateCollectionModel(reader, projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const locales = config.locales.supported;
+	const localeEntryIds = {};
+	const allEntryIds = /* @__PURE__ */ new Set();
+	const resolveTarget = buildProjectTargetResolver(reader);
+	for (const locale of locales) {
+		const filePath = contentFilePath(model, locale);
+		const data = await readJsonViaReader(reader, filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix && projectRoot) {
+					await writeJson(join(projectRoot, filePath), {});
+					fixed++;
+				}
+			}
+			continue;
+		}
+		const ids = new Set(Object.keys(data));
+		localeEntryIds[locale] = ids;
+		for (const id of ids) allEntryIds.add(id);
+		const keys = Object.keys(data);
+		const sorted = [...keys].toSorted();
+		if (keys.join(",") !== sorted.join(",")) {
+			issues.push({
+				severity: "warning",
+				model: model.id,
+				locale,
+				message: "Content file keys not in canonical order"
+			});
+			if (fix && projectRoot) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(join(projectRoot, filePath), resorted);
+				fixed++;
+			}
+		}
+		for (const [entryId, fields] of Object.entries(data)) {
+			entriesChecked++;
+			scanUndeclaredFieldsForSecrets(fields, model.fields, {
+				model: model.id,
+				locale,
+				entry: entryId
+			}, issues);
+			if (!model.fields) continue;
+			const entryResult = validateContent(fields, model.fields, model.id, locale, entryId, {
+				allEntries: data,
+				currentEntryId: entryId
+			});
+			issues.push(...entryResult.errors);
+			const relationErrors = await checkRelationIntegrity(fields, model.fields, model.id, locale, entryId, async () => null, {
+				severity: "error",
+				resolveTarget
+			});
+			issues.push(...relationErrors);
+		}
+	}
+	if (model.i18n && Object.keys(localeEntryIds).length > 1) {
+		const localeKeys = Object.keys(localeEntryIds);
+		for (let i = 1; i < localeKeys.length; i++) {
+			const locA = localeKeys[0];
+			const locB = localeKeys[i];
+			const idsA = localeEntryIds[locA];
+			const idsB = localeEntryIds[locB];
+			for (const id of idsA) if (!idsB.has(id)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale: locB,
+				entry: id,
+				message: `Entry parity: entry "${id}" exists in ${locA} but missing in ${locB}`
+			});
+			for (const id of idsB) if (!idsA.has(id)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale: locA,
+				entry: id,
+				message: `Entry parity: entry "${id}" exists in ${locB} but missing in ${locA}`
+			});
+		}
+	}
+	for (const locale of locales) {
+		const metaRelPath = metaFilePath(model, locale);
+		const metaData = await readJsonViaReader(reader, metaRelPath);
+		const contentData = await readJsonViaReader(reader, contentFilePath(model, locale)) ?? {};
+		if (metaData) for (const metaEntryId of Object.keys(metaData)) {
+			validateScheduleFields(metaData[metaEntryId], {
+				model: model.id,
+				locale,
+				entry: metaEntryId
+			}, issues);
+			if (!(metaEntryId in contentData)) {
+				issues.push({
+					severity: "warning",
+					model: model.id,
+					locale,
+					entry: metaEntryId,
+					message: `Orphan meta: meta entry "${metaEntryId}" exists but content entry missing`
+				});
+				if (fix && projectRoot) {
+					delete metaData[metaEntryId];
+					const metaAbs = join(projectRoot, metaRelPath);
+					if (Object.keys(metaData).length > 0) await writeJson(metaAbs, metaData);
+					else await rm(metaAbs, { force: true });
+					fixed++;
+				}
+			}
+		}
+		for (const entryId of Object.keys(contentData)) if (!metaData || !(entryId in metaData)) {
+			issues.push({
+				severity: "warning",
+				model: model.id,
+				locale,
+				entry: entryId,
+				message: `Orphan content: entry "${entryId}" has no metadata`
+			});
+			if (fix && projectRoot) {
+				await writeMeta(projectRoot, model, {
+					locale,
+					entryId
+				}, {
+					status: "draft",
+					source: "import",
+					updated_by: "contentrain-mcp"
+				});
+				fixed++;
+			}
+		}
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function validateSingletonModel(reader, projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	for (const locale of config.locales.supported) {
+		const filePath = contentFilePath(model, locale);
+		const data = await readJsonViaReader(reader, filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix && projectRoot) {
+					await writeJson(join(projectRoot, filePath), {});
+					fixed++;
+				}
+			}
+			continue;
+		}
+		entriesChecked++;
+		scanUndeclaredFieldsForSecrets(data, model.fields, {
+			model: model.id,
+			locale
+		}, issues);
+		if (model.fields) {
+			const entryResult = validateContent(data, model.fields, model.id, locale);
+			issues.push(...entryResult.errors);
+			const resolveTarget = buildProjectTargetResolver(reader);
+			const relationErrors = await checkRelationIntegrity(data, model.fields, model.id, locale, void 0, async () => null, {
+				severity: "error",
+				resolveTarget
+			});
+			issues.push(...relationErrors);
+		}
+		const keys = Object.keys(data);
+		const sorted = [...keys].toSorted();
+		if (keys.join(",") !== sorted.join(",")) {
+			issues.push({
+				severity: "warning",
+				model: model.id,
+				locale,
+				message: "Content file keys not in canonical order"
+			});
+			if (fix && projectRoot) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(join(projectRoot, filePath), resorted);
+				fixed++;
+			}
+		}
+		const singletonMetaData = await readJsonViaReader(reader, metaFilePath(model, locale));
+		if (singletonMetaData) validateScheduleFields(singletonMetaData, {
+			model: model.id,
+			locale
+		}, issues);
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function validateDictionaryModel(reader, projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const localeKeys = {};
+	for (const locale of config.locales.supported) {
+		const filePath = contentFilePath(model, locale);
+		const data = await readJsonViaReader(reader, filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix && projectRoot) {
+					await writeJson(join(projectRoot, filePath), {});
+					fixed++;
+				}
+			}
+			continue;
+		}
+		entriesChecked++;
+		localeKeys[locale] = new Set(Object.keys(data));
+		for (const [key, value] of Object.entries(data)) if (detectSecrets(value).length > 0) issues.push({
+			severity: "error",
+			model: model.id,
+			locale,
+			field: key,
+			message: `Potential secret detected in key "${key}"`
+		});
+		const valueToKeys = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(data)) {
+			const arr = valueToKeys.get(value);
+			if (arr) arr.push(key);
+			else valueToKeys.set(value, [key]);
+		}
+		for (const [value, dupeKeys] of valueToKeys) if (dupeKeys.length > 1) {
+			const truncated = value.length > 40 ? `${value.slice(0, 40)}...` : value;
+			issues.push({
+				severity: "warning",
+				model: model.id,
+				locale,
+				message: `Duplicate value "${truncated}" mapped to ${dupeKeys.length} keys: [${dupeKeys.join(", ")}]`
+			});
+		}
+		const keys = Object.keys(data);
+		const sorted = [...keys].toSorted();
+		if (keys.join(",") !== sorted.join(",")) {
+			issues.push({
+				severity: "warning",
+				model: model.id,
+				locale,
+				message: "Content file keys not in canonical order"
+			});
+			if (fix && projectRoot) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(join(projectRoot, filePath), resorted);
+				fixed++;
+			}
+		}
+	}
+	if (model.i18n && Object.keys(localeKeys).length > 1) {
+		const localeNames = Object.keys(localeKeys);
+		for (let i = 1; i < localeNames.length; i++) {
+			const locA = localeNames[0];
+			const locB = localeNames[i];
+			const keysA = localeKeys[locA];
+			const keysB = localeKeys[locB];
+			for (const k of keysA) if (!keysB.has(k)) issues.push({
+				severity: "warning",
+				model: model.id,
+				locale: locB,
+				field: k,
+				message: `Key parity: key "${k}" exists in ${locA} but missing in ${locB}`
+			});
+			for (const k of keysB) if (!keysA.has(k)) issues.push({
+				severity: "warning",
+				model: model.id,
+				locale: locA,
+				field: k,
+				message: `Key parity: key "${k}" exists in ${locB} but missing in ${locA}`
+			});
+		}
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function discoverDocumentSlugs(reader, cDir, model) {
+	const strategy = resolveLocaleStrategy(model);
+	const entries = await reader.listDirectory(cDir);
+	if (!model.i18n) return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+	if (strategy === "file") return entries.filter((e) => !e.startsWith("."));
+	if (strategy === "suffix") {
+		const slugs = /* @__PURE__ */ new Set();
+		for (const f of entries) {
+			if (!f.endsWith(".md")) continue;
+			const parts = f.replace(/\.md$/, "").split(".");
+			if (parts.length >= 2) {
+				parts.pop();
+				slugs.add(parts.join("."));
+			}
+		}
+		return [...slugs];
+	}
+	if (strategy === "directory") {
+		const slugs = /* @__PURE__ */ new Set();
+		const localeLists = await Promise.all(entries.filter((localeDir) => !localeDir.startsWith(".")).map((localeDir) => reader.listDirectory(`${cDir}/${localeDir}`)));
+		for (const files of localeLists) for (const f of files) if (f.endsWith(".md")) slugs.add(f.replace(/\.md$/, ""));
+		return [...slugs];
+	}
+	return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+}
+async function validateDocumentModel(reader, projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const cDir = contentDirPath(model);
+	if (!await reader.fileExists(cDir)) return {
+		entries: 0,
+		fixed: 0
+	};
+	const slugs = await discoverDocumentSlugs(reader, cDir, model);
+	const locales = config.locales.supported;
+	for (const slug of slugs) {
+		if (slug.startsWith(".")) continue;
+		for (const locale of locales) {
+			const filePath = documentFilePath(model, locale, slug);
+			const raw = await readTextViaReader(reader, filePath);
+			if (!raw) {
+				if (model.i18n) {
+					issues.push({
+						severity: "warning",
+						model: model.id,
+						locale,
+						slug,
+						message: `Missing translation: document "${slug}" missing ${locale} locale file`
+					});
+					if (fix && projectRoot) {
+						const template = `---\nslug: ${slug}\n---\n`;
+						await writeText(join(projectRoot, filePath), template);
+						fixed++;
+					}
+				}
+				continue;
+			}
+			entriesChecked++;
+			const { frontmatter, body } = parseFrontmatter(raw);
+			scanUndeclaredFieldsForSecrets(frontmatter, {
+				...model.fields,
+				body: true
+			}, {
+				model: model.id,
+				locale,
+				slug
+			}, issues);
+			if (detectSecrets(body).length > 0) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				slug,
+				field: "body",
+				message: "Potential secret detected in document body"
+			});
+			if (model.fields) {
+				const fieldsWithoutBody = Object.fromEntries(Object.entries(model.fields).filter(([name]) => name !== "body"));
+				const entryResult = validateContent(frontmatter, fieldsWithoutBody, model.id, locale);
+				for (const err of entryResult.errors) issues.push({
+					...err,
+					slug
+				});
+				const resolveTarget = buildProjectTargetResolver(reader);
+				const relationErrors = await checkRelationIntegrity(frontmatter, fieldsWithoutBody, model.id, locale, void 0, async () => null, {
+					severity: "error",
+					resolveTarget
+				});
+				for (const err of relationErrors) issues.push({
+					...err,
+					slug
+				});
+			}
+		}
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function checkOrphanContent(reader, validModelIds, issues, _fix) {
+	const fixed = 0;
+	const contentBase = ".contentrain/content";
+	const domains = await reader.listDirectory(contentBase);
+	const modelLists = await Promise.all(domains.filter((d) => !d.startsWith(".")).map(async (d) => ({
+		domain: d,
+		dirs: await reader.listDirectory(`${contentBase}/${d}`)
+	})));
+	for (const { dirs } of modelLists) for (const modelDir of dirs) {
+		if (modelDir.startsWith(".")) continue;
+		if (!validModelIds.has(modelDir)) issues.push({
+			severity: "warning",
+			model: modelDir,
+			message: `Orphan content: content directory exists for deleted model "${modelDir}"`
+		});
+	}
+	return fixed;
+}
+async function validateProject(input, options) {
+	const reader = typeof input === "string" ? new LocalReader(input) : input;
+	const projectRoot = typeof input === "string" ? input : void 0;
+	const fix = Boolean(options?.fix) && projectRoot !== void 0;
+	const issues = [];
+	let totalEntries = 0;
+	let totalFixed = 0;
+	let modelsChecked = 0;
+	const config = await readConfig(reader);
+	if (!config) return {
+		valid: false,
+		summary: {
+			errors: 1,
+			warnings: 0,
+			notices: 0,
+			models_checked: 0,
+			entries_checked: 0
+		},
+		issues: [{
+			severity: "error",
+			message: "Project not initialized: config.json missing"
+		}],
+		fixed: 0
+	};
+	const modelSummaries = await listModels(reader);
+	const validModelIds = new Set(modelSummaries.map((m) => m.id));
+	const modelsToCheck = options?.model ? modelSummaries.filter((m) => m.id === options.model) : modelSummaries;
+	for (const summary of modelsToCheck) {
+		const model = await readModel(reader, summary.id);
+		if (!model) continue;
+		modelsChecked++;
+		let result;
+		switch (model.kind) {
+			case "collection":
+				result = await validateCollectionModel(reader, projectRoot, model, config, issues, fix);
+				break;
+			case "singleton":
+				result = await validateSingletonModel(reader, projectRoot, model, config, issues, fix);
+				break;
+			case "dictionary":
+				result = await validateDictionaryModel(reader, projectRoot, model, config, issues, fix);
+				break;
+			case "document":
+				result = await validateDocumentModel(reader, projectRoot, model, config, issues, fix);
+				break;
+			default: result = {
+				entries: 0,
+				fixed: 0
+			};
+		}
+		totalEntries += result.entries;
+		totalFixed += result.fixed;
+	}
+	if (!options?.model) totalFixed += await checkOrphanContent(reader, validModelIds, issues, fix);
+	if (!options?.model) {
+		const dictModels = modelsToCheck.filter((m) => m.kind === "dictionary");
+		if (dictModels.length > 1) {
+			const globalValueMap = {};
+			for (const summary of dictModels) {
+				const model = await readModel(reader, summary.id);
+				if (!model) continue;
+				for (const locale of config.locales.supported) {
+					if (!globalValueMap[locale]) globalValueMap[locale] = /* @__PURE__ */ new Map();
+					const data = await readJsonViaReader(reader, contentFilePath(model, locale));
+					if (!data) continue;
+					for (const [key, value] of Object.entries(data)) {
+						const refs = globalValueMap[locale].get(value);
+						if (refs) refs.push({
+							model: model.id,
+							key
+						});
+						else globalValueMap[locale].set(value, [{
+							model: model.id,
+							key
+						}]);
+					}
+				}
+			}
+			for (const [locale, valueMap] of Object.entries(globalValueMap)) for (const [value, refs] of valueMap) if (new Set(refs.map((r) => r.model)).size > 1) {
+				const truncated = value.length > 40 ? `${value.slice(0, 40)}...` : value;
+				issues.push({
+					severity: "notice",
+					locale,
+					message: `Cross-model duplicate value "${truncated}" in ${refs.map((r) => `${r.model}/${r.key}`).join(", ")}`
+				});
+			}
+		}
+	}
+	const errors = issues.filter((i) => i.severity === "error").length;
+	const warnings = issues.filter((i) => i.severity === "warning").length;
+	const notices = issues.filter((i) => i.severity === "notice").length;
+	return {
+		valid: errors === 0,
+		summary: {
+			errors,
+			warnings,
+			notices,
+			models_checked: modelsChecked,
+			entries_checked: totalEntries
+		},
+		issues,
+		fixed: totalFixed
+	};
+}
+//#endregion
+export { validateContent as i, validateScheduleFields as n, checkRelationIntegrity as r, validateProject as t };
+
+//# sourceMappingURL=validator-B0nNRFeU.mjs.map