@phtngyn/cms 0.1.0-beta.0

package/src/DocumentEngine-Da0kWotL.js

@@ -0,0 +1,851 @@
+import { G as SourcePath, H as PublicPath, d as DocumentIssue, n as CmsMarkdownDocument, r as CompiledDocument, t as CmsDocumentAnalysis, v as DocumentSourceMapping, x as DocumentValidationResult } from "./models-Citx8jBi.js";
+import { c as createCmsComarkRenderData, s as cmsComarkTextContent } from "./metadata-Czvi3E4K.js";
+import { C as withCmsComarkProps, S as resolveCmsComarkAttributes, _ as createDocumentParser, b as matchesCmsComponentPropType, g as DOCUMENT_ENGINE_FINGERPRINT, r as validateAuthoringDocument, v as SOURCE_MAPPINGS_META_KEY, x as normalizeCmsComponentBindings } from "./AuthoringSchema-BQ5kbhVB.js";
+import { Effect, Option, Predicate, Result, Schema } from "effect";
+
+//#region ../protocol/src/internal/documents/address.ts
+const addressTokenPattern = /:([a-z][\w.]*)(\*)?/giu;
+function parseDocumentAddress(pattern) {
+	const tokens = [...pattern.matchAll(addressTokenPattern)].map((match) => ({
+		catchAll: match[2] === "*",
+		name: match[1] ?? ""
+	}));
+	if (pattern.replace(addressTokenPattern, "").includes(":") || tokens.some((token) => !token.name)) return Result.fail({
+		field: "addressPattern",
+		message: `Document address pattern "${pattern}" contains an invalid token.`
+	});
+	if (tokens.filter((token) => token.catchAll).length > 1) return Result.fail({
+		field: "addressPattern",
+		message: `Document address pattern "${pattern}" contains more than one catch-all token.`
+	});
+	if (new Set(tokens.map((token) => token.name)).size !== tokens.length) return Result.fail({
+		field: "addressPattern",
+		message: `Document address pattern "${pattern}" contains duplicate tokens.`
+	});
+	return Result.succeed({
+		pattern,
+		tokens
+	});
+}
+function resolveDocumentAddress(address, relativeKey, data) {
+	const relativePath = relativeKey === "/" ? "" : relativeKey.slice(1);
+	let resolved = address.pattern;
+	for (const token of address.tokens) {
+		const authored = nestedValue$1(data, token.name);
+		const fallback = token.catchAll ? relativePath : void 0;
+		const value = authored === void 0 ? fallback : Predicate.isString(authored) && authored.trim() ? authored : void 0;
+		if (value === void 0) return Result.fail({
+			field: token.name,
+			message: authored === void 0 ? `Document address field "${token.name}" is required by pattern "${address.pattern}".` : `Document address field "${token.name}" must be a non-empty string.`
+		});
+		const normalized = token.catchAll ? normalizeDocumentRelativePath(value) : normalizeDocumentSegment(value);
+		if (Result.isFailure(normalized)) return Result.fail(normalized.failure);
+		resolved = resolved.replace(`:${token.name}${token.catchAll ? "*" : ""}`, normalized.success);
+	}
+	return normalizePublicPath(resolved);
+}
+function documentKeyFromSourcePath(relativeSourcePath) {
+	const extension = relativeSourcePath.match(/\.(?:md|mdc)$/iu)?.[0];
+	if (!extension) return Result.fail({
+		field: "sourcePath",
+		message: `Document source must be a Markdown file: "${relativeSourcePath}".`
+	});
+	const segments = relativeSourcePath.slice(0, -extension.length).split("/");
+	if (segments.at(-1)?.toLocaleLowerCase() === "index") segments.pop();
+	return normalizeDocumentRelativePath(segments.join("/")).pipe(Result.flatMap(normalizePublicPath));
+}
+function localizeDocumentPath(key, locale, configuration) {
+	if (!configuration || !locale || locale === configuration.defaultLocale && !configuration.prefixDefaultLocale) return key;
+	return PublicPath.make(`/${locale}${key === "/" ? "" : key}`);
+}
+function normalizePublicPath(value) {
+	const path = `/${value.replace(/\\/gu, "/").replace(/^\/+|\/+$/gu, "")}`.replace(/\/{2,}/gu, "/");
+	return Schema.decodeResult(PublicPath)(path).pipe(Result.mapError(() => ({
+		field: "path",
+		message: `Document path "${value}" cannot be normalized into a public path.`
+	})));
+}
+function normalizeDocumentRelativePath(value) {
+	if (!value.trim()) return Result.succeed("");
+	const segments = value.replace(/\\/gu, "/").split("/").filter(Boolean);
+	const normalized = [];
+	for (const segment of segments) {
+		const result = normalizeDocumentSegment(segment);
+		if (Result.isFailure(result)) return result;
+		normalized.push(result.success);
+	}
+	return Result.succeed(normalized.join("/"));
+}
+function normalizeDocumentSegment(value) {
+	const normalized = value.trim().normalize("NFKC").toLocaleLowerCase().replace(/[^\p{Letter}\p{Number}_-]+/gu, "-").replace(/^-+|-+$/gu, "");
+	return normalized ? Result.succeed(normalized) : Result.fail({ message: `Document path segment "${value}" is empty after normalization.` });
+}
+function nestedValue$1(value, path) {
+	return path.split(".").reduce((current, segment) => {
+		if (!Schema.is(Schema.JsonObject)(current)) return void 0;
+		return current[segment];
+	}, value);
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/errors.ts
+var DocumentEngineConfigurationInvalid = class extends Schema.TaggedError()("DocumentEngine.ConfigurationInvalid", {
+	message: Schema.NonEmptyString,
+	field: Schema.optionalKey(Schema.NonEmptyString)
+}) {};
+var DocumentParseFailed = class extends Schema.TaggedError()("DocumentEngine.DocumentParseFailed", {
+	sourcePath: SourcePath,
+	cause: Schema.Defect()
+}) {};
+var DocumentCompilationFailed = class extends Schema.TaggedError()("DocumentEngine.DocumentCompilationFailed", { issues: Schema.Array(DocumentIssue) }) {};
+
+//#endregion
+//#region ../document/src/internal/comark/analysis.ts
+const CMS_STANDARD_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"address",
+	"article",
+	"aside",
+	"b",
+	"blockquote",
+	"br",
+	"button",
+	"caption",
+	"code",
+	"col",
+	"colgroup",
+	"dd",
+	"del",
+	"details",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"figcaption",
+	"figure",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"i",
+	"img",
+	"kbd",
+	"li",
+	"main",
+	"mark",
+	"nav",
+	"ol",
+	"p",
+	"pre",
+	"q",
+	"s",
+	"section",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"u",
+	"ul"
+]);
+function analyzeCmsDocument(body, metadata) {
+	const headings = [];
+	const components = /* @__PURE__ */ new Set();
+	visit$1(body.nodes, (node) => {
+		const tag = node[0].toLocaleLowerCase();
+		if (/^h[1-6]$/u.test(tag)) headings.push({
+			depth: Number(tag.slice(1)),
+			id: Predicate.isString(node[1].id) ? node[1].id : "",
+			text: cmsComarkTextContent(node).trim()
+		});
+		else if (!CMS_STANDARD_TAGS.has(tag)) components.add(tag);
+	});
+	const bodyText = normalizeText(body.nodes.map(cmsComarkTextContent).join(" "));
+	const summary = normalizeText(metadata.description ?? firstParagraph(body.nodes) ?? metadata.title);
+	const searchText = normalizeText([
+		metadata.title,
+		metadata.description,
+		bodyText
+	].filter(Boolean).join(" "));
+	return CmsDocumentAnalysis.make({
+		components: [...components].sort(),
+		headings,
+		searchText,
+		summary
+	});
+}
+function visit$1(nodes, inspect) {
+	for (const node of nodes) {
+		if (Predicate.isString(node) || node[0] === null) continue;
+		inspect(node);
+		const [, , ...children] = node;
+		visit$1(children, inspect);
+	}
+}
+function firstParagraph(nodes) {
+	const paragraph = nodes.find((node) => Array.isArray(node) && node[0] === "p");
+	if (!paragraph || Predicate.isString(paragraph) || paragraph[0] === null) return void 0;
+	return normalizeText(cmsComarkTextContent(paragraph)) || void 0;
+}
+function normalizeText(value) {
+	return value.replace(/\s+/gu, " ").trim();
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/frontmatter-validation.ts
+const validateFrontmatter = Effect.fn("DocumentEngine.validateFrontmatter")(function* (raw, schema, type, sourcePath) {
+	const projection = schema.project(raw);
+	const issues = projection.unknownPaths.toSorted().map((path) => unknownFieldIssue(path, type, sourcePath));
+	const result = yield* schema.validate(projection.value);
+	if ("issues" in result) {
+		issues.push(...result.issues.map((issue) => schemaIssue(issue, projection.value, type, sourcePath)));
+		return {
+			data: projection.value,
+			issues
+		};
+	}
+	const parsed = Schema.decodeUnknownOption(Schema.JsonObject)(result.value);
+	if (parsed._tag === "None") {
+		issues.push(issue("schema.constraint", "The collection schema output must be a JSON-compatible object.", type, sourcePath, "frontmatter"));
+		return {
+			data: projection.value,
+			issues
+		};
+	}
+	return issues.length === 0 ? {
+		data: parsed.value,
+		issues
+	} : {
+		data: projection.value,
+		issues
+	};
+});
+function unknownFieldIssue(path, type, sourcePath) {
+	if (path === "id") return issue("document.id", "Document identity is managed by the CMS and cannot be authored in frontmatter.", type, sourcePath, path);
+	return issue("schema.unknown", `Frontmatter field "${path}" is not declared by collection "${type.collection}".`, type, sourcePath, path);
+}
+function schemaIssue(error, input, type, sourcePath) {
+	const field = issuePath(error.path);
+	return issue(issueCode(error, input, field), error.message, type, sourcePath, field || void 0);
+}
+function issueCode(error, input, field) {
+	if (error.code === "invalid_type") return nestedValue(input, field) === void 0 ? "schema.required" : "schema.type";
+	if (error.code === "invalid_value") return "schema.option";
+	return "schema.constraint";
+}
+function issuePath(path) {
+	return (path ?? []).map((segment) => Predicate.hasProperty(segment, "key") ? segment.key : segment).map(String).join(".");
+}
+function nestedValue(value, path) {
+	if (!path) return value;
+	return path.split(".").reduce((current, segment) => {
+		if (Array.isArray(current)) {
+			const index = Number(segment);
+			return Number.isSafeInteger(index) ? current[index] : void 0;
+		}
+		return Schema.is(Schema.JsonObject)(current) ? current[segment] : void 0;
+	}, value);
+}
+function issue(code, message, type, sourcePath, field) {
+	return {
+		code,
+		collection: type.collection,
+		...field === void 0 ? void 0 : { field },
+		message,
+		severity: "error",
+		sourcePath
+	};
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/compilation.ts
+const isDocumentParseFailed$1 = Schema.is(DocumentParseFailed);
+const compileCompiledDocument = Effect.fn("DocumentEngine.compileDocument")(function* (configuration, parseMarkdown, source) {
+	const location = yield* resolveSourceLocation(configuration, source);
+	const parsedBody = yield* parseBody(parseMarkdown, source);
+	const mappings = yield* sourceMappings(parsedBody, source);
+	const body = normalizeCmsComponentBindings(withoutSourceMappings(parsedBody), configuration.components);
+	const relativeKey = yield* fromAddressResult(documentKeyFromSourcePath(location.relativeSourcePath), source.sourcePath);
+	const validation = yield* validateFrontmatter(body.frontmatter, location.type.schema, location.type.definition, source.sourcePath).pipe(Effect.mapError((cause) => new DocumentCompilationFailed({ issues: [{
+		code: "schema.constraint",
+		collection: location.type.definition.collection,
+		message: cause.message,
+		severity: "error",
+		sourcePath: source.sourcePath
+	}] })));
+	const address = resolveDocumentAddress(location.type.address, relativeKey, validation.data);
+	const key = Result.isSuccess(address) ? address.success : provisionalKey(source.documentId);
+	const path = localizeDocumentPath(key, location.locale, configuration.documents.locales);
+	const title = stringValue(validation.data.title) ?? stringValue(body.meta.title) ?? titleFromSource(location.relativeSourcePath);
+	const description = stringValue(validation.data.description) ?? stringValue(body.meta.description);
+	const issues = Result.isSuccess(address) ? validation.issues : [...validation.issues, addressIssue(address.failure, source.sourcePath)];
+	const canonicalBody = CmsMarkdownDocument.make({
+		frontmatter: validation.data,
+		meta: body.meta,
+		nodes: body.nodes
+	});
+	const analysis = analyzeCmsDocument(canonicalBody, description === void 0 ? { title } : {
+		description,
+		title
+	});
+	return CompiledDocument.make(Object.assign({
+		id: source.documentId,
+		key,
+		path,
+		collection: location.type.definition.collection,
+		draft: source.draft,
+		title,
+		data: validation.data,
+		issues: [...issues, ...validateAuthoringDocument(canonicalBody, configuration.components).map((message) => ({
+			code: "reference.component",
+			message,
+			severity: "error",
+			sourcePath: source.sourcePath
+		}))],
+		analysis,
+		body: canonicalBody,
+		engineFingerprint: DOCUMENT_ENGINE_FINGERPRINT,
+		source: {
+			path: source.sourcePath,
+			mappings
+		}
+	}, location.locale === void 0 ? void 0 : { locale: location.locale }, description === void 0 ? void 0 : { description }));
+});
+function provisionalKey(documentId) {
+	return PublicPath.make(`/_cms-invalid/${documentId}`);
+}
+function addressIssue(error, sourcePath) {
+	const issue = {
+		code: "document.invalid",
+		message: error.message,
+		severity: "error",
+		sourcePath
+	};
+	return error.field === void 0 ? issue : {
+		...issue,
+		field: error.field
+	};
+}
+function resolveSourceLocation(configuration, source) {
+	const segments = source.sourcePath.split("/");
+	let locale;
+	if (configuration.documents.locales) {
+		const candidate = segments.shift();
+		locale = configuration.documents.locales.locales.find((value) => value === candidate);
+		if (!locale) return compilationFailure({
+			code: "document.invalid",
+			field: "locale",
+			message: `Localized document "${source.sourcePath}" must begin with a configured locale.`,
+			severity: "error",
+			sourcePath: source.sourcePath
+		});
+	}
+	const localizedSourcePath = segments.join("/");
+	const type = configuration.types.find(({ definition }) => definition.directory === "." || localizedSourcePath.startsWith(`${definition.directory}/`));
+	if (!type) return compilationFailure({
+		code: "document.invalid",
+		field: "sourcePath",
+		message: `No document collection contains "${source.sourcePath}".`,
+		severity: "error",
+		sourcePath: source.sourcePath
+	});
+	const relativeSourcePath = type.definition.directory === "." ? localizedSourcePath : localizedSourcePath.slice(type.definition.directory.length + 1);
+	if (!relativeSourcePath) return compilationFailure({
+		code: "document.invalid",
+		field: "sourcePath",
+		message: `Document source "${source.sourcePath}" has no collection-relative path.`,
+		severity: "error",
+		sourcePath: source.sourcePath
+	});
+	return Effect.succeed(locale === void 0 ? {
+		relativeSourcePath,
+		type
+	} : {
+		locale,
+		relativeSourcePath,
+		type
+	});
+}
+function parseBody(parseMarkdown, source) {
+	return Effect.tryPromise({
+		try: () => parseMarkdown(source.markdown),
+		catch: (cause) => new DocumentParseFailed({
+			cause,
+			sourcePath: source.sourcePath
+		})
+	}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(CmsMarkdownDocument)), Effect.mapError((cause) => isDocumentParseFailed$1(cause) ? cause : new DocumentParseFailed({
+		cause,
+		sourcePath: source.sourcePath
+	})));
+}
+function sourceMappings(body, source) {
+	return Schema.decodeUnknownEffect(Schema.Array(DocumentSourceMapping))(body.meta["__cmsSourceMappings"] ?? []).pipe(Effect.mapError((cause) => new DocumentParseFailed({
+		cause,
+		sourcePath: source.sourcePath
+	})));
+}
+function withoutSourceMappings(body) {
+	const { [SOURCE_MAPPINGS_META_KEY]: _mappings, ...meta } = body.meta;
+	return CmsMarkdownDocument.make({
+		frontmatter: body.frontmatter,
+		meta,
+		nodes: body.nodes
+	});
+}
+function fromAddressResult(result, sourcePath) {
+	if (Result.isSuccess(result)) return Effect.succeed(result.success);
+	return compilationFailure(addressIssue(result.failure, sourcePath));
+}
+function compilationFailure(issue) {
+	return Effect.fail(new DocumentCompilationFailed({ issues: [issue] }));
+}
+function stringValue(value) {
+	return Predicate.isString(value) && value.trim() ? value.trim() : void 0;
+}
+function titleFromSource(sourcePath) {
+	const stem = (sourcePath.split("/").at(-1) ?? "content").replace(/\.(?:md|mdc)$/iu, "");
+	return (stem.toLocaleLowerCase() === "index" ? sourcePath.split("/").at(-2) ?? "home" : stem).replace(/[-_]+/gu, " ").replace(/^./u, (character) => character.toLocaleUpperCase());
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/catalog-lookup.ts
+function createCatalogLookup(documents, configuration) {
+	const byPath = new Map(documents.map((document) => [document.path, document]));
+	const byVariant = new Map(documents.map((document) => [localeAndKey(document.locale, document.key), document]));
+	const findByKey = (input, locale) => {
+		const keyResult = normalizePublicPath(input);
+		if (Result.isFailure(keyResult)) return Option.none();
+		const key = keyResult.success;
+		const locales = configuration.documents.locales;
+		if (!locales) return Option.fromNullishOr(byVariant.get(localeAndKey(void 0, key)));
+		const requestedLocale = locale ?? locales.defaultLocale;
+		const localized = byVariant.get(localeAndKey(requestedLocale, key));
+		if (localized) return Option.some(localized);
+		if (!locales.fallbackLocale) return Option.none();
+		return Option.fromNullishOr(byVariant.get(localeAndKey(locales.fallbackLocale, key)));
+	};
+	const findByPath = (input) => {
+		const pathResult = normalizePublicPath(input);
+		if (Result.isFailure(pathResult)) return Option.none();
+		const path = pathResult.success;
+		const direct = byPath.get(path);
+		if (direct) return Option.some(direct);
+		const locales = configuration.documents.locales;
+		if (!locales) return Option.none();
+		const request = localizedRequest(path, locales.locales, locales.defaultLocale, locales.prefixDefaultLocale);
+		if (!request) return Option.none();
+		const localized = byVariant.get(localeAndKey(request.locale, request.key));
+		if (localized) return Option.some(localized);
+		if (!locales.fallbackLocale) return Option.none();
+		return Option.fromNullishOr(byVariant.get(localeAndKey(locales.fallbackLocale, request.key)));
+	};
+	return {
+		findByKey,
+		findByPath
+	};
+}
+function localeAndKey(locale, key) {
+	return `${locale ?? ""}:${key}`;
+}
+function localizedRequest(path, locales, defaultLocale, prefixDefaultLocale) {
+	const segments = path === "/" ? [] : path.slice(1).split("/");
+	const possibleLocale = locales.find((locale) => locale === segments[0]);
+	const prefixedLocale = possibleLocale && (possibleLocale !== defaultLocale || prefixDefaultLocale) ? possibleLocale : void 0;
+	if (prefixedLocale) {
+		const keyResult = normalizePublicPath(segments.slice(1).join("/"));
+		return Result.isSuccess(keyResult) ? {
+			key: keyResult.success,
+			locale: prefixedLocale
+		} : void 0;
+	}
+	if (prefixDefaultLocale) return void 0;
+	return {
+		key: path,
+		locale: defaultLocale
+	};
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/catalog-issues.ts
+function collisionIssues(documents) {
+	const issues = [];
+	const byId = /* @__PURE__ */ new Map();
+	const byPath = /* @__PURE__ */ new Map();
+	const byVariant = /* @__PURE__ */ new Map();
+	for (const document of documents) {
+		const identityCollision = byId.get(document.id);
+		if (identityCollision) issues.push(collisionIssue(`Document identity collision for "${document.id}" between "${identityCollision.source.path}" and "${document.source.path}".`, document));
+		else byId.set(document.id, document);
+		const pathCollision = byPath.get(document.path);
+		if (pathCollision) issues.push(collisionIssue(`Document route collision at "${document.path}" between "${pathCollision.source.path}" and "${document.source.path}".`, document, document.path));
+		else byPath.set(document.path, document);
+		const variant = localeAndKey(document.locale, document.key);
+		const variantCollision = byVariant.get(variant);
+		if (variantCollision && variantCollision.path !== pathCollision?.path) issues.push(collisionIssue(`Document locale collision at "${document.key}" between "${variantCollision.source.path}" and "${document.source.path}".`, document, document.key));
+		else byVariant.set(variant, document);
+	}
+	return issues;
+}
+function translationIssues(documents, configuration) {
+	const locales = configuration.documents.locales;
+	if (!locales) return [];
+	const variants = new Set(documents.map((document) => localeAndKey(document.locale, document.key)));
+	return [...new Set(documents.map((document) => document.key))].flatMap((key) => locales.locales.flatMap((locale) => variants.has(localeAndKey(locale, key)) ? [] : [{
+		code: "i18n.missing-translation",
+		key,
+		locale,
+		message: `Document "${key}" is missing its "${locale}" translation.`,
+		severity: "warning"
+	}]));
+}
+function collisionIssue(message, document, key) {
+	const issue = {
+		code: "document.collision",
+		message,
+		severity: "error",
+		sourcePath: document.source.path
+	};
+	return key === void 0 ? issue : Object.assign(issue, { key });
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/component-validation.ts
+function componentValidationMessages(definition, attributes, children) {
+	if (definition.authoring) return [];
+	const messages = [];
+	const props = new Map(definition.props.map((prop) => [prop.name, prop]));
+	for (const prop of definition.props) if (prop.required && attributes.get(prop.name) === void 0) messages.push(`Document component "${definition.name}" requires prop "${prop.name}".`);
+	for (const [name, value] of attributes) {
+		if (name === "$" || name === "class" || name === "id" || name === "style") continue;
+		const prop = props.get(name);
+		if (!prop) messages.push(`Document component "${definition.name}" does not define prop "${name}".`);
+		else if (!matchesCmsComponentPropType(value, prop.type)) messages.push(`Document component "${definition.name}" prop "${name}" must be ${article(prop.type)} ${prop.type}.`);
+	}
+	const slots = new Set(definition.slots.map((slot) => slot.name));
+	const explicitSlots = children.flatMap((node) => {
+		if (Predicate.isString(node) || node[0] !== "template") return [];
+		return [Predicate.isString(node[1].name) ? node[1].name : "default"];
+	});
+	if (children.some((node) => Predicate.isString(node) ? Boolean(node.trim()) : node[0] !== "template") && !slots.has("default")) explicitSlots.push("default");
+	for (const name of new Set(explicitSlots)) if (!slots.has(name)) messages.push(`Document component "${definition.name}" does not define slot "${name}".`);
+	return messages;
+}
+function article(type) {
+	return type === "array" || type === "object" ? "an" : "a";
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/reference-target.ts
+function referenceTarget(tag, attributes, documentPath, mediaBaseUrl) {
+	if (tag === "a") {
+		const path = documentTarget(attributes.get("href"), documentPath);
+		return path ? {
+			kind: "document",
+			path
+		} : void 0;
+	}
+	if (tag === "img") {
+		const key = mediaKey(attributes.get("src"), mediaBaseUrl);
+		return key ? {
+			kind: "media",
+			key
+		} : void 0;
+	}
+	const normalizedTag = tag.toLocaleLowerCase();
+	return CMS_STANDARD_TAGS.has(normalizedTag) ? void 0 : {
+		kind: "component",
+		name: normalizedTag
+	};
+}
+function targetKey(target) {
+	switch (target.kind) {
+		case "component": return `component:${target.name.toLocaleLowerCase()}`;
+		case "document": return `document:${target.path}`;
+		case "media": return `media:${target.key}`;
+	}
+}
+function mediaKey(value, mediaBaseUrl) {
+	if (!Predicate.isString(value) || mediaBaseUrl === void 0) return void 0;
+	const prefix = `${mediaBaseUrl}/`;
+	if (!value.startsWith(prefix)) return void 0;
+	const encodedKey = value.slice(prefix.length).split(/[?#]/u, 1)[0];
+	if (!encodedKey) return void 0;
+	try {
+		const segments = encodedKey.split("/").map(decodeURIComponent);
+		if (segments.some((segment) => !segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\") || hasControlCharacter(segment))) return;
+		const key = segments.join("/");
+		return key.startsWith("media/") ? key : void 0;
+	} catch {
+		return;
+	}
+}
+function documentTarget(value, documentPath) {
+	if (!Predicate.isString(value)) return void 0;
+	const href = value.trim();
+	if (!href || href.startsWith("#") || href.startsWith("?") || href.startsWith("//") || /^[a-z][a-z\d+.-]*:/iu.test(href)) return;
+	const resolvedPath = resolveRelativePath(href.split(/[?#]/u)[0] ?? "", documentPath);
+	if ((resolvedPath.split("/").at(-1) ?? "").includes(".")) return void 0;
+	const normalized = normalizePublicPath(resolvedPath);
+	return Result.isSuccess(normalized) ? normalized.success : void 0;
+}
+function resolveRelativePath(href, documentPath) {
+	const normalizedHref = href.replace(/\\/gu, "/");
+	const segments = normalizedHref.startsWith("/") ? [] : documentPath.split("/").filter(Boolean).slice(0, -1);
+	for (const segment of normalizedHref.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") segments.pop();
+		else segments.push(segment);
+	}
+	return `/${segments.join("/")}`;
+}
+function hasControlCharacter(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0 && (codePoint <= 31 || codePoint === 127)) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/references.ts
+const noReferences = Object.freeze([]);
+function createDocumentReferenceIndex(documents, configuration, findByPath) {
+	const all = [];
+	const byTarget = /* @__PURE__ */ new Map();
+	const issues = /* @__PURE__ */ new Map();
+	for (const document of documents) visit(document.body.nodes, createCmsComarkRenderData(document.body), (tag, attributes, children, nodePath) => {
+		const target = referenceTarget(tag, attributes, document.path, configuration.mediaBaseUrl);
+		if (!target) return;
+		const reference = freezeReference({
+			nodePath,
+			source: {
+				documentId: document.id,
+				path: document.path,
+				sourcePath: document.source.path
+			},
+			target
+		});
+		all.push(reference);
+		const key = targetKey(target);
+		const matching = byTarget.get(key) ?? [];
+		matching.push(reference);
+		byTarget.set(key, matching);
+		if (target.kind === "document" && Option.isNone(findByPath(target.path))) addIssue(issues, document.source.path, {
+			code: "reference.document",
+			key: target.path,
+			message: `Document link "${target.path}" does not resolve.`,
+			severity: "error",
+			sourcePath: document.source.path
+		});
+		else if (target.kind === "component" && configuration.components) {
+			const definition = configuration.components.get(target.name);
+			if (!definition) addIssue(issues, document.source.path, componentIssue(document.source.path, `Document component "${tag}" is not registered.`));
+			else for (const message of componentValidationMessages(definition, attributes, children)) addIssue(issues, document.source.path, componentIssue(document.source.path, message));
+		}
+	});
+	const frozenAll = Object.freeze(all);
+	const frozenByTarget = new Map([...byTarget].map(([key, references]) => [key, Object.freeze(references)]));
+	return {
+		index: Object.freeze({
+			all: frozenAll,
+			impact: (target) => frozenByTarget.get(targetKey(target)) ?? noReferences
+		}),
+		issues
+	};
+}
+function visit(nodes, renderData, onElement, parentPath = []) {
+	nodes.forEach((node, index) => {
+		if (Predicate.isString(node) || node[0] === null) return;
+		const [tag, attributes, ...children] = node;
+		const nodePath = [...parentPath, index];
+		const resolved = resolveCmsComarkAttributes(attributes, renderData);
+		onElement(tag, resolved, children, nodePath);
+		visit(children, withCmsComarkProps(renderData, resolved), onElement, nodePath);
+	});
+}
+function freezeReference(reference) {
+	return Object.freeze({
+		nodePath: Object.freeze([...reference.nodePath]),
+		source: Object.freeze({ ...reference.source }),
+		target: Object.freeze({ ...reference.target })
+	});
+}
+function componentIssue(sourcePath, message) {
+	return {
+		code: "reference.component",
+		message,
+		severity: "error",
+		sourcePath
+	};
+}
+function addIssue(issues, sourcePath, issue) {
+	const sourceIssues = issues.get(sourcePath) ?? [];
+	sourceIssues.push(issue);
+	issues.set(sourcePath, sourceIssues);
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/catalog.ts
+function createDocumentCatalog(configuration, input) {
+	const documents = [...input].sort((left, right) => left.source.path.localeCompare(right.source.path));
+	const collisions = collisionIssues(documents);
+	if (collisions.length > 0) return Result.fail(new DocumentCompilationFailed({ issues: collisions }));
+	const lookup = createCatalogLookup(documents, configuration);
+	const references = createDocumentReferenceIndex(documents, configuration, lookup.findByPath);
+	const withReferenceIssues = documents.map((document) => {
+		const additional = references.issues.get(document.source.path) ?? [];
+		return additional.length === 0 ? document : CompiledDocument.make(Object.assign({}, document, { issues: [...document.issues, ...additional] }));
+	});
+	return Result.succeed({
+		documents: withReferenceIssues,
+		issues: [...withReferenceIssues.flatMap((document) => document.issues), ...translationIssues(withReferenceIssues, configuration)],
+		...createCatalogLookup(withReferenceIssues, configuration),
+		references: references.index
+	});
+}
+
+//#endregion
+//#region ../document/src/internal/document-engine/configuration.ts
+function resolveDocumentEngineConfiguration(documents, options) {
+	if (documents.types.length === 0) return invalid("Documents must define at least one collection.", "types");
+	const collections = /* @__PURE__ */ new Set();
+	const directories = /* @__PURE__ */ new Map();
+	const resolved = [];
+	for (const definition of documents.types) {
+		if (collections.has(definition.collection)) return invalid(`Document collection "${definition.collection}" is defined more than once.`, "types");
+		collections.add(definition.collection);
+		const existing = directories.get(definition.directory);
+		if (existing) return invalid(`Document collections "${existing}" and "${definition.collection}" use the same directory "${definition.directory}".`, "types");
+		directories.set(definition.directory, definition.collection);
+		const addressResult = parseDocumentAddress(definition.addressPattern);
+		if (Result.isFailure(addressResult)) return invalid(addressResult.failure.message, addressResult.failure.field);
+		if (definition.hierarchy && !addressResult.success.tokens.some((token) => token.catchAll)) return invalid(`Document collection "${definition.collection}" can only enable hierarchy with a catch-all address.`, "types");
+		const schema = options.documentModel.types[definition.collection];
+		if (!schema) return invalid(`Document collection "${definition.collection}" has no executable schema.`, "documentModel");
+		resolved.push({
+			address: addressResult.success,
+			definition,
+			schema
+		});
+	}
+	const locales = documents.locales;
+	if (locales) {
+		if (new Set(locales.locales).size !== locales.locales.length) return invalid("Document locales must be unique.", "locales.locales");
+		if (!locales.locales.includes(locales.defaultLocale)) return invalid(`Default locale "${locales.defaultLocale}" is not configured.`, "locales.defaultLocale");
+		if (locales.fallbackLocale && !locales.locales.includes(locales.fallbackLocale)) return invalid(`Fallback locale "${locales.fallbackLocale}" is not configured.`, "locales.fallbackLocale");
+	}
+	let components;
+	if (options.components !== void 0) {
+		const result = resolveComponents(options.components);
+		if (Result.isFailure(result)) return Result.fail(result.failure);
+		components = result.success;
+	}
+	const mediaBaseUrl = options.mediaBaseUrl?.replace(/\/+$/u, "");
+	resolved.sort((left, right) => directoryDepth(right.definition.directory) - directoryDepth(left.definition.directory));
+	const configuration = {
+		documents,
+		types: resolved
+	};
+	if (components !== void 0) configuration.components = components;
+	if (mediaBaseUrl !== void 0) configuration.mediaBaseUrl = mediaBaseUrl;
+	return Result.succeed(configuration);
+}
+function resolveComponents(definitions) {
+	const components = /* @__PURE__ */ new Map();
+	for (const component of definitions) {
+		const name = component.name.toLocaleLowerCase();
+		if (components.has(name)) return invalid(`Document component "${component.name}" is defined more than once.`, "components");
+		components.set(name, component);
+	}
+	return Result.succeed(components);
+}
+function directoryDepth(directory) {
+	return directory === "." ? 0 : directory.split("/").length;
+}
+function invalid(message, field) {
+	return Result.fail(new DocumentEngineConfigurationInvalid(field === void 0 ? { message } : {
+		field,
+		message
+	}));
+}
+
+//#endregion
+//#region ../document/src/DocumentEngine.ts
+const isDocumentParseFailed = Schema.is(DocumentParseFailed);
+/** Resolves installation configuration once and rejects an unusable engine before any Source is compiled. */
+const createDocumentEngine = Effect.fn("DocumentEngine.make")(function* (documents, options) {
+	const configuration = yield* Effect.fromResult(resolveDocumentEngineConfiguration(documents, options));
+	const parseMarkdown = createDocumentParser();
+	const compilations = /* @__PURE__ */ new WeakMap();
+	const compile = Effect.fn("DocumentEngine.compile")((source) => compileCompiledDocument(configuration, parseMarkdown, source));
+	const compileAll = Effect.fn("DocumentEngine.compileAll")(function* (input) {
+		const previous = input.previous ? compilations.get(input.previous) : void 0;
+		const compiled = yield* Effect.forEach(input.sources, (source) => {
+			const cached = previous?.get(source.documentId);
+			return cached && sameCompilationSource(cached.source, source) ? Effect.succeed(cached.document) : compile(source);
+		});
+		const catalog = yield* Effect.fromResult(createDocumentCatalog(configuration, compiled));
+		compilations.set(catalog, new Map(input.sources.map((source, index) => {
+			const document = compiled[index];
+			if (!document) throw new Error(`Compiled document "${source.documentId}" is missing.`);
+			return [source.documentId, {
+				document,
+				source
+			}];
+		})));
+		return catalog;
+	});
+	const validate = Effect.fn("DocumentEngine.validate")(function* (source) {
+		const result = yield* Effect.result(compile(source));
+		if (Result.isSuccess(result)) {
+			const document = result.success;
+			return DocumentValidationResult.make({
+				valid: !document.issues.some((issue) => issue.severity === "error"),
+				document,
+				issues: document.issues
+			});
+		}
+		const error = result.failure;
+		const issues = isDocumentParseFailed(error) ? [{
+			code: "markdown.parse",
+			message: errorMessage(error.cause),
+			severity: "error",
+			sourcePath: error.sourcePath
+		}] : error.issues;
+		return DocumentValidationResult.make({
+			valid: false,
+			issues
+		});
+	});
+	return {
+		compile,
+		compileAll,
+		fingerprint: DOCUMENT_ENGINE_FINGERPRINT,
+		validate
+	};
+});
+function sameCompilationSource(left, right) {
+	return left.documentId === right.documentId && left.draft === right.draft && left.markdown === right.markdown && left.sourcePath === right.sourcePath;
+}
+function errorMessage(cause) {
+	return cause instanceof Error && cause.message ? cause.message : "Markdown could not be parsed.";
+}
+
+//#endregion
+export { normalizePublicPath as a, normalizeDocumentRelativePath as i, DocumentCompilationFailed as n, parseDocumentAddress as o, localizeDocumentPath as r, resolveDocumentAddress as s, createDocumentEngine as t };
+//# sourceMappingURL=DocumentEngine-Da0kWotL.js.map