@contentrain/mcp 0.3.1 → 1.0.0

package/dist/validator-ku84AyFr.mjs

@@ -0,0 +1,755 @@
+import { a as readJson, c as writeText, i as readDir, o as readText, r as pathExists, s as writeJson, t as contentrainDir } from "./fs-BbuGnVcG.mjs";
+import { t as readConfig } from "./config-CPlhDwsv.mjs";
+import { r as writeMeta } from "./meta-manager-CECrfsKm.mjs";
+import { _ as resolveMdFilePath, f as parseFrontmatter, g as resolveLocaleStrategy, h as resolveJsonFilePath, m as resolveContentDir, o as listModels, s as readModel } from "./model-manager-BcWWu5l2.mjs";
+import { join } from "node:path";
+import { rm } from "node:fs/promises";
+//#region src/core/validator.ts
+const SECRET_PATTERNS = [
+	/sk_/,
+	/pk_/,
+	/api_key/i,
+	/apikey/i,
+	/ghp_/,
+	/gho_/,
+	/Bearer /,
+	/postgres:\/\//,
+	/mysql:\/\//,
+	/mongodb:\/\//,
+	/-----BEGIN/,
+	/AKIA/,
+	/aws_secret/i
+];
+function checkSecret(value) {
+	if (typeof value !== "string") return false;
+	return SECRET_PATTERNS.some((p) => p.test(value));
+}
+function fieldTypeMatches(value, fieldDef) {
+	if (value === null || value === void 0) return true;
+	switch (fieldDef.type) {
+		case "string":
+		case "text":
+		case "email":
+		case "url":
+		case "slug":
+		case "color":
+		case "phone":
+		case "code":
+		case "icon":
+		case "markdown":
+		case "richtext":
+		case "date":
+		case "datetime":
+		case "image":
+		case "video":
+		case "file":
+		case "select": return typeof value === "string";
+		case "number":
+		case "integer":
+		case "decimal":
+		case "percent":
+		case "rating": return typeof value === "number";
+		case "boolean": return typeof value === "boolean";
+		case "relation": return typeof value === "string";
+		case "relations":
+		case "array": return Array.isArray(value);
+		case "object": return typeof value === "object" && !Array.isArray(value);
+		default: return true;
+	}
+}
+function checkMinMax(value, fieldDef) {
+	if (fieldDef.min !== void 0) {
+		if (typeof value === "number" && value < fieldDef.min) return `Value ${value} is below minimum ${fieldDef.min}`;
+		if (typeof value === "string" && value.length < fieldDef.min) return `String length ${value.length} is below minimum ${fieldDef.min}`;
+		if (Array.isArray(value) && value.length < fieldDef.min) return `Array length ${value.length} is below minimum ${fieldDef.min}`;
+	}
+	if (fieldDef.max !== void 0) {
+		if (typeof value === "number" && value > fieldDef.max) return `Value ${value} is above maximum ${fieldDef.max}`;
+		if (typeof value === "string" && value.length > fieldDef.max) return `String length ${value.length} is above maximum ${fieldDef.max}`;
+		if (Array.isArray(value) && value.length > fieldDef.max) return `Array length ${value.length} is above maximum ${fieldDef.max}`;
+	}
+	return null;
+}
+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}").`
+		});
+	}
+}
+async function checkRelation(projectRoot, fieldName, fieldDef, value, locale, ctx, issues) {
+	if (fieldDef.type !== "relation" && fieldDef.type !== "relations" || value === void 0 || value === null) return;
+	const targets = Array.isArray(fieldDef.model) ? fieldDef.model : fieldDef.model ? [fieldDef.model] : [];
+	const refs = fieldDef.type === "relations" && Array.isArray(value) ? value : [value];
+	for (const ref of refs) {
+		if (typeof ref !== "string") continue;
+		let found = false;
+		for (const targetModelId of targets) {
+			const targetModel = await readModel(projectRoot, targetModelId);
+			if (!targetModel) {
+				issues.push({
+					severity: "error",
+					...ctx,
+					field: fieldName,
+					message: `Broken relation: target model "${targetModelId}" not found`
+				});
+				found = true;
+				break;
+			}
+			if (targetModel.kind === "document") {
+				if ((await discoverDocumentSlugs(resolveContentDir(projectRoot, targetModel), targetModel)).includes(ref)) {
+					found = true;
+					break;
+				}
+			} else if (targetModel.kind === "singleton" || targetModel.kind === "dictionary") {
+				found = true;
+				break;
+			} else {
+				const targetData = await readJson(resolveJsonFilePath(resolveContentDir(projectRoot, targetModel), targetModel, locale));
+				if (targetData && ref in targetData) {
+					found = true;
+					break;
+				}
+			}
+		}
+		if (!found) issues.push({
+			severity: "error",
+			...ctx,
+			field: fieldName,
+			message: `Broken relation: referenced ${targets.some((t) => t) ? "ref" : "ID"} "${ref}" not found in target model(s)`
+		});
+	}
+}
+async function validateCollectionModel(projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const cDir = resolveContentDir(projectRoot, model);
+	const metaDir = join(contentrainDir(projectRoot), "meta", model.id);
+	const locales = config.locales.supported;
+	const localeEntryIds = {};
+	const allEntryIds = /* @__PURE__ */ new Set();
+	const uniqueFieldValues = {};
+	for (const locale of locales) {
+		const filePath = resolveJsonFilePath(cDir, model, locale);
+		const data = await readJson(filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix) {
+					await writeJson(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) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(filePath, resorted);
+				fixed++;
+			}
+		}
+		for (const [entryId, fields] of Object.entries(data)) {
+			entriesChecked++;
+			for (const [fieldName, value] of Object.entries(fields)) if (checkSecret(value)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				entry: entryId,
+				field: fieldName,
+				message: `Potential secret detected in field "${fieldName}"`
+			});
+			if (!model.fields) continue;
+			for (const [fieldName, fieldDef] of Object.entries(model.fields)) {
+				const value = fields[fieldName];
+				if (fieldDef.required && (value === void 0 || value === null || value === "")) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					entry: entryId,
+					field: fieldName,
+					message: `Required field "${fieldName}" is missing`
+				});
+				if (value !== void 0 && value !== null && !fieldTypeMatches(value, fieldDef)) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					entry: entryId,
+					field: fieldName,
+					message: `Type mismatch: expected ${fieldDef.type}, got ${typeof value}`
+				});
+				if (value !== void 0 && value !== null) {
+					const minMaxErr = checkMinMax(value, fieldDef);
+					if (minMaxErr) issues.push({
+						severity: "error",
+						model: model.id,
+						locale,
+						entry: entryId,
+						field: fieldName,
+						message: minMaxErr
+					});
+				}
+				if (fieldDef.pattern && typeof value === "string") try {
+					if (!new RegExp(fieldDef.pattern).test(value)) issues.push({
+						severity: "error",
+						model: model.id,
+						locale,
+						entry: entryId,
+						field: fieldName,
+						message: `Value "${value}" does not match pattern /${fieldDef.pattern}/`
+					});
+				} catch {
+					issues.push({
+						severity: "warning",
+						model: model.id,
+						locale,
+						entry: entryId,
+						field: fieldName,
+						message: `Invalid pattern regex: ${fieldDef.pattern}`
+					});
+				}
+				if (fieldDef.unique && value !== void 0 && value !== null) {
+					const key = `${fieldName}:${locale}`;
+					if (!uniqueFieldValues[key]) uniqueFieldValues[key] = /* @__PURE__ */ new Map();
+					const existing = uniqueFieldValues[key].get(String(value));
+					if (existing) issues.push({
+						severity: "error",
+						model: model.id,
+						locale,
+						entry: entryId,
+						field: fieldName,
+						message: `Duplicate value "${value}" violates unique constraint (also in entry "${existing}")`
+					});
+					else uniqueFieldValues[key].set(String(value), entryId);
+				}
+				await checkRelation(projectRoot, fieldName, fieldDef, value, locale, {
+					model: model.id,
+					locale,
+					entry: entryId
+				}, issues);
+			}
+		}
+	}
+	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 metaPath = join(metaDir, `${locale}.json`);
+		const metaData = await readJson(metaPath);
+		const contentData = await readJson(resolveJsonFilePath(cDir, 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) {
+					delete metaData[metaEntryId];
+					if (Object.keys(metaData).length > 0) await writeJson(metaPath, metaData);
+					else await rm(metaPath, { 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) {
+				await writeMeta(projectRoot, model, {
+					locale,
+					entryId
+				}, {
+					status: "draft",
+					source: "import",
+					updated_by: "contentrain-mcp"
+				});
+				fixed++;
+			}
+		}
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function validateSingletonModel(projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const cDir = resolveContentDir(projectRoot, model);
+	for (const locale of config.locales.supported) {
+		const filePath = resolveJsonFilePath(cDir, model, locale);
+		const data = await readJson(filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix) {
+					await writeJson(filePath, {});
+					fixed++;
+				}
+			}
+			continue;
+		}
+		entriesChecked++;
+		for (const [fieldName, value] of Object.entries(data)) if (checkSecret(value)) issues.push({
+			severity: "error",
+			model: model.id,
+			locale,
+			field: fieldName,
+			message: `Potential secret detected in field "${fieldName}"`
+		});
+		if (model.fields) for (const [fieldName, fieldDef] of Object.entries(model.fields)) {
+			const value = data[fieldName];
+			if (fieldDef.required && (value === void 0 || value === null || value === "")) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				field: fieldName,
+				message: `Required field "${fieldName}" is missing`
+			});
+			if (value !== void 0 && value !== null && !fieldTypeMatches(value, fieldDef)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				field: fieldName,
+				message: `Type mismatch: expected ${fieldDef.type}, got ${typeof value}`
+			});
+			if (value !== void 0 && value !== null) {
+				const minMaxErr = checkMinMax(value, fieldDef);
+				if (minMaxErr) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					field: fieldName,
+					message: minMaxErr
+				});
+			}
+			if (fieldDef.pattern && typeof value === "string") try {
+				if (!new RegExp(fieldDef.pattern).test(value)) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					field: fieldName,
+					message: `Value "${value}" does not match pattern /${fieldDef.pattern}/`
+				});
+			} catch {
+				issues.push({
+					severity: "warning",
+					model: model.id,
+					locale,
+					field: fieldName,
+					message: `Invalid pattern regex: ${fieldDef.pattern}`
+				});
+			}
+			await checkRelation(projectRoot, fieldName, fieldDef, value, locale, {
+				model: model.id,
+				locale
+			}, issues);
+		}
+		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) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(filePath, resorted);
+				fixed++;
+			}
+		}
+		const singletonMetaData = await readJson(join(contentrainDir(projectRoot), "meta", model.id, `${locale}.json`));
+		if (singletonMetaData) validateScheduleFields(singletonMetaData, {
+			model: model.id,
+			locale
+		}, issues);
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function validateDictionaryModel(projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const cDir = resolveContentDir(projectRoot, model);
+	const localeKeys = {};
+	for (const locale of config.locales.supported) {
+		const filePath = resolveJsonFilePath(cDir, model, locale);
+		const data = await readJson(filePath);
+		if (!data) {
+			if (model.i18n) {
+				issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					message: `Locale file missing: ${locale}.json`
+				});
+				if (fix) {
+					await writeJson(filePath, {});
+					fixed++;
+				}
+			}
+			continue;
+		}
+		entriesChecked++;
+		localeKeys[locale] = new Set(Object.keys(data));
+		for (const [key, value] of Object.entries(data)) if (checkSecret(value)) issues.push({
+			severity: "error",
+			model: model.id,
+			locale,
+			field: key,
+			message: `Potential secret detected in key "${key}"`
+		});
+		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) {
+				const resorted = {};
+				for (const key of sorted) resorted[key] = data[key];
+				await writeJson(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(cDir, model) {
+	const strategy = resolveLocaleStrategy(model);
+	const entries = await readDir(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();
+		for (const localeDir of entries) {
+			if (localeDir.startsWith(".")) continue;
+			const files = await readDir(join(cDir, localeDir));
+			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(projectRoot, model, config, issues, fix) {
+	let entriesChecked = 0;
+	let fixed = 0;
+	const cDir = resolveContentDir(projectRoot, model);
+	if (!await pathExists(cDir)) return {
+		entries: 0,
+		fixed: 0
+	};
+	const slugs = await discoverDocumentSlugs(cDir, model);
+	const locales = config.locales.supported;
+	for (const slug of slugs) {
+		if (slug.startsWith(".")) continue;
+		for (const locale of locales) {
+			const filePath = resolveMdFilePath(cDir, model, locale, slug);
+			const raw = await readText(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) {
+						await writeText(filePath, `---\nslug: ${slug}\n---\n`);
+						fixed++;
+					}
+				}
+				continue;
+			}
+			entriesChecked++;
+			const { frontmatter, body } = parseFrontmatter(raw);
+			for (const [fieldName, value] of Object.entries(frontmatter)) if (checkSecret(value)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				slug,
+				field: fieldName,
+				message: `Potential secret detected in field "${fieldName}"`
+			});
+			if (checkSecret(body)) issues.push({
+				severity: "error",
+				model: model.id,
+				locale,
+				slug,
+				field: "body",
+				message: "Potential secret detected in document body"
+			});
+			if (model.fields) for (const [fieldName, fieldDef] of Object.entries(model.fields)) {
+				if (fieldName === "body") continue;
+				const value = frontmatter[fieldName];
+				if (fieldDef.required && (value === void 0 || value === null || value === "")) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					slug,
+					field: fieldName,
+					message: `Required field "${fieldName}" is missing`
+				});
+				if (value !== void 0 && value !== null && !fieldTypeMatches(value, fieldDef)) issues.push({
+					severity: "error",
+					model: model.id,
+					locale,
+					slug,
+					field: fieldName,
+					message: `Type mismatch: expected ${fieldDef.type}, got ${typeof value}`
+				});
+				if (value !== void 0 && value !== null) {
+					const minMaxErr = checkMinMax(value, fieldDef);
+					if (minMaxErr) issues.push({
+						severity: "error",
+						model: model.id,
+						locale,
+						slug,
+						field: fieldName,
+						message: minMaxErr
+					});
+				}
+				if (fieldDef.pattern && typeof value === "string") try {
+					if (!new RegExp(fieldDef.pattern).test(value)) issues.push({
+						severity: "error",
+						model: model.id,
+						locale,
+						slug,
+						field: fieldName,
+						message: `Value "${value}" does not match pattern /${fieldDef.pattern}/`
+					});
+				} catch {
+					issues.push({
+						severity: "warning",
+						model: model.id,
+						locale,
+						slug,
+						field: fieldName,
+						message: `Invalid pattern regex: ${fieldDef.pattern}`
+					});
+				}
+				await checkRelation(projectRoot, fieldName, fieldDef, value, locale, {
+					model: model.id,
+					locale,
+					slug
+				}, issues);
+			}
+		}
+	}
+	return {
+		entries: entriesChecked,
+		fixed
+	};
+}
+async function checkOrphanContent(projectRoot, validModelIds, issues, _fix) {
+	let fixed = 0;
+	const contentBase = join(contentrainDir(projectRoot), "content");
+	const domains = await readDir(contentBase);
+	for (const domain of domains) {
+		if (domain.startsWith(".")) continue;
+		const modelDirs = await readDir(join(contentBase, domain));
+		for (const modelDir of modelDirs) {
+			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(projectRoot, options) {
+	const issues = [];
+	const fix = options?.fix ?? false;
+	let totalEntries = 0;
+	let totalFixed = 0;
+	let modelsChecked = 0;
+	const config = await readConfig(projectRoot);
+	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(projectRoot);
+	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(projectRoot, summary.id);
+		if (!model) continue;
+		modelsChecked++;
+		let result;
+		switch (model.kind) {
+			case "collection":
+				result = await validateCollectionModel(projectRoot, model, config, issues, fix);
+				break;
+			case "singleton":
+				result = await validateSingletonModel(projectRoot, model, config, issues, fix);
+				break;
+			case "dictionary":
+				result = await validateDictionaryModel(projectRoot, model, config, issues, fix);
+				break;
+			case "document":
+				result = await validateDocumentModel(projectRoot, model, config, issues, fix);
+				break;
+			default: result = {
+				entries: 0,
+				fixed: 0
+			};
+		}
+		totalEntries += result.entries;
+		totalFixed += result.fixed;
+	}
+	if (!options?.model) totalFixed += await checkOrphanContent(projectRoot, validModelIds, issues, fix);
+	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 { validateProject as t };
+
+//# sourceMappingURL=validator-ku84AyFr.mjs.map