@farming-labs/docs 0.2.62 → 0.2.64

package/dist/agent-DKKptIgy.mjs

@@ -0,0 +1,4365 @@
+import { C as buildDocsApiCatalog, E as createDocsStandardsResponse, O as isDocsStandardsDiscoveryRequest, a as DEFAULT_A2A_AGENT_CARD_ROUTE, c as DEFAULT_AGENT_SKILLS_INDEX_ROUTE, g as DEFAULT_API_CATALOG_ROUTE, h as DEFAULT_API_CATALOG_FORMAT, k as resolveDocsDiscoveryApiRoute, l as DEFAULT_AGENT_SKILLS_ROUTE_PATTERN, n as API_CATALOG_MEDIA_TYPE, o as DEFAULT_AGENT_SKILLS_ARCHIVE_ROUTE_PATTERN, r as API_CATALOG_PROFILE_URI, s as DEFAULT_AGENT_SKILLS_INDEX_FORMAT, t as AGENT_SKILLS_DISCOVERY_SCHEMA_URI, v as DEFAULT_LEGACY_SKILLS_INDEX_ROUTE } from "./standards-discovery-jkykaXq1.mjs";
+import { createProcessor } from "@mdx-js/mdx";
+
+//#region src/mcp-auth.ts
+const DEFAULT_MCP_ROUTE = "/api/docs/mcp";
+const DEFAULT_MCP_PUBLIC_ROUTE = "/mcp";
+const DEFAULT_MCP_WELL_KNOWN_ROUTE = "/.well-known/mcp";
+const DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE = "/.well-known/oauth-protected-resource";
+function normalizeDocsMcpEndpointPath(route, fallback = DEFAULT_MCP_ROUTE) {
+	const normalized = `/${route?.trim().split(/[?#]/, 1)[0] || fallback}`.replace(/\/+/g, "/");
+	return normalized !== "/" ? normalized.replace(/\/+$/, "") : fallback;
+}
+function getDocsMcpResourcePaths(route) {
+	return Array.from(new Set([
+		normalizeDocsMcpEndpointPath(route),
+		DEFAULT_MCP_PUBLIC_ROUTE,
+		DEFAULT_MCP_WELL_KNOWN_ROUTE
+	]));
+}
+function buildDocsMcpProtectedResourceMetadataRoute(resourcePath) {
+	const candidate = resourcePath.trim().split(/[?#]/, 1)[0] || "/";
+	const trailingSlash = candidate.length > 1 && candidate.endsWith("/");
+	const normalized = candidate === "/" ? "/" : normalizeDocsMcpEndpointPath(candidate);
+	return normalized === "/" ? DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE : `${DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE}${normalized}${trailingSlash ? "/" : ""}`;
+}
+function getDocsMcpProtectedResourceMetadataRoutes(route) {
+	return getDocsMcpResourcePaths(route).map(buildDocsMcpProtectedResourceMetadataRoute);
+}
+function hasDocsMcpProtectedResourceConfig(mcp) {
+	if (!mcp || typeof mcp !== "object" || mcp.enabled === false || typeof mcp.security?.authenticate !== "function") return false;
+	return normalizeDocsMcpAuthorizationServerUrls(mcp.security?.protectedResource?.authorizationServers).length > 0;
+}
+function normalizeDocsMcpAuthorizationServerUrls(values) {
+	if (!Array.isArray(values)) return [];
+	return Array.from(new Set(values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(isAbsoluteHttpUrl)));
+}
+function isDocsMcpOAuthScopeToken(value) {
+	return typeof value === "string" && /^[\x21\x23-\x5B\x5D-\x7E]+$/u.test(value);
+}
+function isDocsMcpRequest(url, mcp) {
+	const route = typeof mcp === "object" ? mcp.route : void 0;
+	if (isDocsMcpResourcePath(url.pathname, route)) return true;
+	return hasDocsMcpProtectedResourceConfig(mcp) && isDocsMcpProtectedResourceMetadataRequestPath(url.pathname, route);
+}
+function isDocsMcpResourcePath(pathname, route) {
+	return isCanonicalResourcePath(pathname, getDocsMcpResourcePaths(route));
+}
+function resolveDocsMcpResourceLocation(request, route) {
+	const requestUrl = new URL(request.url);
+	const allowedPaths = getDocsMcpResourcePaths(route);
+	const normalizedRequestPath = normalizeRequestPath(requestUrl.pathname);
+	const resourcePath = isCanonicalResourcePath(requestUrl.pathname, allowedPaths) ? requestUrl.pathname : normalizedRequestPath;
+	const resourceUrl = new URL(requestUrl);
+	resourceUrl.pathname = resourcePath;
+	const metadataUrl = new URL(resourceUrl);
+	metadataUrl.pathname = buildDocsMcpProtectedResourceMetadataRoute(resourcePath);
+	return {
+		resourceUrl,
+		metadataUrl
+	};
+}
+function resolveDocsMcpProtectedResourceMetadataLocation(request, route) {
+	const rawUrl = new URL(request.url);
+	const allowedPaths = getDocsMcpResourcePaths(route);
+	if (!rawUrl.pathname.startsWith(`${DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE}/`)) return;
+	const requestedResourcePath = rawUrl.pathname.slice(37);
+	if (!isCanonicalResourcePath(requestedResourcePath, allowedPaths)) return void 0;
+	const metadataUrl = new URL(rawUrl);
+	const resourceUrl = new URL(metadataUrl);
+	resourceUrl.pathname = requestedResourcePath;
+	return {
+		resourceUrl,
+		metadataUrl
+	};
+}
+function isDocsMcpProtectedResourceMetadataPath(pathname) {
+	const normalized = normalizeRequestPath(pathname);
+	return normalized === DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE || normalized.startsWith(`${DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE}/`);
+}
+function normalizeRequestPath(pathname) {
+	const normalized = `/${pathname}`.replace(/\/+/g, "/");
+	return normalized === "/" ? normalized : normalized.replace(/\/+$/, "");
+}
+function isCanonicalResourcePath(pathname, resourcePaths) {
+	return resourcePaths.some((resourcePath) => pathname === resourcePath || resourcePath !== "/" && pathname === `${resourcePath}/`);
+}
+function isDocsMcpProtectedResourceMetadataRequestPath(pathname, route) {
+	if (!pathname.startsWith(`${DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE}/`)) return false;
+	return isCanonicalResourcePath(pathname.slice(37), getDocsMcpResourcePaths(route));
+}
+function isAbsoluteHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		const loopbackHttp = url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]");
+		return (url.protocol === "https:" || loopbackHttp) && !url.username && !url.password && !url.search && !url.hash;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/agent-contract.ts
+const PAGE_AGENT_STRUCTURED_CONTRACT_FIELDS = [
+	"task",
+	"outcome",
+	"appliesTo",
+	"prerequisites",
+	"files",
+	"commands",
+	"sideEffects",
+	"verification",
+	"rollback",
+	"failureModes"
+];
+const PAGE_AGENT_CONTRACT_FIELDS = ["tokenBudget", ...PAGE_AGENT_STRUCTURED_CONTRACT_FIELDS];
+const PAGE_AGENT_CONTRACT_FIELD_SCHEMA = {
+	tokenBudget: "number",
+	task: "string",
+	outcome: "string",
+	appliesTo: {
+		framework: "string|string[]",
+		version: "string|string[]",
+		package: "string|string[]"
+	},
+	prerequisites: "string[]",
+	files: "string[]",
+	commands: "Array<string|{run,cwd?,description?}>",
+	sideEffects: "string[]",
+	verification: "Array<string|{description?,run?,expect?}>",
+	rollback: "string[]",
+	failureModes: "Array<string|{symptom,resolution?}>"
+};
+const APPLIES_TO_FIELDS = [
+	"framework",
+	"version",
+	"package"
+];
+const COMMAND_FIELDS = [
+	"run",
+	"cwd",
+	"description"
+];
+const VERIFICATION_FIELDS = [
+	"description",
+	"run",
+	"expect"
+];
+const FAILURE_MODE_FIELDS = ["symptom", "resolution"];
+const PAGE_AGENT_CONTRACT_START_MARKER = "<!-- farming-labs:agent-contract:start -->";
+const PAGE_AGENT_CONTRACT_END_MARKER = "<!-- farming-labs:agent-contract:end -->";
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeString(value) {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function normalizeStringList(value) {
+	if (!Array.isArray(value)) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const normalized = [];
+	for (const item of value) {
+		const text = normalizeString(item);
+		if (!text || seen.has(text)) continue;
+		seen.add(text);
+		normalized.push(text);
+	}
+	return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeStringOrList(value) {
+	const single = normalizeString(value);
+	if (single) return [single];
+	return normalizeStringList(value);
+}
+function normalizeAppliesTo(value) {
+	if (!isRecord(value)) return void 0;
+	const framework = normalizeStringOrList(value.framework);
+	const version = normalizeStringOrList(value.version);
+	const packageNames = normalizeStringOrList(value.package);
+	if (!framework && !version && !packageNames) return void 0;
+	return {
+		...framework ? { framework } : {},
+		...version ? { version } : {},
+		...packageNames ? { package: packageNames } : {}
+	};
+}
+function normalizeCommands(value) {
+	if (!Array.isArray(value)) return void 0;
+	const commands = [];
+	for (const item of value) {
+		const shorthand = normalizeString(item);
+		if (shorthand) {
+			commands.push(shorthand);
+			continue;
+		}
+		if (!isRecord(item)) continue;
+		const run = normalizeString(item.run);
+		if (!run) continue;
+		const cwd = normalizeString(item.cwd);
+		const description = normalizeString(item.description);
+		commands.push({
+			run,
+			...cwd ? { cwd } : {},
+			...description ? { description } : {}
+		});
+	}
+	return commands.length > 0 ? commands : void 0;
+}
+function normalizeVerification(value) {
+	if (!Array.isArray(value)) return void 0;
+	const verification = [];
+	for (const item of value) {
+		const shorthand = normalizeString(item);
+		if (shorthand) {
+			verification.push(shorthand);
+			continue;
+		}
+		if (!isRecord(item)) continue;
+		const description = normalizeString(item.description);
+		const run = normalizeString(item.run);
+		const expect = normalizeString(item.expect);
+		if (!description && !run && !expect) continue;
+		verification.push({
+			...description ? { description } : {},
+			...run ? { run } : {},
+			...expect ? { expect } : {}
+		});
+	}
+	return verification.length > 0 ? verification : void 0;
+}
+function normalizeFailureModes(value) {
+	if (!Array.isArray(value)) return void 0;
+	const failureModes = [];
+	for (const item of value) {
+		const shorthand = normalizeString(item);
+		if (shorthand) {
+			failureModes.push(shorthand);
+			continue;
+		}
+		if (!isRecord(item)) continue;
+		const symptom = normalizeString(item.symptom);
+		if (!symptom) continue;
+		const resolution = normalizeString(item.resolution);
+		failureModes.push({
+			symptom,
+			...resolution ? { resolution } : {}
+		});
+	}
+	return failureModes.length > 0 ? failureModes : void 0;
+}
+function normalizeTokenBudget(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+	return Math.ceil(value);
+}
+/**
+* Normalize untrusted page frontmatter into the stable agent contract shape.
+* Invalid fields are omitted so malformed author input cannot break page delivery.
+*/
+function normalizePageAgentFrontmatter(value) {
+	if (!isRecord(value)) return void 0;
+	const tokenBudget = normalizeTokenBudget(value.tokenBudget);
+	const task = normalizeString(value.task);
+	const outcome = normalizeString(value.outcome);
+	const appliesTo = normalizeAppliesTo(value.appliesTo);
+	const prerequisites = normalizeStringList(value.prerequisites);
+	const files = normalizeStringList(value.files);
+	const commands = normalizeCommands(value.commands);
+	const sideEffects = normalizeStringList(value.sideEffects);
+	const verification = normalizeVerification(value.verification);
+	const rollback = normalizeStringList(value.rollback);
+	const failureModes = normalizeFailureModes(value.failureModes);
+	const normalized = {
+		...tokenBudget !== void 0 ? { tokenBudget } : {},
+		...task ? { task } : {},
+		...outcome ? { outcome } : {},
+		...appliesTo ? { appliesTo } : {},
+		...prerequisites ? { prerequisites } : {},
+		...files ? { files } : {},
+		...commands ? { commands } : {},
+		...sideEffects ? { sideEffects } : {},
+		...verification ? { verification } : {},
+		...rollback ? { rollback } : {},
+		...failureModes ? { failureModes } : {}
+	};
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function hasStructuredPageAgentContract(value) {
+	const normalized = normalizePageAgentFrontmatter(value);
+	if (!normalized) return false;
+	return PAGE_AGENT_STRUCTURED_CONTRACT_FIELDS.some((field) => normalized[field] !== void 0);
+}
+function addStringIssue(issues, object, field) {
+	if (!(field in object)) return;
+	if (!normalizeString(object[field])) issues.push({
+		path: `agent.${field}`,
+		message: "must be a non-empty string"
+	});
+}
+function addStringListIssues(issues, object, field) {
+	if (!(field in object)) return;
+	const value = object[field];
+	if (!Array.isArray(value) || value.length === 0) {
+		issues.push({
+			path: `agent.${field}`,
+			message: "must be a non-empty string array"
+		});
+		return;
+	}
+	value.forEach((item, index) => {
+		if (!normalizeString(item)) issues.push({
+			path: `agent.${field}[${index}]`,
+			message: "must be a non-empty string"
+		});
+	});
+}
+function editDistance(left, right) {
+	const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+		const current = [leftIndex];
+		for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) current[rightIndex] = Math.min((current[rightIndex - 1] ?? 0) + 1, (previous[rightIndex] ?? 0) + 1, (previous[rightIndex - 1] ?? 0) + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1));
+		previous.splice(0, previous.length, ...current);
+	}
+	return previous[right.length] ?? 0;
+}
+function closestKnownField(field, allowed) {
+	const closest = allowed.map((candidate) => ({
+		candidate,
+		distance: editDistance(field, candidate)
+	})).sort((left, right) => left.distance - right.distance || left.candidate.localeCompare(right.candidate))[0];
+	if (!closest) return void 0;
+	const threshold = Math.max(1, Math.min(3, Math.floor(closest.candidate.length / 3)));
+	return closest.distance <= threshold ? closest.candidate : void 0;
+}
+function addUnknownKeyIssues(issues, object, allowed, path) {
+	for (const field of Object.keys(object)) {
+		if (allowed.includes(field)) continue;
+		const suggestion = closestKnownField(field, allowed);
+		issues.push({
+			path: `${path}.${field}`,
+			message: suggestion ? `is not recognized; did you mean "${path}.${suggestion}"?` : "is not recognized"
+		});
+	}
+}
+/** Return author-facing validation issues without throwing. */
+function getPageAgentFrontmatterIssues(value) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) return [{
+		path: "agent",
+		message: "must be an object"
+	}];
+	const issues = [];
+	addUnknownKeyIssues(issues, value, PAGE_AGENT_CONTRACT_FIELDS, "agent");
+	if ("tokenBudget" in value && (typeof value.tokenBudget !== "number" || !Number.isFinite(value.tokenBudget) || value.tokenBudget <= 0)) issues.push({
+		path: "agent.tokenBudget",
+		message: "must be a positive finite number"
+	});
+	addStringIssue(issues, value, "task");
+	addStringIssue(issues, value, "outcome");
+	if ("appliesTo" in value) if (!isRecord(value.appliesTo)) issues.push({
+		path: "agent.appliesTo",
+		message: "must be an object"
+	});
+	else {
+		addUnknownKeyIssues(issues, value.appliesTo, APPLIES_TO_FIELDS, "agent.appliesTo");
+		for (const field of [
+			"framework",
+			"version",
+			"package"
+		]) {
+			if (!(field in value.appliesTo)) continue;
+			const fieldValue = value.appliesTo[field];
+			if (!normalizeStringOrList(fieldValue)) {
+				issues.push({
+					path: `agent.appliesTo.${field}`,
+					message: "must be a non-empty string or string array"
+				});
+				continue;
+			}
+			if (Array.isArray(fieldValue)) fieldValue.forEach((item, index) => {
+				if (!normalizeString(item)) issues.push({
+					path: `agent.appliesTo.${field}[${index}]`,
+					message: "must be a non-empty string"
+				});
+			});
+		}
+		if (!normalizeAppliesTo(value.appliesTo)) issues.push({
+			path: "agent.appliesTo",
+			message: "must include framework, version, or package"
+		});
+	}
+	for (const field of [
+		"prerequisites",
+		"files",
+		"sideEffects",
+		"rollback"
+	]) addStringListIssues(issues, value, field);
+	if ("commands" in value) if (!Array.isArray(value.commands) || value.commands.length === 0) issues.push({
+		path: "agent.commands",
+		message: "must be a non-empty array"
+	});
+	else value.commands.forEach((command, index) => {
+		if (normalizeString(command)) return;
+		if (!isRecord(command)) {
+			issues.push({
+				path: `agent.commands[${index}]`,
+				message: "must be a command string or an object with a non-empty run field"
+			});
+			return;
+		}
+		addUnknownKeyIssues(issues, command, COMMAND_FIELDS, `agent.commands[${index}]`);
+		if (!normalizeString(command.run)) {
+			issues.push({
+				path: `agent.commands[${index}]`,
+				message: "must be a command string or an object with a non-empty run field"
+			});
+			return;
+		}
+		for (const field of ["cwd", "description"]) if (field in command && !normalizeString(command[field])) issues.push({
+			path: `agent.commands[${index}].${field}`,
+			message: "must be a non-empty string"
+		});
+	});
+	if ("verification" in value) if (!Array.isArray(value.verification) || value.verification.length === 0) issues.push({
+		path: "agent.verification",
+		message: "must be a non-empty array"
+	});
+	else value.verification.forEach((step, index) => {
+		if (normalizeString(step)) return;
+		if (!isRecord(step)) {
+			issues.push({
+				path: `agent.verification[${index}]`,
+				message: "must be a string or an object with description, run, or expect"
+			});
+			return;
+		}
+		addUnknownKeyIssues(issues, step, VERIFICATION_FIELDS, `agent.verification[${index}]`);
+		if (!normalizeVerification([step])) {
+			issues.push({
+				path: `agent.verification[${index}]`,
+				message: "must be a string or an object with description, run, or expect"
+			});
+			return;
+		}
+		for (const field of [
+			"description",
+			"run",
+			"expect"
+		]) if (field in step && !normalizeString(step[field])) issues.push({
+			path: `agent.verification[${index}].${field}`,
+			message: "must be a non-empty string"
+		});
+	});
+	if ("failureModes" in value) if (!Array.isArray(value.failureModes) || value.failureModes.length === 0) issues.push({
+		path: "agent.failureModes",
+		message: "must be a non-empty array"
+	});
+	else value.failureModes.forEach((mode, index) => {
+		if (normalizeString(mode)) return;
+		if (!isRecord(mode)) {
+			issues.push({
+				path: `agent.failureModes[${index}]`,
+				message: "must be a string or an object with a non-empty symptom field"
+			});
+			return;
+		}
+		addUnknownKeyIssues(issues, mode, FAILURE_MODE_FIELDS, `agent.failureModes[${index}]`);
+		if (!normalizeString(mode.symptom)) {
+			issues.push({
+				path: `agent.failureModes[${index}]`,
+				message: "must be a string or an object with a non-empty symptom field"
+			});
+			return;
+		}
+		if ("resolution" in mode && !normalizeString(mode.resolution)) issues.push({
+			path: `agent.failureModes[${index}].resolution`,
+			message: "must be a non-empty string"
+		});
+	});
+	return issues;
+}
+function yamlString(value) {
+	return JSON.stringify(value);
+}
+function renderYamlStringList(lines, indent, key, values) {
+	lines.push(`${indent}${key}:`);
+	for (const value of values) lines.push(`${indent}  - ${yamlString(value)}`);
+}
+function renderYamlObjectList(lines, indent, key, values, fields) {
+	lines.push(`${indent}${key}:`);
+	for (const value of values) {
+		if (typeof value === "string") {
+			lines.push(`${indent}  - ${yamlString(value)}`);
+			continue;
+		}
+		const record = value;
+		const firstField = fields.find((field) => normalizeString(record[field]));
+		if (!firstField) continue;
+		lines.push(`${indent}  - ${firstField}: ${yamlString(normalizeString(record[firstField]))}`);
+		for (const field of fields) {
+			const fieldValue = normalizeString(record[field]);
+			if (field === firstField || !fieldValue) continue;
+			lines.push(`${indent}    ${field}: ${yamlString(fieldValue)}`);
+		}
+	}
+}
+/** Render normalized `agent` YAML in a stable field order. */
+function renderPageAgentFrontmatterYamlLines(value, indentation = 0) {
+	const agent = normalizePageAgentFrontmatter(value);
+	if (!agent) return [];
+	const indent = " ".repeat(Math.max(0, indentation));
+	const child = `${indent}  `;
+	const lines = [`${indent}agent:`];
+	if (agent.tokenBudget !== void 0) lines.push(`${child}tokenBudget: ${agent.tokenBudget}`);
+	if (agent.task) lines.push(`${child}task: ${yamlString(agent.task)}`);
+	if (agent.outcome) lines.push(`${child}outcome: ${yamlString(agent.outcome)}`);
+	if (agent.appliesTo) {
+		lines.push(`${child}appliesTo:`);
+		const appliesIndent = `${child}  `;
+		for (const field of [
+			"framework",
+			"version",
+			"package"
+		]) {
+			const values = normalizeStringOrList(agent.appliesTo[field]);
+			if (values) renderYamlStringList(lines, appliesIndent, field, values);
+		}
+	}
+	if (agent.prerequisites) renderYamlStringList(lines, child, "prerequisites", agent.prerequisites);
+	if (agent.files) renderYamlStringList(lines, child, "files", agent.files);
+	if (agent.commands) renderYamlObjectList(lines, child, "commands", agent.commands, [
+		"run",
+		"cwd",
+		"description"
+	]);
+	if (agent.sideEffects) renderYamlStringList(lines, child, "sideEffects", agent.sideEffects);
+	if (agent.verification) renderYamlObjectList(lines, child, "verification", agent.verification, [
+		"description",
+		"run",
+		"expect"
+	]);
+	if (agent.rollback) renderYamlStringList(lines, child, "rollback", agent.rollback);
+	if (agent.failureModes) renderYamlObjectList(lines, child, "failureModes", agent.failureModes, ["symptom", "resolution"]);
+	return lines;
+}
+function inlineCode(value) {
+	const longestRun = Math.max(0, ...[...value.matchAll(/`+/g)].map((match) => match[0].length));
+	const fence = "`".repeat(longestRun + 1);
+	const padding = value.startsWith("`") || value.endsWith("`") ? " " : "";
+	return `${fence}${padding}${value}${padding}${fence}`;
+}
+function renderTextList(lines, title, values, code = false) {
+	lines.push("", `### ${title}`, "");
+	for (const value of values) lines.push(`- ${code ? inlineCode(value) : value}`);
+}
+/** Render the structured contract as deterministic, compact machine-readable Markdown. */
+function renderPageAgentContractMarkdown(value) {
+	const agent = normalizePageAgentFrontmatter(value);
+	if (!agent || !hasStructuredPageAgentContract(agent)) return "";
+	const lines = [PAGE_AGENT_CONTRACT_START_MARKER, "## Agent Contract"];
+	if (agent.task) lines.push("", `Task: ${agent.task}`);
+	if (agent.outcome) lines.push(`Outcome: ${agent.outcome}`);
+	if (agent.appliesTo) {
+		lines.push("", "### Applies To", "");
+		for (const [label, field] of [
+			["Framework", "framework"],
+			["Version", "version"],
+			["Package", "package"]
+		]) {
+			const values = normalizeStringOrList(agent.appliesTo[field]);
+			if (values) lines.push(`- ${label}: ${values.map(inlineCode).join(", ")}`);
+		}
+	}
+	if (agent.prerequisites) renderTextList(lines, "Prerequisites", agent.prerequisites);
+	if (agent.files) renderTextList(lines, "Files", agent.files, true);
+	if (agent.commands) {
+		lines.push("", "### Commands", "");
+		for (const command of agent.commands) {
+			if (typeof command === "string") {
+				lines.push(`- ${inlineCode(command)}`);
+				continue;
+			}
+			const details = [command.cwd ? `cwd ${inlineCode(command.cwd)}` : void 0, command.description].filter(Boolean);
+			lines.push(`- ${inlineCode(command.run)}${details.length ? ` — ${details.join("; ")}` : ""}`);
+		}
+	}
+	if (agent.sideEffects) renderTextList(lines, "Side Effects", agent.sideEffects);
+	if (agent.verification) {
+		lines.push("", "### Verification", "");
+		for (const step of agent.verification) {
+			if (typeof step === "string") {
+				lines.push(`- ${step}`);
+				continue;
+			}
+			const summary = step.description ?? (step.run ? `Run ${inlineCode(step.run)}` : step.expect ?? "Verification step");
+			lines.push(`- ${summary}`);
+			if (step.run && step.description) lines.push(`  - Run: ${inlineCode(step.run)}`);
+			if (step.expect && step.expect !== summary) lines.push(`  - Expected: ${step.expect}`);
+		}
+	}
+	if (agent.rollback) renderTextList(lines, "Rollback", agent.rollback);
+	if (agent.failureModes) {
+		lines.push("", "### Failure Modes", "");
+		for (const mode of agent.failureModes) {
+			if (typeof mode === "string") {
+				lines.push(`- ${mode}`);
+				continue;
+			}
+			lines.push(`- ${mode.symptom}${mode.resolution ? ` — Recovery: ${mode.resolution}` : ""}`);
+		}
+	}
+	lines.push(PAGE_AGENT_CONTRACT_END_MARKER);
+	return lines.join("\n");
+}
+/** Remove generated contract blocks while preserving handwritten guidance. */
+function stripGeneratedPageAgentContractMarkdown(markdown) {
+	const newline = markdown.includes("\r\n") ? "\r\n" : "\n";
+	const output = [];
+	let fence;
+	let pendingBlock;
+	let skipEmptySeparator = false;
+	for (const line of markdown.split(/\r?\n/)) {
+		if (pendingBlock) {
+			pendingBlock.push(line);
+			if (isGeneratedAgentContractMarker(line, PAGE_AGENT_CONTRACT_END_MARKER)) {
+				pendingBlock = void 0;
+				skipEmptySeparator = true;
+			}
+			continue;
+		}
+		if (!fence && isGeneratedAgentContractMarker(line, PAGE_AGENT_CONTRACT_START_MARKER)) {
+			pendingBlock = [line];
+			continue;
+		}
+		if (skipEmptySeparator && line.length === 0) continue;
+		skipEmptySeparator = false;
+		output.push(line);
+		fence = advanceMarkdownFence(line, fence);
+	}
+	if (pendingBlock) output.push(...pendingBlock);
+	while (output[0] === "") output.shift();
+	return output.join(newline);
+}
+function isGeneratedAgentContractMarker(line, marker) {
+	if (line.trim() !== marker) return false;
+	const markerIndex = line.indexOf(marker);
+	return markerIndex <= 3 && /^ *$/.test(line.slice(0, markerIndex));
+}
+function advanceMarkdownFence(line, fence) {
+	if (fence) {
+		const closing = /^ {0,3}(`+|~+)[\t ]*$/.exec(line)?.[1];
+		if (closing?.[0] === fence.character && closing.length >= fence.length) return;
+		return fence;
+	}
+	const opening = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+	if (!opening?.[1]) return void 0;
+	if (opening[1][0] === "`" && opening[2]?.includes("`")) return void 0;
+	return {
+		character: opening[1][0],
+		length: opening[1].length
+	};
+}
+function isAgentContractHeadingText(value) {
+	return value.trim().toLowerCase() === "agent contract";
+}
+function hasPageAgentContractHeading(markdown) {
+	let fence;
+	let previousLine;
+	for (const line of markdown.split(/\r?\n/)) {
+		const nextFence = advanceMarkdownFence(line, fence);
+		if (fence || nextFence) {
+			fence = nextFence;
+			previousLine = void 0;
+			continue;
+		}
+		const atxText = /^ {0,3}#{1,6}(?:[\t ]+|$)(.*)$/.exec(line)?.[1]?.replace(/[\t ]+#+[\t ]*$/, "").trim();
+		if (atxText && isAgentContractHeadingText(atxText)) return true;
+		if (previousLine && /^ {0,3}(?:=+|-+)[\t ]*$/.test(line) && isAgentContractHeadingText(previousLine)) return true;
+		previousLine = line.trim().length > 0 && !/^ {4}/.test(line) && !/^ {0,3}\t/.test(line) ? line : void 0;
+	}
+	return false;
+}
+/** Insert one generated contract unless the document already has handwritten contract guidance. */
+function upsertPageAgentContractMarkdown(markdown, value) {
+	const cleaned = stripGeneratedPageAgentContractMarkdown(markdown);
+	const contract = renderPageAgentContractMarkdown(value);
+	if (!contract || hasPageAgentContractHeading(cleaned)) return cleaned;
+	return cleaned ? `${contract}\n\n${cleaned.replace(/^\r?\n+/, "")}` : contract;
+}
+
+//#endregion
+//#region src/related.ts
+function normalizeDocsRelated(value) {
+	if (!Array.isArray(value)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const links = [];
+	for (const item of value) {
+		const parsed = parseRelatedInput(item);
+		if (!parsed) continue;
+		const dedupeKey = normalizeRelatedLookupPath(parsed.href) ?? parsed.href;
+		if (seen.has(dedupeKey)) continue;
+		seen.add(dedupeKey);
+		links.push({ href: parsed.href });
+	}
+	return links;
+}
+function renderDocsRelatedMarkdownLines(related) {
+	if (!related?.length) return [];
+	return [`Related: ${related.map((link) => normalizeInlineText(link.href)).join(", ")}`];
+}
+function parseRelatedInput(value) {
+	if (typeof value === "string") {
+		const href = cleanString(value);
+		return href ? { href } : null;
+	}
+	return null;
+}
+function cleanString(value) {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function normalizeRelatedLookupPath(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	let pathname = trimmed;
+	try {
+		pathname = new URL(trimmed, "https://docs.local").pathname;
+	} catch {
+		pathname = trimmed.split(/[?#]/, 1)[0] ?? trimmed;
+	}
+	pathname = pathname.replace(/\/+/g, "/").replace(/\.md$/i, "");
+	if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+	if (pathname !== "/") pathname = pathname.replace(/\/+$/, "");
+	return pathname;
+}
+function normalizeInlineText(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+
+//#endregion
+//#region src/sitemap.ts
+const DEFAULT_SITEMAP_XML_ROUTE = "/sitemap.xml";
+const DEFAULT_SITEMAP_MD_ROUTE = "/sitemap.md";
+const DEFAULT_SITEMAP_MD_DOCS_ROUTE = "/docs/sitemap.md";
+const DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE = "/.well-known/sitemap.md";
+const DEFAULT_SITEMAP_MANIFEST_PATH = ".farming-labs/sitemap-manifest.json";
+function normalizeUrlPath(value) {
+	const normalized = value.replace(/\/+/g, "/");
+	if (normalized === "/") return normalized;
+	return normalized.replace(/\/+$/, "");
+}
+function normalizeRoutePrefix(value) {
+	if (!value) return "";
+	const normalized = normalizeUrlPath(`/${value.replace(/^\/+|\/+$/g, "")}`);
+	return normalized === "/" ? "" : normalized;
+}
+function joinRoute(prefix, route) {
+	return normalizeUrlPath(`${prefix}/${route.replace(/^\/+/, "")}`);
+}
+function normalizeDateOnly(value) {
+	if (!value) return void 0;
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const dateOnly = trimmed.match(/^(\d{4}-\d{2}-\d{2})/);
+	if (dateOnly) return dateOnly[1];
+	const parsed = new Date(trimmed);
+	if (Number.isNaN(parsed.getTime())) return void 0;
+	return parsed.toISOString().slice(0, 10);
+}
+function normalizeBaseUrl(value) {
+	if (!value) return void 0;
+	return value.trim().replace(/\/+$/, "") || void 0;
+}
+function isEnabledObject(config) {
+	if (config === false) return false;
+	if (config === void 0) return true;
+	if (config === true) return true;
+	return config.enabled !== false;
+}
+function resolveDocsSitemapConfig(sitemap, defaults = {}) {
+	const objectConfig = sitemap && typeof sitemap === "object" ? sitemap : {};
+	const routePrefix = normalizeRoutePrefix(objectConfig.routePrefix);
+	const xmlConfig = objectConfig.xml;
+	const markdownConfig = objectConfig.markdown;
+	const xmlEnabled = xmlConfig === false ? false : typeof xmlConfig === "object" ? xmlConfig.enabled ?? true : true;
+	const markdownEnabled = markdownConfig === false ? false : typeof markdownConfig === "object" ? markdownConfig.enabled ?? true : true;
+	return {
+		enabled: isEnabledObject(sitemap),
+		routePrefix,
+		baseUrl: normalizeBaseUrl(objectConfig.baseUrl ?? defaults.baseUrl),
+		manifestPath: objectConfig.manifestPath ?? DEFAULT_SITEMAP_MANIFEST_PATH,
+		xml: {
+			enabled: xmlEnabled,
+			includeLastmod: typeof xmlConfig === "object" ? xmlConfig.includeLastmod ?? true : true,
+			route: joinRoute(routePrefix, DEFAULT_SITEMAP_XML_ROUTE)
+		},
+		markdown: {
+			enabled: markdownEnabled,
+			includeDescriptions: typeof markdownConfig === "object" ? markdownConfig.includeDescriptions ?? true : true,
+			includeLastmod: typeof markdownConfig === "object" ? markdownConfig.includeLastmod ?? true : true,
+			linkTarget: typeof markdownConfig === "object" ? markdownConfig.linkTarget ?? "both" : "both",
+			route: joinRoute(routePrefix, DEFAULT_SITEMAP_MD_ROUTE),
+			docsRoute: routePrefix ? void 0 : DEFAULT_SITEMAP_MD_DOCS_ROUTE,
+			wellKnownRoute: joinRoute(routePrefix, DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE)
+		}
+	};
+}
+function resolveDocsSitemapRequest(url, sitemap, options = {}) {
+	const pathname = normalizeUrlPath(url.pathname);
+	const format = url.searchParams.get("format")?.trim();
+	if (pathname === resolveDocsDiscoveryApiRoute(options.apiRoute)) {
+		if (format === "sitemap-xml") return "xml";
+		if (format === "sitemap-md" || format === "sitemap-markdown") return "markdown";
+	}
+	const resolved = resolveDocsSitemapConfig(sitemap);
+	if (!resolved.enabled) return null;
+	if (resolved.xml.enabled && pathname === resolved.xml.route) return "xml";
+	if (resolved.markdown.enabled && (pathname === resolved.markdown.route || pathname === resolved.markdown.docsRoute || pathname === resolved.markdown.wellKnownRoute)) return "markdown";
+	return null;
+}
+function toDocsSitemapMarkdownUrl(url) {
+	const normalized = normalizeUrlPath(url);
+	return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+function absolutizeUrl(baseUrl, url) {
+	if (/^https?:\/\//i.test(url)) return url;
+	const base = normalizeBaseUrl(baseUrl);
+	return base ? `${base}${url.startsWith("/") ? url : `/${url}`}` : url;
+}
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function hashString(value) {
+	let hash = 14695981039346656037n;
+	const bytes = new TextEncoder().encode(value);
+	for (const byte of bytes) {
+		hash ^= BigInt(byte);
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return `"fnv1a64-${hash.toString(16).padStart(16, "0")}"`;
+}
+function newestLastmod(pages) {
+	let newest;
+	for (const page of pages) {
+		const date = normalizeDateOnly(page.lastmod);
+		if (!date) continue;
+		if (!newest || date > newest) newest = date;
+	}
+	return newest;
+}
+function titleize(value) {
+	return value.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function sitemapSectionName(entry, pageUrl) {
+	const normalizedEntry = `/${entry.replace(/^\/+|\/+$/g, "") || "docs"}`;
+	const normalizedUrl = normalizeUrlPath(pageUrl);
+	if (normalizedUrl === normalizedEntry) return "Overview";
+	const firstSegment = (normalizedUrl.startsWith(`${normalizedEntry}/`) ? normalizedUrl.slice(normalizedEntry.length + 1) : normalizedUrl.replace(/^\/+/, "")).split("/").filter(Boolean)[0];
+	return firstSegment ? titleize(firstSegment) : "Pages";
+}
+function buildDocsSitemapManifest(options) {
+	const baseUrl = normalizeBaseUrl(options.baseUrl);
+	const seen = /* @__PURE__ */ new Set();
+	const pages = [];
+	for (const page of options.pages) {
+		const url = normalizeUrlPath(page.url);
+		if (seen.has(url)) continue;
+		seen.add(url);
+		const resolvedLastmod = options.resolveLastmod?.(page);
+		const fallbackLastmod = normalizeDateOnly(page.lastmod ?? page.lastModified);
+		const lastmod = normalizeDateOnly(resolvedLastmod?.lastmod) ?? fallbackLastmod;
+		pages.push({
+			url,
+			absoluteUrl: absolutizeUrl(baseUrl, url),
+			markdownUrl: page.markdownUrl ?? toDocsSitemapMarkdownUrl(url),
+			title: page.title,
+			description: page.description,
+			sourcePath: page.sourcePath,
+			lastmod,
+			lastmodSource: resolvedLastmod?.lastmodSource ?? (lastmod ? "unknown" : void 0),
+			related: page.related?.map((link) => link.href)
+		});
+	}
+	pages.sort((left, right) => left.url.localeCompare(right.url));
+	return {
+		version: 1,
+		generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		baseUrl,
+		entry: options.entry ?? "docs",
+		siteTitle: options.siteTitle,
+		pages
+	};
+}
+function renderDocsSitemapXml(manifest, options = {}) {
+	const baseUrl = normalizeBaseUrl(options.baseUrl ?? manifest.baseUrl);
+	const includeLastmod = options.includeLastmod ?? true;
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">"];
+	for (const page of manifest.pages) {
+		lines.push("  <url>");
+		lines.push(`    <loc>${escapeXml(page.absoluteUrl ?? absolutizeUrl(baseUrl, page.url))}</loc>`);
+		const lastmod = normalizeDateOnly(page.lastmod);
+		if (includeLastmod && lastmod) lines.push(`    <lastmod>${lastmod}</lastmod>`);
+		lines.push("  </url>");
+	}
+	lines.push("</urlset>");
+	return `${lines.join("\n")}\n`;
+}
+function renderDocsSitemapMarkdown(manifest, options = {}) {
+	const siteTitle = manifest.siteTitle ?? "Documentation";
+	const includeDescriptions = options.includeDescriptions ?? true;
+	const includeLastmod = options.includeLastmod ?? true;
+	const linkTarget = options.linkTarget ?? "both";
+	const lines = [`# ${siteTitle} Sitemap`, ""];
+	const baseUrl = normalizeBaseUrl(options.baseUrl ?? manifest.baseUrl);
+	if (baseUrl) lines.push(`Base URL: ${baseUrl}`);
+	lines.push(`Docs entry: /${manifest.entry.replace(/^\/+|\/+$/g, "") || "docs"}`);
+	lines.push(`Generated: ${normalizeDateOnly(manifest.generatedAt) ?? manifest.generatedAt}`, "");
+	const groups = /* @__PURE__ */ new Map();
+	for (const page of manifest.pages) {
+		const sectionName = sitemapSectionName(manifest.entry, page.url);
+		groups.set(sectionName, [...groups.get(sectionName) ?? [], page]);
+	}
+	for (const [sectionName, pages] of groups) {
+		lines.push(`## ${sectionName}`, "");
+		for (const page of pages) {
+			const primaryHref = linkTarget === "markdown" ? page.markdownUrl : page.url;
+			lines.push(`- [${page.title}](${primaryHref})`);
+			if (linkTarget === "both" || linkTarget === "markdown") lines.push(`  Markdown: ${page.markdownUrl}`);
+			if (includeDescriptions && page.description) lines.push(`  Description: ${page.description}`);
+			const lastmod = normalizeDateOnly(page.lastmod);
+			if (includeLastmod && lastmod) lines.push(`  Last updated: ${lastmod}`);
+			if (page.related && page.related.length > 0) lines.push(`  Related: ${page.related.join(", ")}`);
+			lines.push("");
+		}
+	}
+	return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function readDocsSitemapManifestFromContentMap(contentMap) {
+	if (!contentMap) return null;
+	const raw = contentMap[`/${DEFAULT_SITEMAP_MANIFEST_PATH}`] ?? contentMap[DEFAULT_SITEMAP_MANIFEST_PATH];
+	if (!raw) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function resolveDocsSitemapPageLastmod(manifest, url) {
+	if (!manifest) return void 0;
+	const normalizedUrl = normalizeUrlPath(url);
+	return normalizeDateOnly(manifest.pages.find((entry) => normalizeUrlPath(entry.url) === normalizedUrl)?.lastmod);
+}
+function createDocsSitemapResponse({ request, apiRoute, sitemap, entry = "docs", siteTitle, baseUrl, pages, manifest }) {
+	const url = new URL(request.url);
+	const format = resolveDocsSitemapRequest(url, sitemap, { apiRoute });
+	if (!format) return null;
+	const resolved = resolveDocsSitemapConfig(sitemap, { baseUrl });
+	if (!resolved.enabled) return null;
+	if (format === "xml" && !resolved.xml.enabled) return null;
+	if (format === "markdown" && !resolved.markdown.enabled) return null;
+	const nextManifest = manifest ?? buildDocsSitemapManifest({
+		pages,
+		entry,
+		siteTitle,
+		baseUrl: resolved.baseUrl ?? url.origin
+	});
+	const responseBaseUrl = resolved.baseUrl ?? nextManifest.baseUrl ?? url.origin;
+	const body = format === "xml" ? renderDocsSitemapXml(nextManifest, {
+		baseUrl: responseBaseUrl,
+		includeLastmod: resolved.xml.includeLastmod
+	}) : renderDocsSitemapMarkdown(nextManifest, {
+		baseUrl: responseBaseUrl,
+		includeDescriptions: resolved.markdown.includeDescriptions,
+		includeLastmod: resolved.markdown.includeLastmod,
+		linkTarget: resolved.markdown.linkTarget
+	});
+	const headers = new Headers({
+		"Content-Type": format === "xml" ? "application/xml; charset=utf-8" : "text/markdown; charset=utf-8",
+		"Cache-Control": "public, max-age=0, must-revalidate",
+		ETag: hashString(body)
+	});
+	const lastModified = newestLastmod(nextManifest.pages);
+	if (lastModified) headers.set("Last-Modified", (/* @__PURE__ */ new Date(`${lastModified}T00:00:00.000Z`)).toUTCString());
+	if (request.headers.get("if-none-match") === headers.get("ETag")) return new Response(null, {
+		status: 304,
+		headers
+	});
+	return new Response(body, { headers });
+}
+
+//#endregion
+//#region src/audience.ts
+/** Resolve whether content with an optional audience restriction is visible. */
+function resolveDocsAudienceExposure(only, audience) {
+	return only !== "human" && only !== "agent" || only === audience;
+}
+const DOCS_AUDIENCE_TAG_NAMES = [
+	"Audience",
+	"Agent",
+	"Human"
+];
+const DOCS_AUDIENCE_TAG_CANDIDATE_PATTERN = /<\/?(?:Audience|Agent|Human)(?=[\s/>])/;
+function parseAudienceOnly(attributes) {
+	if (/\{\s*\.\.\./.test(attributes)) return void 0;
+	const value = attributes.match(/(?:^|\s)only\s*=\s*(?:"(human|agent)"|'(human|agent)'|\{\s*"(human|agent)"\s*\}|\{\s*'(human|agent)'\s*\})/)?.slice(1).find(Boolean);
+	return value === "human" || value === "agent" ? value : void 0;
+}
+function isEscapedAt(content, index) {
+	let backslashes = 0;
+	for (let cursor = index - 1; cursor >= 0 && content[cursor] === "\\"; cursor -= 1) backslashes += 1;
+	return backslashes % 2 === 1;
+}
+const JAVASCRIPT_REGEX_PREFIX_KEYWORDS = new Set([
+	"await",
+	"case",
+	"delete",
+	"do",
+	"else",
+	"each",
+	"if",
+	"in",
+	"instanceof",
+	"key",
+	"new",
+	"of",
+	"return",
+	"throw",
+	"catch",
+	"const",
+	"debug",
+	"html",
+	"render",
+	"snippet",
+	"then",
+	"typeof",
+	"void",
+	"yield"
+]);
+function canStartJavascriptRegex(content, cursor, boundary) {
+	let previous = cursor - 1;
+	while (previous > boundary && /\s/.test(content[previous] ?? "")) previous -= 1;
+	if (previous <= boundary || /[([{=,:;!?&|>]/.test(content[previous] ?? "")) return true;
+	const precedingWord = content.slice(boundary + 1, cursor).match(/([A-Za-z_$][\w$]*)\s*$/)?.[1];
+	return JAVASCRIPT_REGEX_PREFIX_KEYWORDS.has(precedingWord ?? "");
+}
+function readAudienceTagAt(content, index) {
+	let cursor = index + 1;
+	const closing = content[cursor] === "/";
+	if (closing) cursor += 1;
+	const name = DOCS_AUDIENCE_TAG_NAMES.find((candidate) => content.startsWith(candidate, cursor) && /[\s/>]/.test(content[cursor + candidate.length] ?? ""));
+	if (!name) return void 0;
+	cursor += name.length;
+	const attributesStart = cursor;
+	let braceDepth = 0;
+	let quote;
+	let blockComment = false;
+	let lineComment = false;
+	while (cursor < content.length) {
+		const character = content[cursor];
+		const next = content[cursor + 1];
+		if (lineComment) {
+			if (character === "\n") lineComment = false;
+			cursor += 1;
+			continue;
+		}
+		if (blockComment) {
+			if (character === "*" && next === "/") {
+				blockComment = false;
+				cursor += 2;
+			} else cursor += 1;
+			continue;
+		}
+		if (quote) {
+			if (character === "\\") {
+				cursor += 2;
+				continue;
+			}
+			if (character === quote) quote = void 0;
+			cursor += 1;
+			continue;
+		}
+		if (braceDepth > 0 && character === "/" && next === "*") {
+			blockComment = true;
+			cursor += 2;
+			continue;
+		}
+		if (braceDepth > 0 && character === "/" && next === "/") {
+			lineComment = true;
+			cursor += 2;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") quote = character;
+		else if (character === "{") braceDepth += 1;
+		else if (character === "}" && braceDepth > 0) braceDepth -= 1;
+		else if (character === ">" && braceDepth === 0) {
+			let attributesEnd = cursor;
+			let slashIndex = cursor - 1;
+			while (slashIndex >= attributesStart && /\s/.test(content[slashIndex] ?? "")) slashIndex -= 1;
+			const selfClosing = content[slashIndex] === "/";
+			if (selfClosing) attributesEnd = slashIndex;
+			const attributes = content.slice(attributesStart, attributesEnd);
+			return {
+				index,
+				end: cursor + 1,
+				name,
+				closing,
+				selfClosing,
+				attributes,
+				only: name === "Agent" ? "agent" : name === "Human" ? "human" : parseAudienceOnly(attributes)
+			};
+		}
+		cursor += 1;
+	}
+}
+function findAudienceTags(content, protectedRanges) {
+	const tags = [];
+	let cursor = 0;
+	while (cursor < content.length) {
+		const index = content.indexOf("<", cursor);
+		if (index === -1) break;
+		if (isEscapedAt(content, index) || isInsideRange(index, protectedRanges)) {
+			cursor = index + 1;
+			continue;
+		}
+		const tag = readAudienceTagAt(content, index);
+		if (tag) {
+			tags.push(tag);
+			cursor = tag.end;
+		} else cursor = index + 1;
+	}
+	return tags;
+}
+const docsAudienceMdxProcessor = createProcessor({ format: "mdx" });
+const docsAudienceMarkdownProcessor = createProcessor({ format: "md" });
+function getOffset(position, edge) {
+	const value = position?.[edge]?.offset;
+	return typeof value === "number" ? value : void 0;
+}
+function maskRangesForMdxParser(content, ranges) {
+	if (ranges.length === 0) return content;
+	const characters = content.split("");
+	for (const range of ranges) for (let index = range.start; index < range.end; index += 1) if (characters[index] !== "\n" && characters[index] !== "\r") characters[index] = " ";
+	return characters.join("");
+}
+function findLeadingFrontmatterRange(content) {
+	const bomLength = content.startsWith("") ? 1 : 0;
+	const opening = content.slice(bomLength).match(/^(---|\+\+\+)[\t ]*(?:\r?\n|$)/);
+	const marker = opening?.[1];
+	if (!opening || !marker) return void 0;
+	let offset = bomLength + opening[0].length;
+	for (const line of content.slice(offset).split(/(?<=\n)/)) {
+		offset += line.length;
+		const value = line.replace(/\r?\n$/, "");
+		if (marker === "---" ? /^(?:---|\.\.\.)[\t ]*$/.test(value) : /^\+\+\+[\t ]*$/.test(value)) return {
+			start: 0,
+			end: offset
+		};
+	}
+}
+function findHtmlLiteralRanges(content, excludedRanges = []) {
+	const ranges = [];
+	const rawPattern = /<(script|style)(?=[\s/>])/g;
+	let cursor = 0;
+	while (cursor < content.length) {
+		rawPattern.lastIndex = cursor;
+		const rawMatch = rawPattern.exec(content);
+		const commentStart = content.indexOf("<!--", cursor);
+		const rawStart = rawMatch?.index ?? -1;
+		const useComment = commentStart !== -1 && (rawStart === -1 || commentStart < rawStart);
+		const start = useComment ? commentStart : rawStart;
+		if (start === -1) break;
+		if (isEscapedAt(content, start) || isInsideRange(start, excludedRanges)) {
+			cursor = start + 1;
+			continue;
+		}
+		if (useComment) {
+			const closing = content.indexOf("-->", start + 4);
+			const end = closing === -1 ? content.length : closing + 3;
+			ranges.push({
+				start,
+				end
+			});
+			cursor = end;
+			continue;
+		}
+		const name = rawMatch?.[1];
+		if (!name) {
+			cursor = start + 1;
+			continue;
+		}
+		const opening = readGenericMdxJsxTag(content, start);
+		if (!opening) {
+			cursor = start + 1;
+			continue;
+		}
+		if (opening.selfClosing) {
+			cursor = opening.end;
+			continue;
+		}
+		const closingPattern = new RegExp(`</${name}\\s*>`, "g");
+		closingPattern.lastIndex = opening.end;
+		if (!closingPattern.exec(content)) {
+			ranges.push({
+				start,
+				end: content.length
+			});
+			break;
+		}
+		ranges.push({
+			start,
+			end: closingPattern.lastIndex
+		});
+		cursor = closingPattern.lastIndex;
+	}
+	return ranges;
+}
+function prepareMdxParserSource(content) {
+	const baseExcludedRanges = findDelimiterExclusionRanges(content);
+	const svelteDirectives = findSvelteDirectiveRanges(content, baseExcludedRanges);
+	const ranges = [...findHtmlLiteralRanges(content, mergeProtectedRanges([...baseExcludedRanges, ...svelteDirectives])), ...svelteDirectives];
+	const frontmatter = findLeadingFrontmatterRange(content);
+	if (frontmatter) ranges.push(frontmatter);
+	return maskRangesForMdxParser(content, mergeProtectedRanges(ranges));
+}
+function getExpressionLiteralString(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const expression = value.data?.estree?.body?.[0]?.expression;
+	return expression?.type === "Literal" && typeof expression.value === "string" ? expression.value : void 0;
+}
+function getMdxAudienceAttributeInfo(attributes) {
+	const hasSpreadAttribute = attributes.some((attribute) => attribute.type === "mdxJsxExpressionAttribute");
+	const onlyAttribute = [...attributes].reverse().find((attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "only");
+	if (hasSpreadAttribute) return {
+		hasOnlyAttribute: Boolean(onlyAttribute),
+		hasSpreadAttribute,
+		onlyKind: "dynamic"
+	};
+	if (!onlyAttribute) return {
+		hasOnlyAttribute: false,
+		hasSpreadAttribute: false,
+		onlyKind: "missing"
+	};
+	const value = typeof onlyAttribute.value === "string" ? onlyAttribute.value : getExpressionLiteralString(onlyAttribute.value);
+	if (value === "human" || value === "agent") return {
+		only: value,
+		hasOnlyAttribute: true,
+		hasSpreadAttribute: false,
+		onlyKind: "static"
+	};
+	return {
+		hasOnlyAttribute: true,
+		hasSpreadAttribute: false,
+		onlyKind: typeof onlyAttribute.value === "object" ? "dynamic" : "invalid"
+	};
+}
+function getEstreeAudienceAttributeInfo(attributes) {
+	const records = attributes.filter((attribute) => Boolean(attribute && typeof attribute === "object"));
+	const hasSpreadAttribute = records.some((attribute) => attribute.type === "JSXSpreadAttribute");
+	const onlyAttribute = [...records].reverse().find((attribute) => {
+		const name = attribute.name;
+		return attribute.type === "JSXAttribute" && name?.type === "JSXIdentifier" && name.name === "only";
+	});
+	if (hasSpreadAttribute) return {
+		hasOnlyAttribute: Boolean(onlyAttribute),
+		hasSpreadAttribute,
+		onlyKind: "dynamic"
+	};
+	if (!onlyAttribute) return {
+		hasOnlyAttribute: false,
+		hasSpreadAttribute: false,
+		onlyKind: "missing"
+	};
+	const attributeValue = onlyAttribute.value;
+	const value = attributeValue?.type === "Literal" ? attributeValue.value : attributeValue?.type === "JSXExpressionContainer" && attributeValue.expression?.type === "Literal" ? attributeValue.expression.value : void 0;
+	if (value === "human" || value === "agent") return {
+		only: value,
+		hasOnlyAttribute: true,
+		hasSpreadAttribute: false,
+		onlyKind: "static"
+	};
+	return {
+		hasOnlyAttribute: true,
+		hasSpreadAttribute: false,
+		onlyKind: attributeValue?.type === "JSXExpressionContainer" ? "dynamic" : "invalid"
+	};
+}
+function getOpeningTagEnd(content, start, name, attributes) {
+	const searchStart = Math.max(start + name.length + 1, ...attributes.map((attribute) => getOffset(attribute.position, "end") ?? 0));
+	const closingBracket = content.indexOf(">", searchStart);
+	return closingBracket === -1 ? void 0 : closingBracket + 1;
+}
+function addMdxAudienceElementTags(content, node, tags) {
+	const name = node.name;
+	const start = getOffset(node.position, "start");
+	const nodeEnd = getOffset(node.position, "end");
+	if (start === void 0 || nodeEnd === void 0) return;
+	const attributes = node.attributes ?? [];
+	const openingEnd = getOpeningTagEnd(content, start, name, attributes);
+	if (openingEnd === void 0) return;
+	const closingStart = content.lastIndexOf(`</${name}`, nodeEnd);
+	const hasClosingTag = closingStart >= openingEnd;
+	const attributeInfo = getMdxAudienceAttributeInfo(attributes);
+	const rawAttributes = content.slice(start + name.length + 1, openingEnd - 1);
+	tags.push({
+		index: start,
+		end: openingEnd,
+		name,
+		closing: false,
+		selfClosing: !hasClosingTag,
+		attributes: rawAttributes,
+		only: name === "Agent" ? "agent" : name === "Human" ? "human" : attributeInfo.only,
+		hasOnlyAttribute: attributeInfo.hasOnlyAttribute,
+		hasSpreadAttribute: attributeInfo.hasSpreadAttribute,
+		onlyKind: attributeInfo.onlyKind
+	});
+	if (hasClosingTag) tags.push({
+		index: closingStart,
+		end: nodeEnd,
+		name,
+		closing: true,
+		selfClosing: false,
+		attributes: ""
+	});
+}
+function getEstreeJsxIdentifierName(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const name = value;
+	return name.type === "JSXIdentifier" && DOCS_AUDIENCE_TAG_NAMES.some((candidate) => candidate === name.name) ? name.name : void 0;
+}
+function addEstreeAudienceElementTags(content, node, tags, jsxChild) {
+	const opening = node.openingElement;
+	if (!opening) return;
+	const name = getEstreeJsxIdentifierName(opening.name);
+	const start = typeof opening.start === "number" ? opening.start : void 0;
+	const openingEnd = typeof opening.end === "number" ? opening.end : void 0;
+	const nodeEnd = typeof node.end === "number" ? node.end : void 0;
+	if (!name || start === void 0 || openingEnd === void 0 || nodeEnd === void 0) return;
+	const attributeInfo = getEstreeAudienceAttributeInfo(Array.isArray(opening.attributes) ? opening.attributes : []);
+	const closing = node.closingElement;
+	const closingStart = closing && typeof closing.start === "number" ? closing.start : void 0;
+	const closingEnd = closing && typeof closing.end === "number" ? closing.end : void 0;
+	tags.push({
+		index: start,
+		end: openingEnd,
+		name,
+		closing: false,
+		selfClosing: closingStart === void 0,
+		attributes: content.slice(start + name.length + 1, openingEnd - 1),
+		only: name === "Agent" ? "agent" : name === "Human" ? "human" : attributeInfo.only,
+		expression: true,
+		jsxChild,
+		hasOnlyAttribute: attributeInfo.hasOnlyAttribute,
+		hasSpreadAttribute: attributeInfo.hasSpreadAttribute,
+		onlyKind: attributeInfo.onlyKind
+	});
+	if (closingStart !== void 0 && closingEnd !== void 0) tags.push({
+		index: closingStart,
+		end: closingEnd,
+		name,
+		closing: true,
+		selfClosing: false,
+		attributes: "",
+		expression: true,
+		jsxChild
+	});
+}
+function collectEstreeAudienceTags(content, value, tags, seen = /* @__PURE__ */ new WeakSet(), parent, parentKey) {
+	if (!value || typeof value !== "object" || seen.has(value)) return;
+	seen.add(value);
+	const record = value;
+	if (record.type === "JSXElement") {
+		const opening = record.openingElement;
+		if (getEstreeJsxIdentifierName(opening?.name)) {
+			addEstreeAudienceElementTags(content, record, tags, parentKey === "children" && (parent?.type === "JSXElement" || parent?.type === "JSXFragment"));
+			for (const child of Array.isArray(record.children) ? record.children : []) collectEstreeAudienceTags(content, child, tags, seen, record, "children");
+			return;
+		}
+	}
+	for (const [key, child] of Object.entries(record)) {
+		if (key === "loc" || key === "range" || key === "comments") continue;
+		if (Array.isArray(child)) for (const item of child) collectEstreeAudienceTags(content, item, tags, seen, record, key);
+		else collectEstreeAudienceTags(content, child, tags, seen, record, key);
+	}
+}
+function collectMdxAudienceTags(content, node, tags) {
+	const isMdxJsxElement = node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement";
+	if (isMdxJsxElement && (node.name === "script" || node.name === "style")) return;
+	const isAudienceElement = Boolean(isMdxJsxElement && node.name && DOCS_AUDIENCE_TAG_NAMES.some((candidate) => candidate === node.name));
+	if (isAudienceElement) addMdxAudienceElementTags(content, node, tags);
+	if (node.type !== "mdxjsEsm") {
+		if (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") collectEstreeAudienceTags(content, node.data?.estree, tags);
+		if (isMdxJsxElement && !isAudienceElement) for (const attribute of node.attributes ?? []) {
+			collectEstreeAudienceTags(content, attribute.data?.estree, tags);
+			if (attribute.value && typeof attribute.value === "object") {
+				const value = attribute.value;
+				collectEstreeAudienceTags(content, value.data?.estree, tags);
+			}
+		}
+	}
+	for (const child of node.children ?? []) collectMdxAudienceTags(content, child, tags);
+}
+function findMdxAstAudienceTags(content) {
+	try {
+		const tree = docsAudienceMdxProcessor.parse(prepareMdxParserSource(content));
+		const tags = [];
+		collectMdxAudienceTags(content, tree, tags);
+		return tags.sort((left, right) => left.index - right.index || left.end - right.end);
+	} catch {
+		return;
+	}
+}
+/** Locate effective audience tags while excluding Markdown/MDX literal contexts. */
+function findDocsAudienceMdxTags(content) {
+	if (!DOCS_AUDIENCE_TAG_CANDIDATE_PATTERN.test(content)) return [];
+	return findMdxAstAudienceTags(content) ?? findAudienceTags(content, findProtectedRanges(content));
+}
+function isAudienceVisible(scopes, audience) {
+	return scopes.every((scope) => resolveDocsAudienceExposure(scope.only, audience));
+}
+function mergeProtectedRanges(ranges) {
+	const sorted = [...ranges].sort((left, right) => left.start - right.start || left.end - right.end);
+	const merged = [];
+	for (const range of sorted) {
+		const previous = merged.at(-1);
+		if (!previous || range.start > previous.end) {
+			merged.push({ ...range });
+			continue;
+		}
+		previous.end = Math.max(previous.end, range.end);
+	}
+	return merged;
+}
+function findMarkdownLiteralRanges(content) {
+	try {
+		const tree = docsAudienceMarkdownProcessor.parse(content);
+		const ranges = [];
+		const visit = (node) => {
+			const start = getOffset(node.position, "start");
+			const end = getOffset(node.position, "end");
+			if (start !== void 0 && end !== void 0) {
+				if (node.type === "code" || node.type === "inlineCode" || node.type === "definition") ranges.push({
+					start,
+					end
+				});
+				else if (node.type === "link" || node.type === "image") {
+					const contentEnd = Math.max(start, ...(node.children ?? []).map((child) => getOffset(child.position, "end") ?? start));
+					ranges.push({
+						start: contentEnd,
+						end
+					});
+				}
+			}
+			for (const child of node.children ?? []) visit(child);
+		};
+		visit(tree);
+		return ranges;
+	} catch {
+		return [];
+	}
+}
+function findMarkdownLinkDestinationRanges(content, protectedRanges) {
+	const ranges = [];
+	let cursor = 0;
+	while (cursor < content.length) {
+		const start = content.indexOf("](", cursor);
+		if (start === -1) break;
+		if (isEscapedAt(content, start) || isInsideRange(start, protectedRanges)) {
+			cursor = start + 1;
+			continue;
+		}
+		let end = start + 2;
+		let parenthesisDepth = 1;
+		let angleDestination = false;
+		let quote;
+		while (end < content.length && parenthesisDepth > 0) {
+			const character = content[end];
+			if (character === "\\") {
+				end += 2;
+				continue;
+			}
+			if (quote) {
+				if (character === quote) quote = void 0;
+				end += 1;
+				continue;
+			}
+			if (character === "\"" || character === "'") quote = character;
+			else if (character === "<" && parenthesisDepth === 1) {
+				const closingAngle = content.indexOf(">", end + 1);
+				const closingParenthesis = content.indexOf(")", end + 1);
+				angleDestination = closingAngle !== -1 && closingAngle < closingParenthesis;
+			} else if (character === ">" && angleDestination) angleDestination = false;
+			else if (!angleDestination && character === "(") parenthesisDepth += 1;
+			else if (!angleDestination && character === ")") parenthesisDepth -= 1;
+			end += 1;
+		}
+		if (parenthesisDepth === 0) ranges.push({
+			start: start + 1,
+			end
+		});
+		cursor = Math.max(start + 1, end);
+	}
+	return ranges;
+}
+function findFenceRanges(content) {
+	const ranges = [];
+	let fence;
+	let offset = 0;
+	const stripBlockquoteContainers = (line) => {
+		let value = line;
+		while (/^ {0,3}>[\t ]?/.test(value)) value = value.replace(/^ {0,3}>[\t ]?/, "");
+		return value;
+	};
+	const stripOpeningListContainers = (line) => {
+		let value = line;
+		while (/^ {0,3}(?:[-+*]|\d{1,9}[.)])[\t ]+/.test(value)) value = value.replace(/^ {0,3}(?:[-+*]|\d{1,9}[.)])[\t ]+/, "");
+		return value;
+	};
+	for (const line of content.split(/(?<=\n)/)) {
+		const containerRelativeLine = stripBlockquoteContainers(line.replace(/\r?\n$/, ""));
+		const match = (fence ? containerRelativeLine : stripOpeningListContainers(containerRelativeLine)).match(/^[\t ]*(`{3,}|~{3,})(.*)$/);
+		if (!fence && match?.[1]) fence = {
+			marker: match[1][0],
+			length: match[1].length,
+			start: offset
+		};
+		else if (fence && match?.[1]?.[0] === fence.marker && match[1].length >= fence.length && /^[\t ]*$/.test(match[2] ?? "")) {
+			ranges.push({
+				start: fence.start,
+				end: offset + line.length
+			});
+			fence = void 0;
+		}
+		offset += line.length;
+	}
+	if (fence) ranges.push({
+		start: fence.start,
+		end: content.length
+	});
+	return ranges;
+}
+function findSvelteDirectiveRanges(content, excludedRanges) {
+	const ranges = [];
+	let index = 0;
+	while (index < content.length) {
+		const start = content.indexOf("{", index);
+		if (start === -1) break;
+		const sigil = content[start + 1];
+		if (!/[#/:@]/.test(sigil ?? "") || !/[A-Za-z]/.test(content[start + 2] ?? "") || isEscapedAt(content, start) || isInsideRange(start, excludedRanges)) {
+			index = start + 1;
+			continue;
+		}
+		let cursor = start + 2;
+		let braceDepth = 1;
+		let quote;
+		let blockComment = false;
+		let lineComment = false;
+		let regex = false;
+		let regexCharacterClass = false;
+		while (cursor < content.length && braceDepth > 0) {
+			const character = content[cursor];
+			const next = content[cursor + 1];
+			if (lineComment) {
+				if (character === "\n") lineComment = false;
+				cursor += 1;
+				continue;
+			}
+			if (blockComment) {
+				if (character === "*" && next === "/") {
+					blockComment = false;
+					cursor += 2;
+				} else cursor += 1;
+				continue;
+			}
+			if (quote) {
+				if (character === "\\") {
+					cursor += 2;
+					continue;
+				}
+				if (character === quote) quote = void 0;
+				cursor += 1;
+				continue;
+			}
+			if (regex) {
+				if (character === "\\") {
+					cursor += 2;
+					continue;
+				}
+				if (character === "[") regexCharacterClass = true;
+				if (character === "]") regexCharacterClass = false;
+				if (character === "/" && !regexCharacterClass) regex = false;
+				cursor += 1;
+				continue;
+			}
+			if (character === "/" && next === "*") {
+				blockComment = true;
+				cursor += 2;
+				continue;
+			}
+			if (character === "/" && next === "/") {
+				lineComment = true;
+				cursor += 2;
+				continue;
+			}
+			if (character === "\"" || character === "'" || character === "`") {
+				quote = character;
+				cursor += 1;
+				continue;
+			}
+			if (character === "/") {
+				if (canStartJavascriptRegex(content, cursor, start + 1)) {
+					regex = true;
+					cursor += 1;
+					continue;
+				}
+			}
+			if (character === "{") braceDepth += 1;
+			if (character === "}") braceDepth -= 1;
+			cursor += 1;
+		}
+		if (braceDepth === 0) ranges.push({
+			start,
+			end: cursor
+		});
+		index = Math.max(start + 1, cursor);
+	}
+	return ranges;
+}
+function scanMdxModuleLine(line, state) {
+	for (let index = 0; index < line.length; index += 1) {
+		const character = line[index];
+		const next = line[index + 1];
+		if (state.blockComment) {
+			if (character === "*" && next === "/") {
+				state.blockComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (state.quote) {
+			if (character === "\\") {
+				index += 1;
+				continue;
+			}
+			if (character === state.quote) state.quote = void 0;
+			continue;
+		}
+		if (character === "/" && next === "/") break;
+		if (character === "/" && next === "*") {
+			state.blockComment = true;
+			index += 1;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") {
+			state.quote = character;
+			continue;
+		}
+		if (state.jsxTag) {
+			if (character === "{") state.braceDepth += 1;
+			else if (character === "}" && state.braceDepth > 0) state.braceDepth -= 1;
+			else if (character === ">" && state.braceDepth === 0) {
+				let previous = index - 1;
+				while (previous >= 0 && /[\t ]/.test(line[previous] ?? "")) previous -= 1;
+				const selfClosing = line[previous] === "/";
+				let following = index + 1;
+				while (following < line.length && /[\t ]/.test(line[following] ?? "")) following += 1;
+				const genericTypeParameters = !state.jsxTag.closing && line[following] === "(";
+				if (state.jsxTag.closing) state.jsxDepth = Math.max(0, state.jsxDepth - 1);
+				else if (!selfClosing && !genericTypeParameters) state.jsxDepth += 1;
+				state.jsxTag = void 0;
+			}
+			continue;
+		}
+		if (character === "<") {
+			let previous = index - 1;
+			while (previous >= 0 && /[\t ]/.test(line[previous] ?? "")) previous -= 1;
+			const previousCharacter = line[previous];
+			const atExpressionStart = previousCharacter === void 0 || /[=([{,:?!;]/.test(previousCharacter);
+			const openingElement = (state.jsxDepth > 0 || atExpressionStart) && /[A-Za-z]/.test(next ?? "");
+			const closingElement = state.jsxDepth > 0 && next === "/" && /[A-Za-z]/.test(line[index + 2] ?? "");
+			const openingFragment = atExpressionStart && next === ">";
+			const closingFragment = state.jsxDepth > 0 && next === "/" && line[index + 2] === ">";
+			if (openingFragment) {
+				state.jsxDepth += 1;
+				index += 1;
+				continue;
+			}
+			if (closingFragment) {
+				state.jsxDepth = Math.max(0, state.jsxDepth - 1);
+				index += 2;
+				continue;
+			}
+			if (openingElement || closingElement) {
+				state.jsxTag = { closing: closingElement };
+				continue;
+			}
+		}
+		if (character === "{") {
+			state.braceDepth += 1;
+			state.sawBlock = true;
+			continue;
+		}
+		if (character === "}") state.braceDepth = Math.max(0, state.braceDepth - 1);
+		else if (character === "[") state.bracketDepth += 1;
+		else if (character === "]") state.bracketDepth = Math.max(0, state.bracketDepth - 1);
+		else if (character === "(") state.parenthesisDepth += 1;
+		else if (character === ")") state.parenthesisDepth = Math.max(0, state.parenthesisDepth - 1);
+	}
+}
+function shouldContinueMdxModule(statement, state, nextSignificantLine) {
+	if (state.quote || state.blockComment || state.braceDepth > 0 || state.bracketDepth > 0 || state.parenthesisDepth > 0 || state.jsxTag || state.jsxDepth > 0) return true;
+	const trimmed = statement.trimEnd();
+	if (/^\s*import\b(?!\s*[.(])/.test(statement)) {
+		if (!(/^\s*import\s*(?:type\s+)?["'`]/.test(statement) || /\bfrom\s*["'`][\s\S]*["'`]\s*;?\s*$/.test(trimmed)) && !/;\s*$/.test(trimmed)) return true;
+	}
+	const isExportList = /^\s*export\s+(?:type\s+)?\{/.test(statement);
+	const isExportAll = /^\s*export\s+\*/.test(statement);
+	if ((isExportList || isExportAll) && !/\bfrom\s*["'`][\s\S]*["'`]\s*;?\s*$/.test(trimmed) && (isExportAll || /^\s*from\b/.test(nextSignificantLine ?? ""))) return true;
+	if (/=>\s*$/.test(trimmed) || /[=([{,:.?+\-*/%&|^!]$/.test(trimmed)) return true;
+	if (/\b(?:as|default|extends|from|implements|satisfies)$/.test(trimmed)) return true;
+	return /^\s*export\s+(?:default\s+)?(?:(?:async\s+)?function|class|enum|interface|module|namespace)\b/.test(statement) && !state.sawBlock;
+}
+function isInsideRange(index, ranges) {
+	return ranges.some((range) => index >= range.start && index < range.end);
+}
+function findMdxModuleRanges(content, protectedRanges) {
+	const ranges = [];
+	const lines = content.split(/(?<=\n)/);
+	let offset = 0;
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+		const line = lines[lineIndex] ?? "";
+		const firstNonWhitespace = line.search(/\S/);
+		if (/^\s*(?:import|export)\b/.test(line) && !isInsideRange(offset + Math.max(0, firstNonWhitespace), protectedRanges)) {
+			const start = offset;
+			const state = {
+				braceDepth: 0,
+				bracketDepth: 0,
+				parenthesisDepth: 0,
+				blockComment: false,
+				sawBlock: false,
+				jsxDepth: 0
+			};
+			let statement = "";
+			while (lineIndex < lines.length) {
+				const moduleLine = lines[lineIndex] ?? "";
+				statement += moduleLine;
+				scanMdxModuleLine(moduleLine, state);
+				offset += moduleLine.length;
+				const nextSignificantLine = lines.slice(lineIndex + 1).find((candidate) => candidate.trim().length > 0);
+				if (!shouldContinueMdxModule(statement, state, nextSignificantLine)) break;
+				lineIndex += 1;
+			}
+			ranges.push({
+				start,
+				end: offset
+			});
+			continue;
+		}
+		offset += line.length;
+	}
+	return ranges;
+}
+function findInlineCodeRanges(content, protectedRanges) {
+	const ranges = [];
+	let index = 0;
+	while (index < content.length) {
+		if (content[index] !== "`" || isEscapedAt(content, index) || isInsideRange(index, protectedRanges)) {
+			index += 1;
+			continue;
+		}
+		let markerLength = 1;
+		while (content[index + markerLength] === "`") markerLength += 1;
+		let closingIndex = index + markerLength;
+		while (closingIndex < content.length) {
+			closingIndex = content.indexOf("`", closingIndex);
+			if (closingIndex === -1) break;
+			if (isInsideRange(closingIndex, protectedRanges)) {
+				closingIndex += 1;
+				continue;
+			}
+			let closingLength = 1;
+			while (content[closingIndex + closingLength] === "`") closingLength += 1;
+			if (closingLength === markerLength) break;
+			closingIndex += closingLength;
+		}
+		if (closingIndex === -1) {
+			index += markerLength;
+			continue;
+		}
+		ranges.push({
+			start: index,
+			end: closingIndex + markerLength
+		});
+		index = closingIndex + markerLength;
+	}
+	return ranges;
+}
+function findMdxExpressionLiteralRanges(content, protectedRanges) {
+	const ranges = [];
+	let index = 0;
+	while (index < content.length) {
+		if (content[index] !== "{" || isEscapedAt(content, index) || isInsideRange(index, protectedRanges)) {
+			index += 1;
+			continue;
+		}
+		let cursor = index + 1;
+		let depth = 1;
+		while (cursor < content.length && depth > 0) {
+			if (isInsideRange(cursor, protectedRanges)) {
+				cursor += 1;
+				continue;
+			}
+			const character = content[cursor];
+			const next = content[cursor + 1];
+			if (character === "\"" || character === "'" || character === "`") {
+				const quote = character;
+				const start = cursor;
+				cursor += 1;
+				while (cursor < content.length) {
+					if (content[cursor] === "\\") {
+						cursor += 2;
+						continue;
+					}
+					if (content[cursor] === quote) {
+						cursor += 1;
+						break;
+					}
+					cursor += 1;
+				}
+				ranges.push({
+					start,
+					end: cursor
+				});
+				continue;
+			}
+			if (character === "/" && next === "*") {
+				const start = cursor;
+				const end = content.indexOf("*/", cursor + 2);
+				cursor = end === -1 ? content.length : end + 2;
+				ranges.push({
+					start,
+					end: cursor
+				});
+				continue;
+			}
+			if (character === "/" && next === "/") {
+				const start = cursor;
+				const newline = content.indexOf("\n", cursor + 2);
+				cursor = newline === -1 ? content.length : newline;
+				ranges.push({
+					start,
+					end: cursor
+				});
+				continue;
+			}
+			if (character === "/") {
+				if (canStartJavascriptRegex(content, cursor, index)) {
+					const start = cursor;
+					let inCharacterClass = false;
+					cursor += 1;
+					while (cursor < content.length) {
+						if (content[cursor] === "\\") {
+							cursor += 2;
+							continue;
+						}
+						if (content[cursor] === "[") inCharacterClass = true;
+						if (content[cursor] === "]") inCharacterClass = false;
+						if (content[cursor] === "/" && !inCharacterClass) {
+							cursor += 1;
+							while (/[A-Za-z]/.test(content[cursor] ?? "")) cursor += 1;
+							break;
+						}
+						if (content[cursor] === "\n") break;
+						cursor += 1;
+					}
+					ranges.push({
+						start,
+						end: cursor
+					});
+					continue;
+				}
+			}
+			if (character === "{") depth += 1;
+			if (character === "}") depth -= 1;
+			cursor += 1;
+		}
+		index = Math.max(index + 1, cursor);
+	}
+	return ranges;
+}
+function readGenericMdxJsxTag(content, index) {
+	let cursor = index + 1;
+	if (content[cursor] === "/") cursor += 1;
+	if (!/[A-Za-z]/.test(content[cursor] ?? "")) return void 0;
+	const nameStart = cursor;
+	while (/[\w:.-]/.test(content[cursor] ?? "")) cursor += 1;
+	const name = content.slice(nameStart, cursor);
+	if (DOCS_AUDIENCE_TAG_NAMES.some((candidate) => candidate === name)) return void 0;
+	if (!/[\s/>]/.test(content[cursor] ?? "")) return void 0;
+	const literals = [];
+	let braceDepth = 0;
+	while (cursor < content.length) {
+		const character = content[cursor];
+		const next = content[cursor + 1];
+		if (character === "\"" || character === "'" || character === "`") {
+			const quote = character;
+			const start = cursor;
+			cursor += 1;
+			while (cursor < content.length) {
+				if (content[cursor] === "\\") {
+					cursor += 2;
+					continue;
+				}
+				if (content[cursor] === quote) {
+					cursor += 1;
+					break;
+				}
+				cursor += 1;
+			}
+			literals.push({
+				start,
+				end: cursor
+			});
+			continue;
+		}
+		if (braceDepth > 0 && character === "/" && next === "*") {
+			const start = cursor;
+			const end = content.indexOf("*/", cursor + 2);
+			cursor = end === -1 ? content.length : end + 2;
+			literals.push({
+				start,
+				end: cursor
+			});
+			continue;
+		}
+		if (braceDepth > 0 && character === "/" && next === "/") {
+			const start = cursor;
+			const newline = content.indexOf("\n", cursor + 2);
+			cursor = newline === -1 ? content.length : newline;
+			literals.push({
+				start,
+				end: cursor
+			});
+			continue;
+		}
+		if (character === "{") braceDepth += 1;
+		else if (character === "}" && braceDepth > 0) braceDepth -= 1;
+		else if (character === ">" && braceDepth === 0) {
+			let previous = cursor - 1;
+			while (previous >= index && /\s/.test(content[previous] ?? "")) previous -= 1;
+			return {
+				end: cursor + 1,
+				literals,
+				selfClosing: content[previous] === "/"
+			};
+		}
+		cursor += 1;
+	}
+}
+function findGenericMdxJsxLiteralRanges(content, protectedRanges) {
+	const ranges = [];
+	let cursor = 0;
+	while (cursor < content.length) {
+		const index = content.indexOf("<", cursor);
+		if (index === -1) break;
+		if (isEscapedAt(content, index) || isInsideRange(index, protectedRanges)) {
+			cursor = index + 1;
+			continue;
+		}
+		const tag = readGenericMdxJsxTag(content, index);
+		if (!tag) {
+			cursor = index + 1;
+			continue;
+		}
+		ranges.push(...tag.literals);
+		cursor = tag.end;
+	}
+	return ranges;
+}
+function findDelimiterExclusionRanges(content) {
+	const markdownLiterals = findMarkdownLiteralRanges(content);
+	const fences = findFenceRanges(content);
+	const frontmatter = findLeadingFrontmatterRange(content);
+	const literalBlocks = mergeProtectedRanges([
+		...markdownLiterals,
+		...fences,
+		...frontmatter ? [frontmatter] : []
+	]);
+	const inlineCode = findInlineCodeRanges(content, literalBlocks);
+	const markdownLinks = findMarkdownLinkDestinationRanges(content, literalBlocks);
+	const nonModuleRanges = mergeProtectedRanges([
+		...literalBlocks,
+		...inlineCode,
+		...markdownLinks
+	]);
+	const moduleRanges = findMdxModuleRanges(content, nonModuleRanges);
+	const nonExpressionRanges = mergeProtectedRanges([...nonModuleRanges, ...moduleRanges]);
+	const expressionLiterals = findMdxExpressionLiteralRanges(content, nonExpressionRanges);
+	const nonJsxRanges = mergeProtectedRanges([...nonExpressionRanges, ...expressionLiterals]);
+	return mergeProtectedRanges([...nonJsxRanges, ...findGenericMdxJsxLiteralRanges(content, nonJsxRanges)]);
+}
+function findProtectedRanges(content) {
+	const baseExcludedRanges = findDelimiterExclusionRanges(content);
+	const svelteDirectives = findSvelteDirectiveRanges(content, baseExcludedRanges);
+	const excludedRanges = mergeProtectedRanges([...baseExcludedRanges, ...svelteDirectives]);
+	const htmlLiterals = findHtmlLiteralRanges(content, excludedRanges);
+	return mergeProtectedRanges([...excludedRanges, ...htmlLiterals]);
+}
+function normalizeProjectedWhitespace(content) {
+	const protectedRanges = findProtectedRanges(content);
+	return content.replace(/\n{3,}/g, (newlines, offset) => {
+		const end = offset + newlines.length;
+		return protectedRanges.some((range) => range.start < end && range.end > offset) ? newlines : "\n\n";
+	}).trim();
+}
+/** Find audience declarations that cannot be projected consistently at build time. */
+function findDocsAudienceMdxIssues(content) {
+	const issues = [];
+	for (const tag of findDocsAudienceMdxTags(content)) {
+		if (tag.closing) continue;
+		const { attributes } = tag;
+		const hasOnlyAttribute = tag.hasOnlyAttribute ?? /(?:^|\s)only\s*=/.test(attributes);
+		const hasSpreadAttribute = tag.hasSpreadAttribute ?? /\{\s*\.\.\./.test(attributes);
+		if ((tag.name === "Agent" || tag.name === "Human") && hasOnlyAttribute) {
+			const shorthandAudience = tag.name === "Agent" ? "agent" : "human";
+			issues.push({
+				code: tag.name === "Agent" ? "ignored-agent-only" : "ignored-human-only",
+				index: tag.index,
+				message: `<${tag.name}> is always ${shorthandAudience}-only, so its \`only\` prop is ignored. Use <Audience only="${shorthandAudience}"> when you need the explicit form.`
+			});
+			continue;
+		}
+		if (tag.name !== "Audience") continue;
+		if (hasSpreadAttribute) {
+			issues.push({
+				code: "dynamic-only",
+				index: tag.index,
+				message: "Audience spread props cannot be projected consistently. Remove the spread and use the static literal `only=\"human\"` or `only=\"agent\"`."
+			});
+			continue;
+		}
+		if (tag.only) continue;
+		if (!hasOnlyAttribute) {
+			issues.push({
+				code: "missing-only",
+				index: tag.index,
+				message: "<Audience> requires the static literal `only=\"human\"` or `only=\"agent\"`."
+			});
+			continue;
+		}
+		const dynamicOnly = tag.onlyKind === "dynamic" || /(?:^|\s)only\s*=\s*\{/.test(attributes);
+		issues.push({
+			code: dynamicOnly ? "dynamic-only" : "invalid-only",
+			index: tag.index,
+			message: dynamicOnly ? "Dynamic Audience.only expressions cannot be projected consistently. Use the static literal `only=\"human\"` or `only=\"agent\"`." : "Audience.only must be the static literal `\"human\"` or `\"agent\"`."
+		});
+	}
+	return issues;
+}
+/**
+* Resolve MDX into its human or agent projection.
+*
+* `<Agent>` is shorthand for `<Audience only="agent">`, while `<Human>` is
+* shorthand for `<Audience only="human">`. Unknown `Audience.only` values are
+* treated as shared content so an authoring typo never silently deletes content.
+* These primitives shape content for each surface; they are not an access-control boundary.
+*/
+function resolveDocsAudienceMdxContent(content, audience) {
+	const scopes = [];
+	let output = "";
+	let cursor = 0;
+	let resolvedTag = false;
+	for (const tag of findDocsAudienceMdxTags(content)) {
+		const activeScope = scopes.at(-1);
+		if (tag.closing && activeScope?.name !== tag.name) continue;
+		resolvedTag = true;
+		const visibleBeforeTag = isAudienceVisible(scopes, audience);
+		if (visibleBeforeTag) output += content.slice(cursor, tag.index);
+		cursor = tag.end;
+		if (tag.closing) {
+			if (tag.expression && visibleBeforeTag) output += "</>";
+			scopes.pop();
+			continue;
+		}
+		if (tag.selfClosing) {
+			if (tag.expression && visibleBeforeTag) output += tag.jsxChild ? "{null}" : "null";
+			continue;
+		}
+		scopes.push({
+			name: tag.name,
+			only: tag.only
+		});
+		if (tag.expression && visibleBeforeTag) output += isAudienceVisible(scopes, audience) ? "<>" : tag.jsxChild ? "{null}" : "null";
+	}
+	if (isAudienceVisible(scopes, audience)) output += content.slice(cursor);
+	return resolvedTag ? normalizeProjectedWhitespace(output) : content;
+}
+/** Backwards-compatible name retained for existing integrations. */
+function resolveDocsAgentMdxContent(content, audience) {
+	return resolveDocsAudienceMdxContent(content, audience);
+}
+
+//#endregion
+//#region src/agent.ts
+const DEFAULT_DOCS_API_ROUTE = "/api/docs";
+const DEFAULT_DOCS_CONFIG_FORMAT = "docs-config-map.v1";
+const DEFAULT_DOCS_CONFIG_ROUTE = `${DEFAULT_DOCS_API_ROUTE}?format=config`;
+const DEFAULT_DOCS_DIAGNOSTICS_FORMAT = "docs-diagnostics.v1";
+const DEFAULT_DOCS_DIAGNOSTICS_ROUTE = `${DEFAULT_DOCS_API_ROUTE}?format=diagnostics`;
+const DEFAULT_OPENAPI_SCHEMA_ROUTE = `${DEFAULT_DOCS_API_ROUTE}?format=openapi`;
+const DEFAULT_AGENT_SPEC_ROUTE = "/api/docs/agent/spec";
+const DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE = "/.well-known/agent";
+const DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE = "/.well-known/agent.json";
+const DEFAULT_LLMS_TXT_ROUTE = "/llms.txt";
+const DEFAULT_LLMS_FULL_TXT_ROUTE = "/llms-full.txt";
+const DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms.txt";
+const DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms-full.txt";
+const DEFAULT_LLMS_TXT_MAX_CHARS = 5e4;
+const DEFAULT_SKILL_MD_ROUTE = "/skill.md";
+const DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE = "/.well-known/skill.md";
+const DEFAULT_AGENTS_MD_ROUTE = "/AGENTS.md";
+const DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENTS.md";
+const DEFAULT_AGENT_MD_ROUTE = "/AGENT.md";
+const DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENT.md";
+const DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE = "/robots.txt";
+const DEFAULT_AGENT_FEEDBACK_ROUTE = "/api/docs/agent/feedback";
+const DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		task: {
+			type: "string",
+			description: "Short description of what the agent was trying to do."
+		},
+		understanding: {
+			type: "string",
+			description: "How well the docs supported the task, e.g. \"partial\" or \"clear\"."
+		},
+		outcome: {
+			type: "string",
+			description: "What happened after reading the docs, e.g. \"implemented\" or \"blocked\"."
+		},
+		confidence: {
+			type: "number",
+			minimum: 0,
+			maximum: 1,
+			description: "Confidence score from 0 to 1."
+		},
+		neededCodeReading: {
+			type: "boolean",
+			description: "Whether the agent still needed to inspect repository code."
+		},
+		missingContext: {
+			type: "array",
+			items: { type: "string" },
+			description: "Important details the docs did not provide clearly enough."
+		},
+		docIssues: {
+			type: "array",
+			items: { type: "string" },
+			description: "Specific documentation problems encountered during the task."
+		},
+		suggestedImprovement: {
+			type: "string",
+			description: "Concrete suggestion for improving the docs page or examples."
+		}
+	},
+	required: ["task", "outcome"]
+};
+const DEFAULT_DOCS_DIAGNOSTICS_MCP_TOOLS = {
+	listDocs: true,
+	listPages: true,
+	readPage: true,
+	listTasks: true,
+	readTask: true,
+	searchDocs: true,
+	getNavigation: true,
+	getCodeExamples: true,
+	getConfigSchema: true,
+	getContext: true
+};
+const DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER = "Signature-Agent";
+const DOCS_AI_AGENT_USER_AGENT_PATTERNS = [
+	"claudebot",
+	"claude-searchbot",
+	"claude-user",
+	"anthropic-ai",
+	"claude-web",
+	"chatgpt",
+	"gptbot",
+	"oai-searchbot",
+	"openai",
+	"gemini",
+	"bard",
+	"google-cloudvertexbot",
+	"google-extended",
+	"meta-externalagent",
+	"meta-externalfetcher",
+	"meta-webindexer",
+	"perplexity",
+	"youbot",
+	"you.com",
+	"deepseekbot",
+	"cursor",
+	"github-copilot",
+	"codeium",
+	"tabnine",
+	"sourcegraph",
+	"cohere-ai",
+	"bytespider",
+	"amazonbot",
+	"ai2bot",
+	"diffbot",
+	"omgili",
+	"omgilibot"
+];
+const DOCS_TRADITIONAL_BOT_USER_AGENT_PATTERNS = [
+	"googlebot",
+	"bingbot",
+	"yandexbot",
+	"baiduspider",
+	"duckduckbot",
+	"slurp",
+	"msnbot",
+	"facebot",
+	"twitterbot",
+	"linkedinbot",
+	"whatsapp",
+	"telegrambot",
+	"pingdom",
+	"uptimerobot",
+	"newrelic",
+	"datadog",
+	"statuspage",
+	"site24x7",
+	"applebot"
+];
+const DOCS_BOT_LIKE_USER_AGENT_PATTERN = /bot|agent|fetch|crawl|spider|search/i;
+const DOCS_BOT_LIKE_USER_AGENT_TERMS = [
+	"bot",
+	"agent",
+	"fetch",
+	"crawl",
+	"spider",
+	"search"
+];
+const DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN = buildDocsUserAgentHeaderPattern(DOCS_AI_AGENT_USER_AGENT_PATTERNS);
+const DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN = buildDocsUserAgentHeaderPattern(DOCS_TRADITIONAL_BOT_USER_AGENT_PATTERNS);
+const DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN = buildDocsUserAgentHeaderPattern(DOCS_BOT_LIKE_USER_AGENT_TERMS);
+const DOCS_LLMS_TXT_DIRECTIVE_LINE = "LLM index: /llms.txt";
+const DOCS_MCP_SERVICE_SUBDOMAIN_LABELS = new Set([
+	"api",
+	"developer",
+	"developers",
+	"dev",
+	"docs",
+	"help",
+	"mcp",
+	"reference"
+]);
+const COMMON_SECOND_LEVEL_PUBLIC_SUFFIX_LABELS = new Set([
+	"ac",
+	"co",
+	"com",
+	"edu",
+	"go",
+	"gov",
+	"mil",
+	"ne",
+	"net",
+	"or",
+	"org"
+]);
+const DOCS_CONFIG_MAP_TOP_LEVEL_KEYS = [
+	"entry",
+	"docsPath",
+	"contentDir",
+	"i18n",
+	"staticExport",
+	"theme",
+	"analytics",
+	"telemetry",
+	"cloud",
+	"observability",
+	"github",
+	"nav",
+	"themeToggle",
+	"breadcrumb",
+	"sidebar",
+	"components",
+	"onCopyClick",
+	"codeBlocks",
+	"feedback",
+	"mcp",
+	"icons",
+	"pageActions",
+	"search",
+	"lastUpdated",
+	"readingTime",
+	"ai",
+	"ordering",
+	"llmsTxt",
+	"sitemap",
+	"robots",
+	"changelog",
+	"apiReference",
+	"agent",
+	"review",
+	"metadata",
+	"og"
+];
+function normalizeDocsPathSegment(value) {
+	return value.replace(/^\/+|\/+$/g, "");
+}
+function normalizeDocsUrlPath(value) {
+	const normalized = value.replace(/\/+/g, "/");
+	if (normalized === "/") return normalized;
+	return normalized.replace(/\/+$/, "");
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDocsConfigRequest(url) {
+	return url.searchParams.get("format")?.trim() === "config";
+}
+function isDocsDiagnosticsRequest(url) {
+	return url.searchParams.get("format")?.trim() === "diagnostics";
+}
+/** Prefer an explicitly configured API route; otherwise infer a query-form route from the request. */
+function resolveDocsRequestApiRoute(url, configuredApiRoute) {
+	const configured = configuredApiRoute?.trim();
+	if (configured) return resolveDocsDiscoveryApiRoute(configured);
+	const fallback = resolveDocsDiscoveryApiRoute();
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	const hasPublicRepresentationSuffix = /\.(?:md|txt|xml)$/i.test(pathname);
+	if (pathname.startsWith("/.well-known/") || hasPublicRepresentationSuffix) return fallback;
+	return Boolean(url.searchParams.get("format")?.trim()) || url.searchParams.get("agent")?.trim() === "spec" || url.searchParams.has("query") || url.searchParams.get("feedback")?.trim() === "agent" ? resolveDocsDiscoveryApiRoute(pathname) : fallback;
+}
+function buildDocsConfigMap(config, options = {}) {
+	const pointers = {};
+	const values = serializeDocsConfigMapValue(pickDocsConfigMapValues(config), [], /* @__PURE__ */ new WeakSet(), pointers);
+	const mappedValues = isPlainObject(values) ? values : {};
+	const language = containsDocsConfigKind(mappedValues, "jsx") ? "tsx" : "ts";
+	return {
+		schemaVersion: 1,
+		format: DEFAULT_DOCS_CONFIG_FORMAT,
+		source: {
+			file: options.file ?? (language === "tsx" ? "docs.config.tsx" : "docs.config.ts"),
+			language
+		},
+		serialization: {
+			mode: "json-safe",
+			redacted: "Scalar values under secret-like keys such as apiKey, token, secret, password, authorization, and credential are redacted unless the key ends with Env.",
+			nonSerializable: "described"
+		},
+		values: mappedValues,
+		pointers
+	};
+}
+function buildDocsDiagnostics(config, options = {}) {
+	const input = config;
+	const entry = normalizeDocsPathSegment(stringConfigValue(input.entry) ?? options.entry ?? "docs");
+	const docsRoute = routeFromConfigPath(stringConfigValue(input.docsPath) ?? entry);
+	const cloud = isPlainObject(input.cloud) ? input.cloud : void 0;
+	const apiRoute = resolveDocsDiscoveryApiRoute(options.apiRoute ?? stringConfigValue(cloud?.apiRoute));
+	const apiQueryRoute = (query) => `${apiRoute}?${query}`;
+	const staticExport = input.staticExport === true;
+	const i18n = options.i18n ?? null;
+	const localesEnabled = Boolean(i18n?.locales.length);
+	const search = resolveDocsDiagnosticsSearch(input.search, staticExport);
+	const ai = resolveDocsDiagnosticsAi(input.ai, staticExport);
+	const llms = resolveDocsDiagnosticsLlms(input.llmsTxt);
+	const apiCatalog = resolveDocsDiagnosticsApiCatalog(input.llmsTxt, staticExport, options.apiCatalog);
+	const sitemapConfig = resolveDocsSitemapConfig(input.sitemap);
+	const robotsEnabled = isRobotsDiscoveryEnabled(input.robots);
+	const openapiConfig = resolveDocsOpenApiDiscoveryConfig(options.openapi ?? input.apiReference);
+	const openapiUrl = resolveDocsOpenApiDiscoveryUrl(openapiConfig, apiRoute);
+	const apiReferenceRoute = resolveDocsDiagnosticsApiReferenceRoute(input.apiReference);
+	const mcp = options.mcp ?? resolveDocsDiagnosticsMcp(input.mcp);
+	const feedback = options.feedback ?? resolveDocsAgentFeedbackConfig(input.feedback);
+	const agentFeedbackEnabled = feedback.enabled === true;
+	const agentFeedbackRoute = feedback.route ?? DEFAULT_AGENT_FEEDBACK_ROUTE;
+	const agentFeedbackSchemaRoute = feedback.schemaRoute ?? `${agentFeedbackRoute}/schema`;
+	const humanFeedback = isDocsDiagnosticsHumanFeedbackEnabled(input.feedback);
+	const warnings = [];
+	const errors = [];
+	if (staticExport) warnings.push({
+		severity: "warning",
+		code: "static-export-runtime-api",
+		path: "/staticExport",
+		message: `staticExport is enabled; runtime API-backed capabilities at ${apiRoute} are unavailable in production static export builds.`
+	});
+	if (staticExport && ai.configured) errors.push({
+		severity: "error",
+		code: "ai-static-export",
+		path: "/ai/enabled",
+		message: `Ask AI requires the runtime ${apiRoute} POST handler and will not run in static export builds.`
+	});
+	if (ai.enabled && !search.enabled) warnings.push({
+		severity: "warning",
+		code: "ai-without-search",
+		path: "/ai",
+		message: "Ask AI is enabled while docs search is disabled, so retrieval context may be unavailable."
+	});
+	const adapter = options.adapter?.trim() || null;
+	if (adapter && adapter !== "next") {
+		if (!stringConfigValue(input.contentDir)) warnings.push({
+			severity: "warning",
+			code: "missing-content-dir",
+			path: "/contentDir",
+			message: `${adapter} docs usually need contentDir so the server can find markdown content.`
+		});
+		if (!isPlainObject(input.nav)) warnings.push({
+			severity: "warning",
+			code: "missing-nav",
+			path: "/nav",
+			message: `${adapter} docs usually need nav.title and nav.url for sidebar branding and root navigation.`
+		});
+	}
+	validateDocsDiagnosticsSearchConfig(input.search, errors);
+	return {
+		schemaVersion: 1,
+		format: DEFAULT_DOCS_DIAGNOSTICS_FORMAT,
+		ok: errors.length === 0,
+		adapter,
+		routes: {
+			docs: docsRoute,
+			api: apiRoute,
+			config: apiQueryRoute("format=config"),
+			diagnostics: apiQueryRoute("format=diagnostics"),
+			agentSpec: apiRoute === DEFAULT_DOCS_API_ROUTE ? DEFAULT_AGENT_SPEC_ROUTE : apiQueryRoute("agent=spec"),
+			apiCatalog: apiCatalog.enabled ? DEFAULT_API_CATALOG_ROUTE : null,
+			agentSkillsIndex: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+			agentSkillsArtifact: DEFAULT_AGENT_SKILLS_ROUTE_PATTERN,
+			agents: apiQueryRoute("format=agents"),
+			skill: apiQueryRoute("format=skill"),
+			search: search.enabled ? apiQueryRoute("query={query}") : null,
+			agentSearch: search.enabled ? apiQueryRoute("query={query}&audience=agent") : null,
+			askAi: ai.enabled ? apiRoute : null,
+			mcp: mcp.enabled ? mcp.route : null,
+			llmsTxt: llms.enabled ? DEFAULT_LLMS_TXT_ROUTE : null,
+			llmsFullTxt: llms.enabled ? DEFAULT_LLMS_FULL_TXT_ROUTE : null,
+			sitemapXml: sitemapConfig.enabled && sitemapConfig.xml.enabled ? sitemapConfig.xml.route : null,
+			sitemapMarkdown: sitemapConfig.enabled && sitemapConfig.markdown.enabled ? sitemapConfig.markdown.route : null,
+			robots: robotsEnabled ? DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE : null,
+			openapi: openapiConfig.enabled ? openapiUrl ?? apiQueryRoute("format=openapi") : null,
+			apiReference: openapiConfig.enabled ? apiReferenceRoute : null
+		},
+		features: {
+			staticExport: { status: staticExport ? "enabled" : "disabled" },
+			config: {
+				status: "enabled",
+				route: apiQueryRoute("format=config")
+			},
+			diagnostics: {
+				status: "enabled",
+				route: apiQueryRoute("format=diagnostics")
+			},
+			apiCatalog: {
+				status: apiCatalog.enabled ? "enabled" : "disabled",
+				reason: apiCatalog.reason,
+				route: apiCatalog.enabled ? DEFAULT_API_CATALOG_ROUTE : null,
+				transport: "GET/HEAD"
+			},
+			search: {
+				status: search.enabled ? "enabled" : "disabled",
+				reason: search.reason,
+				route: search.enabled ? apiQueryRoute("query={query}") : null,
+				routes: {
+					human: search.enabled ? apiQueryRoute("query={query}") : null,
+					agent: search.enabled ? apiQueryRoute("query={query}&audience=agent") : null
+				},
+				agentEndpoint: search.enabled ? apiQueryRoute("query={query}&audience=agent") : null,
+				audienceParam: "audience",
+				defaultAudience: "human",
+				supportedAudiences: ["human", "agent"],
+				provider: search.provider,
+				transport: "GET"
+			},
+			ai: {
+				status: ai.enabled ? "enabled" : "disabled",
+				reason: ai.reason,
+				route: ai.enabled ? apiRoute : null,
+				mode: ai.mode,
+				transport: "POST"
+			},
+			mcp: {
+				status: mcp.enabled ? "enabled" : "disabled",
+				route: mcp.enabled ? mcp.route : null,
+				transport: "GET/POST",
+				tools: mcp.tools
+			},
+			feedback: {
+				status: agentFeedbackEnabled || humanFeedback ? "enabled" : "disabled",
+				human: humanFeedback,
+				agent: agentFeedbackEnabled,
+				routes: {
+					agentSubmit: agentFeedbackEnabled ? agentFeedbackRoute : null,
+					agentSchema: agentFeedbackEnabled ? agentFeedbackSchemaRoute : null
+				}
+			},
+			llmsTxt: {
+				status: llms.enabled ? "enabled" : "disabled",
+				reason: llms.reason,
+				routes: {
+					txt: llms.enabled ? DEFAULT_LLMS_TXT_ROUTE : null,
+					full: llms.enabled ? DEFAULT_LLMS_FULL_TXT_ROUTE : null,
+					wellKnownTxt: llms.enabled ? DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE : null,
+					wellKnownFull: llms.enabled ? DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE : null
+				}
+			},
+			sitemap: {
+				status: sitemapConfig.enabled ? "enabled" : "disabled",
+				routes: {
+					xml: sitemapConfig.enabled && sitemapConfig.xml.enabled ? sitemapConfig.xml.route : null,
+					markdown: sitemapConfig.enabled && sitemapConfig.markdown.enabled ? sitemapConfig.markdown.route : null,
+					docsMarkdown: sitemapConfig.enabled && sitemapConfig.markdown.enabled ? sitemapConfig.markdown.docsRoute ?? null : null,
+					wellKnownMarkdown: sitemapConfig.enabled && sitemapConfig.markdown.enabled ? sitemapConfig.markdown.wellKnownRoute : null
+				}
+			},
+			robots: {
+				status: robotsEnabled ? "enabled" : "disabled",
+				route: robotsEnabled ? DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE : null
+			},
+			apiReference: {
+				status: openapiConfig.enabled ? "enabled" : "disabled",
+				route: openapiConfig.enabled ? apiReferenceRoute : null,
+				routes: { openapi: openapiConfig.enabled ? openapiUrl ?? apiQueryRoute("format=openapi") : null },
+				provider: openapiConfig.source
+			},
+			agents: {
+				status: "enabled",
+				routes: {
+					default: DEFAULT_AGENTS_MD_ROUTE,
+					wellKnown: DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE,
+					api: apiQueryRoute("format=agents")
+				}
+			},
+			skills: {
+				status: "enabled",
+				transport: "GET/HEAD",
+				routes: {
+					default: DEFAULT_SKILL_MD_ROUTE,
+					wellKnown: DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE,
+					api: apiQueryRoute("format=skill"),
+					index: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+					artifact: DEFAULT_AGENT_SKILLS_ROUTE_PATTERN
+				}
+			},
+			locales: {
+				status: localesEnabled ? "enabled" : "disabled",
+				provider: localesEnabled ? "query-param" : void 0
+			}
+		},
+		warnings,
+		errors
+	};
+}
+function pickDocsConfigMapValues(config) {
+	const output = {};
+	for (const key of DOCS_CONFIG_MAP_TOP_LEVEL_KEYS) if (Object.prototype.hasOwnProperty.call(config, key)) output[key] = config[key];
+	return output;
+}
+function serializeDocsConfigMapValue(value, path, seen, pointers, depth = 0) {
+	const key = path.at(-1) ?? "";
+	const pointerPath = toDocsConfigJsonPointer(path);
+	const setPointer = (kind) => {
+		if (path.length > 0) pointers[pointerPath] = {
+			path: toDocsConfigDotPath(path),
+			kind
+		};
+	};
+	if (value === void 0) return void 0;
+	if (shouldRedactDocsConfigKey(key) && value !== null && typeof value !== "object") {
+		setPointer("secret");
+		return {
+			$kind: "secret",
+			value: "[redacted]"
+		};
+	}
+	if (value === null || typeof value === "string" || typeof value === "boolean") {
+		setPointer(typeof value);
+		return value;
+	}
+	if (typeof value === "number") {
+		setPointer("number");
+		return Number.isFinite(value) ? value : String(value);
+	}
+	if (typeof value === "bigint") {
+		setPointer("bigint");
+		return {
+			$kind: "bigint",
+			value: value.toString()
+		};
+	}
+	if (typeof value === "symbol") {
+		setPointer("symbol");
+		return {
+			$kind: "symbol",
+			value: String(value)
+		};
+	}
+	if (typeof value === "function") {
+		setPointer("function");
+		return {
+			$kind: "function",
+			name: getDocsConfigFunctionName(value)
+		};
+	}
+	if (value instanceof Date) {
+		setPointer("date");
+		return {
+			$kind: "date",
+			value: value.toISOString()
+		};
+	}
+	if (value instanceof URL) {
+		setPointer("url");
+		return value.toString();
+	}
+	if (depth >= 10) {
+		setPointer("truncated");
+		return {
+			$kind: "truncated",
+			reason: "Exceeded max depth of 10."
+		};
+	}
+	if (Array.isArray(value)) {
+		setPointer("array");
+		return value.map((entry, index) => serializeDocsConfigMapValue(entry, [...path, String(index)], seen, pointers, depth + 1)).filter((entry) => entry !== void 0);
+	}
+	if (isDocsConfigReactElement(value)) {
+		setPointer("jsx");
+		return {
+			$kind: "jsx",
+			component: getDocsConfigReactElementName(value)
+		};
+	}
+	if (seen.has(value)) {
+		setPointer("circular");
+		return { $kind: "circular" };
+	}
+	seen.add(value);
+	const output = {};
+	for (const [childKey, childValue] of Object.entries(value)) {
+		const serialized = serializeDocsConfigMapValue(childValue, [...path, childKey], seen, pointers, depth + 1);
+		if (serialized !== void 0) output[childKey] = serialized;
+	}
+	seen.delete(value);
+	if (path.length === 1 && path[0] === "theme") {
+		setPointer("theme");
+		return {
+			$kind: "theme",
+			...output
+		};
+	}
+	setPointer("object");
+	return output;
+}
+function shouldRedactDocsConfigKey(key) {
+	const normalized = key.replace(/[-_]/g, "").toLowerCase();
+	if (!normalized || normalized === "env" || normalized.endsWith("env")) return false;
+	return normalized.includes("apikey") || normalized.includes("token") || normalized.includes("secret") || normalized.includes("password") || normalized.includes("authorization") || normalized.includes("credential");
+}
+function isDocsConfigReactElement(value) {
+	if (!isPlainObject(value) || !("$$typeof" in value)) return false;
+	return String(value.$$typeof).includes("react.");
+}
+function getDocsConfigReactElementName(value) {
+	const type = value.type;
+	if (typeof type === "string") return type;
+	if (typeof type === "function") return getDocsConfigFunctionName(type);
+	if (isPlainObject(type)) {
+		const displayName = type.displayName;
+		if (typeof displayName === "string") return displayName;
+		const render = type.render;
+		if (typeof render === "function") return getDocsConfigFunctionName(render);
+	}
+	return "unknown";
+}
+function getDocsConfigFunctionName(value) {
+	const displayName = value.displayName;
+	return typeof displayName === "string" ? displayName : value.name || "anonymous";
+}
+function toDocsConfigJsonPointer(path) {
+	return path.length === 0 ? "" : `/${path.map(escapeDocsConfigJsonPointerPart).join("/")}`;
+}
+function escapeDocsConfigJsonPointerPart(value) {
+	return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function toDocsConfigDotPath(path) {
+	return path.map((part, index) => /^\d+$/.test(part) ? `[${part}]` : index === 0 ? part : `.${part}`).join("");
+}
+function containsDocsConfigKind(value, kind) {
+	if (!isPlainObject(value)) {
+		if (!Array.isArray(value)) return false;
+	}
+	if (Array.isArray(value)) return value.some((entry) => containsDocsConfigKind(entry, kind));
+	if (value["$kind"] === kind) return true;
+	return Object.values(value).some((entry) => containsDocsConfigKind(entry, kind));
+}
+function stringConfigValue(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function routeFromConfigPath(value) {
+	const normalized = normalizeDocsPathSegment(value);
+	return normalized ? `/${normalized}` : "/";
+}
+function resolveDocsDiagnosticsSearch(search, staticExport) {
+	const provider = isPlainObject(search) ? stringConfigValue(search.provider) : "simple";
+	const configured = search !== false && !(isPlainObject(search) && search.enabled === false);
+	if (staticExport) return {
+		enabled: false,
+		configured,
+		provider,
+		reason: "static-export"
+	};
+	if (!configured) return {
+		enabled: false,
+		configured,
+		provider,
+		reason: "configured-disabled"
+	};
+	return {
+		enabled: true,
+		configured,
+		provider
+	};
+}
+function resolveDocsDiagnosticsAi(ai, staticExport) {
+	const configured = isPlainObject(ai) && ai.enabled === true;
+	const mode = isPlainObject(ai) ? stringConfigValue(ai.mode) : void 0;
+	if (!configured) return {
+		enabled: false,
+		configured,
+		reason: "not-configured"
+	};
+	if (staticExport) return {
+		enabled: false,
+		configured,
+		mode,
+		reason: "static-export"
+	};
+	return {
+		enabled: true,
+		configured,
+		mode
+	};
+}
+function resolveDocsDiagnosticsLlms(llmsTxt) {
+	return llmsTxt !== false && !(isPlainObject(llmsTxt) && llmsTxt.enabled === false) ? { enabled: true } : {
+		enabled: false,
+		reason: "configured-disabled"
+	};
+}
+function resolveDocsDiagnosticsApiCatalog(llmsTxt, staticExport, explicit) {
+	if (staticExport) return {
+		enabled: false,
+		reason: "static-export"
+	};
+	if (explicit !== void 0) return explicit ? { enabled: true } : {
+		enabled: false,
+		reason: "configured-disabled"
+	};
+	if (isPlainObject(llmsTxt) && llmsTxt.apiCatalog === false) return {
+		enabled: false,
+		reason: "llms-txt-api-catalog-disabled"
+	};
+	return { enabled: true };
+}
+function resolveDocsDiagnosticsMcp(mcp) {
+	const config = isPlainObject(mcp) ? mcp : {};
+	const tools = isPlainObject(config.tools) ? config.tools : {};
+	return {
+		enabled: typeof mcp === "boolean" ? mcp : config.enabled !== false,
+		route: normalizeDocsDiagnosticsMcpRoute(config.route),
+		name: stringConfigValue(config.name) ?? "Documentation",
+		version: stringConfigValue(config.version) ?? "0.0.0",
+		tools: {
+			...DEFAULT_DOCS_DIAGNOSTICS_MCP_TOOLS,
+			listDocs: tools.listDocs !== false,
+			listPages: tools.listPages !== false,
+			readPage: tools.readPage !== false,
+			listTasks: tools.listTasks !== false,
+			readTask: tools.readTask !== false,
+			searchDocs: tools.searchDocs !== false,
+			getNavigation: tools.getNavigation !== false,
+			getCodeExamples: tools.getCodeExamples !== false,
+			getConfigSchema: tools.getConfigSchema !== false,
+			getContext: tools.getContext !== false
+		}
+	};
+}
+function normalizeDocsDiagnosticsMcpRoute(route) {
+	const value = stringConfigValue(route);
+	if (!value) return DEFAULT_MCP_ROUTE;
+	const normalized = `/${value}`.replace(/\/+/g, "/");
+	return normalized !== "/" ? normalized.replace(/\/+$/, "") : DEFAULT_MCP_ROUTE;
+}
+function isDocsDiagnosticsHumanFeedbackEnabled(feedback) {
+	return feedback === true || isPlainObject(feedback) && feedback.enabled !== false;
+}
+function resolveDocsDiagnosticsApiReferenceRoute(apiReference) {
+	if (isPlainObject(apiReference)) return routeFromConfigPath(stringConfigValue(apiReference.path) ?? "api-reference");
+	return "/api-reference";
+}
+function validateDocsDiagnosticsSearchConfig(search, errors) {
+	if (!isPlainObject(search) || search.enabled === false) return;
+	const provider = stringConfigValue(search.provider) ?? "simple";
+	const requireString = (key) => {
+		if (!stringConfigValue(search[key])) errors.push({
+			severity: "error",
+			code: `missing-search-${key.replace(/[A-Z]/g, (value) => `-${value.toLowerCase()}`)}`,
+			path: `/search/${key}`,
+			message: `Search provider "${provider}" requires search.${key}.`
+		});
+	};
+	if (provider === "algolia") {
+		requireString("appId");
+		requireString("indexName");
+		requireString("searchApiKey");
+	}
+	if (provider === "typesense") {
+		requireString("baseUrl");
+		requireString("collection");
+		requireString("apiKey");
+	}
+	if (provider === "mcp") requireString("endpoint");
+	if (provider === "custom" && !("adapter" in search)) errors.push({
+		severity: "error",
+		code: "missing-search-adapter",
+		path: "/search/adapter",
+		message: "Search provider \"custom\" requires search.adapter."
+	});
+}
+function normalizeDocsAgentFeedbackRoute(route, fallback = DEFAULT_AGENT_FEEDBACK_ROUTE) {
+	if (!route || route.trim().length === 0) return fallback;
+	const normalized = `/${route}`.replace(/\/+/g, "/");
+	return normalized !== "/" ? normalized.replace(/\/+$/, "") : fallback;
+}
+function buildDocsAgentFeedbackSchema(payloadSchema) {
+	return {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			context: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					page: { type: "string" },
+					url: { type: "string" },
+					slug: { type: "string" },
+					locale: { type: "string" },
+					source: { type: "string" }
+				}
+			},
+			payload: payloadSchema
+		},
+		required: ["payload"]
+	};
+}
+function resolveDocsAgentFeedbackConfig(feedback) {
+	const route = normalizeDocsAgentFeedbackRoute();
+	const enabled = {
+		enabled: true,
+		route,
+		schemaRoute: `${route}/schema`,
+		payloadSchema: DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA,
+		schema: buildDocsAgentFeedbackSchema(DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA)
+	};
+	const disabled = {
+		enabled: false,
+		route,
+		schemaRoute: `${route}/schema`,
+		payloadSchema: DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA,
+		schema: buildDocsAgentFeedbackSchema(DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA)
+	};
+	if (feedback === false) return disabled;
+	if (!feedback || feedback === true || typeof feedback !== "object") return enabled;
+	const agent = feedback.agent;
+	if (agent === false) return disabled;
+	if (!agent) return enabled;
+	if (agent === true) return enabled;
+	const resolvedRoute = normalizeDocsAgentFeedbackRoute(agent.route, route);
+	const resolvedSchemaRoute = normalizeDocsAgentFeedbackRoute(agent.schemaRoute, `${resolvedRoute}/schema`);
+	const payloadSchema = agent.schema ?? DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA;
+	return {
+		enabled: agent.enabled !== false,
+		route: resolvedRoute,
+		schemaRoute: resolvedSchemaRoute,
+		payloadSchema,
+		schema: buildDocsAgentFeedbackSchema(payloadSchema),
+		onFeedback: agent.onFeedback
+	};
+}
+function resolveDocsAgentFeedbackRequest(url, feedback) {
+	if (!feedback.enabled) return null;
+	const feedbackMode = url.searchParams.get("feedback")?.trim();
+	const schemaMode = url.searchParams.get("schema")?.trim();
+	if (feedbackMode === "agent") return { kind: schemaMode === "1" || schemaMode === "true" ? "schema" : "submit" };
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	if (pathname === feedback.schemaRoute) return { kind: "schema" };
+	if (pathname === feedback.route) return { kind: "submit" };
+	return null;
+}
+function normalizeDocsAgentFeedbackContext(value) {
+	if (!isPlainObject(value)) return void 0;
+	const context = {};
+	if (typeof value.page === "string") context.page = value.page;
+	if (typeof value.url === "string") context.url = value.url;
+	if (typeof value.slug === "string") context.slug = value.slug;
+	if (typeof value.locale === "string") context.locale = value.locale;
+	if (typeof value.source === "string") context.source = value.source;
+	return Object.keys(context).length > 0 ? context : void 0;
+}
+async function parseDocsAgentFeedbackData(request) {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return {
+			ok: false,
+			response: Response.json({ error: "Agent feedback body must be valid JSON" }, { status: 400 })
+		};
+	}
+	if (!isPlainObject(body)) return {
+		ok: false,
+		response: Response.json({ error: "Agent feedback body must be an object" }, { status: 400 })
+	};
+	if (!isPlainObject(body.payload)) return {
+		ok: false,
+		response: Response.json({ error: "Agent feedback body must include a payload object" }, { status: 400 })
+	};
+	return {
+		ok: true,
+		data: {
+			context: normalizeDocsAgentFeedbackContext(body.context),
+			payload: body.payload
+		}
+	};
+}
+function validateDocsAgentFeedbackPayload(value, schema, valuePath = "payload") {
+	const schemaType = typeof schema.type === "string" ? schema.type : void 0;
+	if (Array.isArray(schema.enum) && !schema.enum.some((entry) => Object.is(entry, value))) return `${valuePath} must be one of the configured enum values`;
+	if (schemaType === "object" || !schemaType && (schema.properties || schema.required)) {
+		if (!isPlainObject(value)) return `${valuePath} must be an object`;
+		const properties = isPlainObject(schema.properties) ? schema.properties : {};
+		const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+		for (const key of required) if (!(key in value)) return `${valuePath}.${key} is required`;
+		if (schema.additionalProperties === false) {
+			for (const key of Object.keys(value)) if (!(key in properties)) return `${valuePath}.${key} is not allowed`;
+		}
+		for (const [key, propertySchema] of Object.entries(properties)) {
+			if (!(key in value)) continue;
+			if (!isPlainObject(propertySchema)) continue;
+			const error = validateDocsAgentFeedbackPayload(value[key], propertySchema, `${valuePath}.${key}`);
+			if (error) return error;
+		}
+		return;
+	}
+	if (schemaType === "array") {
+		if (!Array.isArray(value)) return `${valuePath} must be an array`;
+		if (!isPlainObject(schema.items)) return void 0;
+		for (const [index, item] of value.entries()) {
+			const error = validateDocsAgentFeedbackPayload(item, schema.items, `${valuePath}[${index}]`);
+			if (error) return error;
+		}
+		return;
+	}
+	if (schemaType === "string") {
+		if (typeof value !== "string") return `${valuePath} must be a string`;
+		if (typeof schema.minLength === "number" && value.length < schema.minLength) return `${valuePath} must be at least ${schema.minLength} characters`;
+		if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return `${valuePath} must be at most ${schema.maxLength} characters`;
+		return;
+	}
+	if (schemaType === "number") {
+		if (typeof value !== "number" || !Number.isFinite(value)) return `${valuePath} must be a number`;
+		if (typeof schema.minimum === "number" && value < schema.minimum) return `${valuePath} must be >= ${schema.minimum}`;
+		if (typeof schema.maximum === "number" && value > schema.maximum) return `${valuePath} must be <= ${schema.maximum}`;
+		return;
+	}
+	if (schemaType === "boolean") {
+		if (typeof value !== "boolean") return `${valuePath} must be a boolean`;
+		return;
+	}
+}
+function toDocsMarkdownUrl(url, options = {}) {
+	const [withoutHash, hash = ""] = url.split("#", 2);
+	const [pathname, query = ""] = withoutHash.split("?", 2);
+	const normalizedPath = normalizeDocsUrlPath(pathname || "/");
+	const markdownPath = normalizedPath.endsWith(".md") ? normalizedPath : `${normalizedPath}.md`;
+	const params = new URLSearchParams(query);
+	if (options.locale && !params.has("lang")) params.set("lang", options.locale);
+	const search = params.toString();
+	return `${markdownPath}${search ? `?${search}` : ""}${hash ? `#${hash}` : ""}`;
+}
+function resolveDocsMarkdownCanonicalUrl({ origin, entry = "docs", requestedPath, locale }) {
+	const pathname = normalizeRequestedMarkdownPath(normalizeDocsPathSegment(entry) || "docs", requestedPath);
+	const canonicalUrl = new URL(pathname, origin);
+	if (locale) canonicalUrl.searchParams.set("lang", locale);
+	return canonicalUrl.toString();
+}
+function getDocsMarkdownCanonicalLinkHeader(options) {
+	return `<${resolveDocsMarkdownCanonicalUrl(options)}>; rel="canonical"`;
+}
+function joinDocsPublicRoute(prefix, suffix) {
+	const normalizedPrefix = normalizeDocsUrlPath(`/${normalizeDocsPathSegment(prefix)}`);
+	const normalizedSuffix = `/${normalizeDocsPathSegment(suffix)}`;
+	if (normalizedPrefix === "/") return normalizedSuffix;
+	return normalizeDocsUrlPath(`${normalizedPrefix}${normalizedSuffix}`);
+}
+function normalizeLlmsTxtMatch(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "/";
+	return normalizeDocsUrlPath(trimmed.startsWith("/") ? trimmed : `/${trimmed}`);
+}
+function llmsTxtMatchPrefix(value) {
+	const normalized = normalizeLlmsTxtMatch(value);
+	const wildcardIndex = normalized.indexOf("*");
+	return normalizeDocsUrlPath((wildcardIndex >= 0 ? normalized.slice(0, wildcardIndex) : normalized).replace(/\/+$/, "") || "/");
+}
+function deriveLlmsTxtSectionRoute(match) {
+	return joinDocsPublicRoute(llmsTxtMatchPrefix(match[0] ?? "/"), "llms.txt");
+}
+function deriveLlmsTxtSectionFullRoute(route) {
+	const normalized = normalizeDocsUrlPath(route);
+	if (normalized.endsWith("/llms.txt")) return `${normalized.slice(0, -9)}/llms-full.txt`;
+	return joinDocsPublicRoute(normalized, "llms-full.txt");
+}
+function resolveDocsBaseLlmsTxtRoute(basePath) {
+	if (!basePath) return null;
+	return joinDocsPublicRoute(normalizeDocsPathSegment(basePath) || "docs", "llms.txt");
+}
+function resolveDocsBaseLlmsFullTxtRoute(basePath) {
+	const route = resolveDocsBaseLlmsTxtRoute(basePath);
+	return route ? deriveLlmsTxtSectionFullRoute(route) : null;
+}
+function normalizeLlmsTxtMaxChars(value, fallback) {
+	const mode = value?.mode ?? fallback?.mode ?? "warn";
+	const chars = value?.chars ?? fallback?.chars ?? DEFAULT_LLMS_TXT_MAX_CHARS;
+	return {
+		mode,
+		chars: Number.isFinite(chars) && chars > 0 ? Math.floor(chars) : DEFAULT_LLMS_TXT_MAX_CHARS
+	};
+}
+function resolveDocsLlmsTxtSections(llms) {
+	if (!llms || typeof llms !== "object" || !Array.isArray(llms.sections)) return [];
+	const rootMaxChars = normalizeLlmsTxtMaxChars(llms.maxChars);
+	return llms.sections.flatMap((section) => {
+		const match = (Array.isArray(section.match) ? section.match : [section.match]).map(normalizeLlmsTxtMatch).filter(Boolean);
+		if (match.length === 0) return [];
+		const route = deriveLlmsTxtSectionRoute(match);
+		const resolved = {
+			title: section.title,
+			match,
+			route,
+			fullRoute: deriveLlmsTxtSectionFullRoute(route),
+			maxChars: normalizeLlmsTxtMaxChars(section.maxChars, rootMaxChars)
+		};
+		if (section.description !== void 0) resolved.description = section.description;
+		return [resolved];
+	});
+}
+function matchesDocsLlmsTxtSection(pageUrl, section) {
+	const pathname = normalizeDocsUrlPath(pageUrl.split(/[?#]/, 1)[0] || "/");
+	return section.match.some((pattern) => {
+		const normalized = normalizeLlmsTxtMatch(pattern);
+		if (normalized.endsWith("/**")) {
+			const prefix = normalizeDocsUrlPath(normalized.slice(0, -3) || "/");
+			if (prefix === "/") return true;
+			return pathname === prefix || pathname.startsWith(`${prefix}/`);
+		}
+		if (normalized.endsWith("/*")) {
+			const prefix = normalizeDocsUrlPath(normalized.slice(0, -2) || "/");
+			if (prefix === "/") {
+				const directChild = pathname.slice(1);
+				return directChild.length > 0 && !directChild.includes("/");
+			}
+			if (!pathname.startsWith(`${prefix}/`)) return false;
+			return !pathname.slice(prefix.length + 1).includes("/");
+		}
+		return pathname === normalized;
+	});
+}
+function resolveDocsLlmsTxtRequest(url, llms, basePath, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	const apiRoute = resolveDocsDiscoveryApiRoute(options.apiRoute);
+	const sections = resolveDocsLlmsTxtSections(llms);
+	for (const section of sections) {
+		if (pathname === section.route) return {
+			format: "llms",
+			section
+		};
+		if (pathname === section.fullRoute) return {
+			format: "llms-full",
+			section
+		};
+	}
+	const format = url.searchParams.get("format");
+	if (pathname === apiRoute && (format === "llms" || format === "llms-full")) {
+		const sectionRoute = url.searchParams.get("section")?.trim();
+		const normalizedSectionRoute = sectionRoute ? normalizeDocsUrlPath(sectionRoute) : void 0;
+		return {
+			format,
+			section: normalizedSectionRoute ? sections.find((candidate) => candidate.route === normalizedSectionRoute || candidate.fullRoute === normalizedSectionRoute) ?? {
+				title: "",
+				match: [],
+				route: normalizedSectionRoute,
+				fullRoute: normalizedSectionRoute,
+				maxChars: normalizeLlmsTxtMaxChars(void 0)
+			} : void 0
+		};
+	}
+	if (pathname === DEFAULT_LLMS_TXT_ROUTE || pathname === DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE) return { format: "llms" };
+	if (pathname === resolveDocsBaseLlmsTxtRoute(basePath)) return { format: "llms" };
+	if (pathname === DEFAULT_LLMS_FULL_TXT_ROUTE || pathname === DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE) return { format: "llms-full" };
+	if (pathname === resolveDocsBaseLlmsFullTxtRoute(basePath)) return { format: "llms-full" };
+	return null;
+}
+function renderLlmsTxtPageList(pages, baseUrl) {
+	let content = "";
+	for (const page of pages) {
+		content += `- [${page.title}](${baseUrl}${page.markdownUrl ?? toDocsMarkdownUrl(page.url)})`;
+		if (page.description) content += `: ${page.description}`;
+		content += "\n";
+	}
+	return content;
+}
+function resolveDocsResourceUrl(baseUrl, url) {
+	if (/^[a-z][a-z0-9+.-]*:/i.test(url)) return url;
+	return `${baseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+}
+function renderLlmsFullTxtPages(pages, baseUrl) {
+	let content = "";
+	for (const page of pages) {
+		content += `## ${page.title}\n\n`;
+		content += `URL: ${baseUrl}${page.url}\n\n`;
+		if (page.description) content += `${page.description}\n\n`;
+		const agentContent = page.agentRawContent ?? page.agentFallbackRawContent ?? page.agentContent ?? page.agentFallbackContent ?? page.rawContent ?? page.content;
+		content += `${agentContent}\n\n---\n\n`;
+	}
+	return content;
+}
+function renderDocsLlmsTxt(pages, options = {}) {
+	const siteTitle = options.siteTitle ?? "Documentation";
+	const siteDescription = options.siteDescription;
+	const baseUrl = options.baseUrl ?? "";
+	const maxChars = normalizeLlmsTxtMaxChars(options.maxChars);
+	const apiCatalogEnabled = options.apiCatalog ?? true;
+	const sections = resolveDocsLlmsTxtSections(options);
+	const openapi = resolveDocsOpenApiDiscoveryConfig(options.openapi);
+	const openapiUrl = resolveDocsOpenApiDiscoveryUrl(openapi, resolveDocsDiscoveryApiRoute(options.apiRoute));
+	const matchedPageUrls = /* @__PURE__ */ new Set();
+	const generatedSections = sections.map((section) => {
+		const sectionPages = pages.filter((page) => matchesDocsLlmsTxtSection(page.url, section));
+		for (const page of sectionPages) matchedPageUrls.add(normalizeDocsUrlPath(page.url));
+		let llmsTxt = `# ${siteTitle} - ${section.title}\n\n`;
+		if (section.description) llmsTxt += `> ${section.description}\n\n`;
+		else if (siteDescription) llmsTxt += `> ${siteDescription}\n\n`;
+		llmsTxt += "## Pages\n\n";
+		llmsTxt += renderLlmsTxtPageList(sectionPages, baseUrl);
+		let llmsFullTxt = `# ${siteTitle} - ${section.title}\n\n`;
+		if (section.description) llmsFullTxt += `> ${section.description}\n\n`;
+		else if (siteDescription) llmsFullTxt += `> ${siteDescription}\n\n`;
+		llmsFullTxt += renderLlmsFullTxtPages(sectionPages, baseUrl);
+		return {
+			...section,
+			llmsTxt,
+			llmsFullTxt
+		};
+	});
+	const rootPages = generatedSections.length > 0 ? pages.filter((page) => !matchedPageUrls.has(normalizeDocsUrlPath(page.url))) : pages;
+	let llmsTxt = `# ${siteTitle}\n\n`;
+	if (siteDescription) llmsTxt += `> ${siteDescription}\n\n`;
+	llmsTxt += "## Agent Discovery\n\n";
+	llmsTxt += `- [Agent manifest](${resolveDocsResourceUrl(baseUrl, DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE)}): Farming Labs discovery manifest\n`;
+	if (apiCatalogEnabled) llmsTxt += `- [API catalog](${resolveDocsResourceUrl(baseUrl, DEFAULT_API_CATALOG_ROUTE)}): RFC 9727 API catalog\n`;
+	llmsTxt += `- [Agent Skills index](${resolveDocsResourceUrl(baseUrl, DEFAULT_AGENT_SKILLS_INDEX_ROUTE)}): Hashed Agent Skills discovery\n\n`;
+	if (generatedSections.length > 0) {
+		llmsTxt += "## Sections\n\n";
+		for (const section of generatedSections) {
+			llmsTxt += `- [${section.title}](${baseUrl}${section.route})`;
+			if (section.description) llmsTxt += `: ${section.description}`;
+			llmsTxt += "\n";
+		}
+		llmsTxt += "\n";
+	}
+	if (openapi.enabled && openapiUrl) {
+		llmsTxt += "## API Schemas\n\n";
+		llmsTxt += `- [OpenAPI schema](${resolveDocsResourceUrl(baseUrl, openapiUrl)}): Machine-readable API schema for tool use and API clients`;
+		if (openapi.apiReferencePath) llmsTxt += `; rendered API reference at ${resolveDocsResourceUrl(baseUrl, openapi.apiReferencePath)}`;
+		llmsTxt += "\n\n";
+	}
+	if (rootPages.length > 0 || generatedSections.length === 0) {
+		llmsTxt += "## Pages\n\n";
+		llmsTxt += renderLlmsTxtPageList(rootPages, baseUrl);
+	}
+	let llmsFullTxt = `# ${siteTitle}\n\n`;
+	if (siteDescription) llmsFullTxt += `> ${siteDescription}\n\n`;
+	llmsFullTxt += renderLlmsFullTxtPages(pages, baseUrl);
+	return {
+		llmsTxt,
+		llmsFullTxt,
+		maxChars,
+		sections: generatedSections
+	};
+}
+function selectDocsLlmsTxtContent(content, request) {
+	if (request.section) {
+		const section = content.sections.find((candidate) => candidate.route === request.section?.route);
+		if (!section) return null;
+		return {
+			content: request.format === "llms-full" ? section.llmsFullTxt : section.llmsTxt,
+			label: request.format === "llms-full" ? section.fullRoute : section.route,
+			maxChars: request.format === "llms-full" ? {
+				...section.maxChars,
+				mode: "off"
+			} : section.maxChars
+		};
+	}
+	return {
+		content: request.format === "llms-full" ? content.llmsFullTxt : content.llmsTxt,
+		label: request.format === "llms-full" ? DEFAULT_LLMS_FULL_TXT_ROUTE : DEFAULT_LLMS_TXT_ROUTE,
+		maxChars: request.format === "llms-full" ? {
+			...content.maxChars,
+			mode: "off"
+		} : content.maxChars
+	};
+}
+function getDocsLlmsTxtMaxCharsIssue(label, content, maxChars) {
+	if (maxChars.mode === "off" || content.length <= maxChars.chars) return null;
+	return {
+		mode: maxChars.mode,
+		chars: maxChars.chars,
+		actual: content.length,
+		label,
+		message: `${label} is ${content.length.toLocaleString()} chars, above the configured ${maxChars.chars.toLocaleString()} char llms.txt budget.`
+	};
+}
+function resolveDocsStandardsOrigin(preferred, fallback) {
+	for (const candidate of [preferred, fallback]) {
+		if (!candidate) continue;
+		try {
+			const url = new URL(candidate);
+			if (url.protocol === "http:" || url.protocol === "https:") return url.origin;
+		} catch {}
+	}
+	return new URL(fallback).origin;
+}
+/** Build and serve standards-based discovery without replacing the custom agent manifest. */
+async function createDocsStandardsDiscoveryResponse({ request, preferredSkillDocument, fallbackSkillDocument, origin, entry = "docs", docsPath, apiCatalog: explicitApiCatalog, apiRoute, i18n: _i18n, search: _search, mcp, feedback, llms, sitemap, robots, openapi, markdown: _markdown, publishedSkills, agentCard }) {
+	const url = new URL(request.url);
+	const resolvedApiRoute = resolveDocsDiscoveryApiRoute(apiRoute);
+	if (!isDocsStandardsDiscoveryRequest(url, { apiRoute: resolvedApiRoute })) return null;
+	const normalizedEntry = normalizeDocsPathSegment(entry) || "docs";
+	const normalizedDocsPath = normalizeDocsPathSegment(docsPath ?? normalizedEntry);
+	const apiCatalogEnabled = explicitApiCatalog ?? llms?.apiCatalog ?? true;
+	const catalogOrigin = resolveDocsStandardsOrigin(llms?.baseUrl, origin || url.origin);
+	const sitemapConfig = resolveDocsSitemapConfig(sitemap, { baseUrl: llms?.baseUrl });
+	const openapiConfig = resolveDocsOpenApiDiscoveryConfig(openapi);
+	const openapiUrl = resolveDocsOpenApiDiscoveryUrl(openapiConfig, resolvedApiRoute);
+	const feedbackRoute = feedback?.route ?? DEFAULT_AGENT_FEEDBACK_ROUTE;
+	const feedbackSchemaRoute = feedback?.schemaRoute ?? `${feedbackRoute}/schema`;
+	const llmsEnabled = llms?.enabled ?? true;
+	const robotsEnabled = isRobotsDiscoveryEnabled(robots);
+	const llmsSections = resolveDocsLlmsTxtSections(llms);
+	const llmsRoutes = llmsEnabled ? [
+		DEFAULT_LLMS_TXT_ROUTE,
+		DEFAULT_LLMS_FULL_TXT_ROUTE,
+		DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE,
+		DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE,
+		...llmsSections.flatMap((section) => [section.route, section.fullRoute])
+	] : [];
+	const sitemapRoutes = sitemapConfig.enabled ? [...sitemapConfig.xml.enabled ? [sitemapConfig.xml.route] : [], ...sitemapConfig.markdown.enabled ? [
+		sitemapConfig.markdown.route,
+		sitemapConfig.markdown.docsRoute,
+		sitemapConfig.markdown.wellKnownRoute
+	].filter((route) => Boolean(route)) : []] : [];
+	const protectedResourceMetadataRoutes = mcp.enabled && mcp.security?.authenticate && mcp.security.protectedResource ? getDocsMcpProtectedResourceMetadataRoutes(mcp.route) : [];
+	return createDocsStandardsResponse({
+		request,
+		apiCatalogEnabled,
+		apiRoute: resolvedApiRoute,
+		preferredSkillDocument,
+		fallbackSkillDocument,
+		publishedSkills,
+		agentCard,
+		apiCatalog: apiCatalogEnabled ? buildDocsApiCatalog({
+			origin: catalogOrigin,
+			docsRoute: normalizedDocsPath ? `/${normalizedDocsPath}` : "/",
+			apiRoute: resolvedApiRoute,
+			configRoute: `${resolvedApiRoute}?format=config`,
+			diagnosticsRoute: `${resolvedApiRoute}?format=diagnostics`,
+			agentManifestRoute: DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE,
+			agentSkillsIndexRoute: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+			legacySkillsIndexRoute: DEFAULT_LEGACY_SKILLS_INDEX_ROUTE,
+			agentCardRoute: agentCard ? DEFAULT_A2A_AGENT_CARD_ROUTE : null,
+			agentsRoute: DEFAULT_AGENTS_MD_ROUTE,
+			skillRoute: DEFAULT_SKILL_MD_ROUTE,
+			markdownRootRoute: `/${normalizedEntry}.md`,
+			llmsRoutes,
+			sitemapRoutes,
+			robotsRoute: robotsEnabled ? DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE : null,
+			mcpRoute: mcp.enabled ? mcp.route : null,
+			protectedResourceMetadataRoutes,
+			feedbackRoutes: feedback?.enabled ? [feedbackRoute, feedbackSchemaRoute] : [],
+			openapiRoute: openapiConfig.enabled ? openapiUrl ?? `${resolvedApiRoute}?format=openapi` : null,
+			apiReferenceRoute: openapiConfig.enabled && openapiConfig.apiReferencePath ? openapiConfig.apiReferencePath : null
+		}) : void 0
+	});
+}
+function isDocsAgentDiscoveryRequest(url, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	if (pathname === resolveDocsDiscoveryApiRoute(options.apiRoute) && url.searchParams.get("agent")?.trim() === "spec") return true;
+	return pathname === DEFAULT_AGENT_SPEC_ROUTE || pathname === DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE || pathname === DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE;
+}
+function buildDocsMcpEndpointCandidates(baseUrl, routes = [DEFAULT_MCP_PUBLIC_ROUTE, DEFAULT_MCP_WELL_KNOWN_ROUTE], options = {}) {
+	const includeOriginFallback = options.includeOriginFallback !== false;
+	const includeRootDomainFallback = options.includeRootDomainFallback !== false;
+	const includeMcpSubdomainFallback = options.includeMcpSubdomainFallback !== false;
+	const base = new URL(baseUrl);
+	const primaryOrigin = base.origin;
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const addCandidate = (candidateBaseUrl, route) => {
+		const resolved = resolveDocsMcpCandidateUrl(candidateBaseUrl, route);
+		if (seen.has(resolved.url)) return;
+		seen.add(resolved.url);
+		candidates.push({
+			...resolved,
+			label: formatDocsMcpCandidateLabel(resolved.url, primaryOrigin)
+		});
+	};
+	for (const route of routes) addCandidate(baseUrl, route);
+	const originBaseUrl = primaryOrigin;
+	if (includeOriginFallback && originBaseUrl !== baseUrl.replace(/\/+$/, "")) for (const route of routes) addCandidate(originBaseUrl, route);
+	if (includeRootDomainFallback) for (const rootDomainBaseUrl of toDocsRootDomainBaseUrls(base)) for (const route of routes) addCandidate(rootDomainBaseUrl, route);
+	if (includeMcpSubdomainFallback) for (const mcpBaseUrl of toDocsMcpSubdomainBaseUrls(base)) {
+		addCandidate(mcpBaseUrl, DEFAULT_MCP_PUBLIC_ROUTE);
+		addCandidate(mcpBaseUrl, "/");
+	}
+	return candidates;
+}
+function resolveDocsMcpCandidateUrl(baseUrl, route) {
+	if (/^https?:\/\//i.test(route)) {
+		const parsed = new URL(route);
+		const path = `${parsed.pathname || "/"}${parsed.search}`;
+		return {
+			baseUrl: parsed.origin,
+			route: path,
+			url: parsed.toString()
+		};
+	}
+	const base = new URL(baseUrl);
+	const basePath = base.pathname.replace(/\/+$/, "");
+	const routePath = route.startsWith("/") ? route : `/${route}`;
+	const parsed = new URL(`${basePath}${routePath}`, base.origin);
+	return {
+		baseUrl: parsed.origin,
+		route: `${parsed.pathname}${parsed.search}`,
+		url: parsed.toString()
+	};
+}
+function formatDocsMcpCandidateLabel(url, primaryOrigin) {
+	const parsed = new URL(url);
+	const path = `${parsed.pathname}${parsed.search}`;
+	return parsed.origin === primaryOrigin ? path : `${parsed.origin}${path}`;
+}
+function toDocsMcpSubdomainBaseUrls(base) {
+	return getDocsMcpRootDomainCandidates(base.hostname).map((rootDomain) => `${base.protocol}//mcp.${rootDomain}${base.port ? `:${base.port}` : ""}`);
+}
+function toDocsRootDomainBaseUrls(base) {
+	return getDocsMcpRootDomainCandidates(base.hostname).map((rootDomain) => `${base.protocol}//${rootDomain}${base.port ? `:${base.port}` : ""}`);
+}
+function getDocsMcpRootDomainCandidates(hostname) {
+	const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+	if (!normalized || !normalized.includes(".") || isDocsIpHostname(normalized)) return [];
+	const labels = normalized.split(".").filter(Boolean);
+	if (labels.length < 2) return [];
+	const candidates = [];
+	const addCandidate = (candidateLabels) => {
+		if (candidateLabels.length < 2) return;
+		const candidate = candidateLabels.join(".");
+		if (!candidates.includes(candidate)) candidates.push(candidate);
+	};
+	if (labels.length >= 3 && DOCS_MCP_SERVICE_SUBDOMAIN_LABELS.has(labels[0] ?? "")) addCandidate(labels.slice(1));
+	const tld = labels.at(-1) ?? "";
+	const secondLevel = labels.at(-2) ?? "";
+	if (labels.length >= 3 && tld.length === 2 && COMMON_SECOND_LEVEL_PUBLIC_SUFFIX_LABELS.has(secondLevel)) addCandidate(labels.slice(-3));
+	else addCandidate(labels.slice(-2));
+	return candidates;
+}
+function isDocsIpHostname(hostname) {
+	return /^(\d{1,3}\.){3}\d{1,3}$/.test(hostname) || hostname.includes(":");
+}
+function isDocsSkillRequest(url, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	if (pathname === DEFAULT_SKILL_MD_ROUTE || pathname === DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE) return true;
+	return pathname === resolveDocsDiscoveryApiRoute(options.apiRoute) && resolveDocsSkillFormat(url) === "skill";
+}
+function resolveDocsSkillFormat(url) {
+	return url.searchParams.get("format")?.trim() === "skill" ? "skill" : null;
+}
+function isDocsAgentsPath(pathname) {
+	return pathname === DEFAULT_AGENTS_MD_ROUTE || pathname === DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE || pathname === DEFAULT_AGENT_MD_ROUTE || pathname === DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE;
+}
+function isDocsAgentsRequest(url, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	if (isDocsAgentsPath(pathname)) return true;
+	return pathname === resolveDocsDiscoveryApiRoute(options.apiRoute) && resolveDocsAgentsFormat(url) === "agents";
+}
+function resolveDocsAgentsFormat(url) {
+	return url.searchParams.get("format")?.trim() === "agents" ? "agents" : null;
+}
+function isDocsPublicGetRequest(entry, url, request, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	const apiRoute = resolveDocsDiscoveryApiRoute(options.apiRoute);
+	if (pathname === apiRoute || pathname === DEFAULT_MCP_ROUTE) return false;
+	return isDocsStandardsDiscoveryRequest(url, { apiRoute }) || isDocsAgentDiscoveryRequest(url, { apiRoute }) || isDocsAgentsRequest(url, { apiRoute }) || isDocsSkillRequest(url, { apiRoute }) || pathname === DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE && isRobotsDiscoveryEnabled(options.robots) || resolveDocsLlmsTxtRequest(url, options.llms, entry, { apiRoute }) !== null || resolveDocsSitemapRequest(url, options.sitemap, { apiRoute }) !== null || resolveDocsMarkdownRequest(entry, url, request, { apiRoute }) !== null;
+}
+function isDocsLlmsTxtPublicRequest(url, llms, basePath, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	const apiRoute = resolveDocsDiscoveryApiRoute(options.apiRoute);
+	return pathname !== apiRoute && resolveDocsLlmsTxtRequest(url, llms, basePath, { apiRoute }) !== null;
+}
+function resolveDocsLlmsTxtFormat(url, basePath, options = {}) {
+	return resolveDocsLlmsTxtRequest(url, void 0, basePath, options)?.format ?? null;
+}
+function resolveDocsMarkdownRequest(entry, url, request, options = {}) {
+	const pathname = normalizeDocsUrlPath(url.pathname);
+	const format = url.searchParams.get("format")?.trim();
+	if (pathname === resolveDocsDiscoveryApiRoute(options.apiRoute) && format === "markdown") return { requestedPath: url.searchParams.get("path")?.trim() ?? "" };
+	const normalizedEntry = `/${normalizeDocsPathSegment(entry) || "docs"}`;
+	if (pathname === `${normalizedEntry}.md`) return { requestedPath: "" };
+	const slugPrefix = `${normalizedEntry}/`;
+	if (pathname.startsWith(slugPrefix) && pathname.endsWith(".md")) return { requestedPath: pathname.slice(slugPrefix.length, -3) };
+	if (acceptsDocsMarkdown(request) || hasDocsMarkdownSignatureAgent(request) || detectDocsMarkdownAgentRequest(request).detected) {
+		if (pathname === normalizedEntry) return { requestedPath: "" };
+		if (pathname.startsWith(slugPrefix)) return { requestedPath: pathname.slice(slugPrefix.length) };
+	}
+	return null;
+}
+function hasDocsMarkdownSignatureAgent(request) {
+	return Boolean(request.headers.get(DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER)?.trim());
+}
+function detectDocsMarkdownAgentRequest(request) {
+	if (hasDocsMarkdownSignatureAgent(request)) return {
+		detected: true,
+		method: "signature_agent"
+	};
+	const userAgent = request.headers.get("user-agent")?.trim().toLowerCase() ?? "";
+	if (!userAgent) return {
+		detected: false,
+		method: null
+	};
+	if (DOCS_AI_AGENT_USER_AGENT_PATTERNS.some((pattern) => userAgent.includes(pattern))) return {
+		detected: true,
+		method: "user_agent"
+	};
+	if (!request.headers.get("sec-fetch-mode") && DOCS_BOT_LIKE_USER_AGENT_PATTERN.test(userAgent)) {
+		if (!DOCS_TRADITIONAL_BOT_USER_AGENT_PATTERNS.some((pattern) => userAgent.includes(pattern))) return {
+			detected: true,
+			method: "heuristic"
+		};
+	}
+	return {
+		detected: false,
+		method: null
+	};
+}
+function getDocsMarkdownVaryHeader(request) {
+	const values = /* @__PURE__ */ new Set();
+	if (acceptsDocsMarkdown(request)) values.add("Accept");
+	if (hasDocsMarkdownSignatureAgent(request)) {
+		values.add("Accept");
+		values.add(DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER);
+	}
+	const agentDetection = detectDocsMarkdownAgentRequest(request);
+	if (agentDetection.detected && agentDetection.method !== "signature_agent") {
+		values.add("User-Agent");
+		if (agentDetection.method === "heuristic") values.add("Sec-Fetch-Mode");
+	}
+	return values.size > 0 ? Array.from(values).join(", ") : null;
+}
+const DOCS_MARKDOWN_RECOVERY_MATCH_LIMIT = 5;
+const DOCS_MARKDOWN_RECOVERY_REDIRECT_CONFIDENCE = .99;
+const DOCS_MARKDOWN_RECOVERY_SLUG_MAX_LENGTH = 256;
+function normalizeDocsRecoveryText(value) {
+	return value.toLowerCase().replace(/\.md$/i, "").replace(/[#?].*$/g, "").replace(/['"`]/g, "").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function normalizeDocsRecoverySlug(entry, value) {
+	const withoutHash = value.split("#", 1)[0] ?? value;
+	const withoutMarkdown = (withoutHash.split("?", 1)[0] ?? withoutHash).replace(/\.md$/i, "");
+	const normalizedPath = normalizeDocsUrlPath(withoutMarkdown.startsWith("/") ? withoutMarkdown : `/${withoutMarkdown}`);
+	const normalizedEntry = `/${normalizeDocsPathSegment(entry) || "docs"}`;
+	if (normalizedPath === normalizedEntry) return "";
+	if (normalizedPath.startsWith(`${normalizedEntry}/`)) return normalizeDocsPathSegment(normalizedPath.slice(normalizedEntry.length + 1));
+	return normalizeDocsPathSegment(normalizedPath);
+}
+function limitDocsRecoverySlug(value) {
+	return value.slice(0, DOCS_MARKDOWN_RECOVERY_SLUG_MAX_LENGTH);
+}
+function tokenizeDocsRecoveryText(value) {
+	return normalizeDocsRecoveryText(value).split(/\s+/).filter((token) => token.length > 1);
+}
+function levenshteinDistance(a, b) {
+	if (a === b) return 0;
+	if (!a) return b.length;
+	if (!b) return a.length;
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	let current = new Array(b.length + 1);
+	for (let i = 1; i <= a.length; i += 1) {
+		current[0] = i;
+		for (let j = 1; j <= b.length; j += 1) {
+			const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+			current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, substitution);
+		}
+		[previous, current] = [current, previous];
+	}
+	return previous[b.length] ?? Math.max(a.length, b.length);
+}
+function normalizedEditSimilarity(a, b) {
+	if (!a || !b) return 0;
+	if (a === b) return 1;
+	const maxLength = Math.max(a.length, b.length);
+	if (maxLength === 0) return 1;
+	return Math.max(0, 1 - levenshteinDistance(a, b) / maxLength);
+}
+function tokenOverlapScore(requestedTokens, candidateTokens) {
+	if (requestedTokens.length === 0 || candidateTokens.length === 0) return 0;
+	const candidates = new Set(candidateTokens);
+	return requestedTokens.filter((token) => candidates.has(token)).length / requestedTokens.length;
+}
+function sameDocsRecoveryParent(a, b) {
+	const aParts = a.split("/").filter(Boolean);
+	const bParts = b.split("/").filter(Boolean);
+	if (aParts.length !== bParts.length || aParts.length === 0) return false;
+	return aParts.slice(0, -1).join("/") === bParts.slice(0, -1).join("/");
+}
+function scoreDocsMarkdownRecoveryMatch({ entry, requestedPath, page }) {
+	const requestedSlug = limitDocsRecoverySlug(normalizeDocsRecoverySlug(entry, requestedPath));
+	const pageSlug = limitDocsRecoverySlug(normalizeDocsRecoverySlug(entry, page.url));
+	const requestedLast = requestedSlug.split("/").filter(Boolean).at(-1) ?? requestedSlug;
+	const pageLast = pageSlug.split("/").filter(Boolean).at(-1) ?? pageSlug;
+	const title = normalizeDocsRecoveryText(page.title);
+	const requestedText = normalizeDocsRecoveryText(requestedSlug.replace(/\//g, " "));
+	const requestedTokens = tokenizeDocsRecoveryText(requestedText);
+	const candidateTokens = tokenizeDocsRecoveryText([
+		pageSlug.replace(/\//g, " "),
+		page.title,
+		page.description ?? ""
+	].join(" "));
+	const pathDistance = levenshteinDistance(requestedSlug, pageSlug);
+	const segmentDistance = levenshteinDistance(requestedLast, pageLast);
+	if (requestedSlug && pageSlug && (sameDocsRecoveryParent(requestedSlug, pageSlug) && segmentDistance <= 1 || pathDistance <= 1)) return .995;
+	const pathSimilarity = normalizedEditSimilarity(requestedSlug, pageSlug);
+	const segmentSimilarity = normalizedEditSimilarity(requestedLast, pageLast);
+	const titleSimilarity = normalizedEditSimilarity(requestedText, title);
+	const overlap = tokenOverlapScore(requestedTokens, candidateTokens);
+	const substringBoost = requestedText && (pageSlug.includes(requestedSlug) || title.includes(requestedText) || requestedText.includes(title)) ? .12 : 0;
+	return Math.min(.98, Math.max(pathSimilarity * .86, segmentSimilarity * .8, titleSimilarity * .72, overlap * .75) + substringBoost);
+}
+function resolveDocsMarkdownRecovery({ entry = "docs", requestedPath, pages = [] }) {
+	const normalizedEntry = normalizeDocsPathSegment(entry) || "docs";
+	const matches = pages.map((page) => ({
+		page,
+		confidence: scoreDocsMarkdownRecoveryMatch({
+			entry: normalizedEntry,
+			requestedPath,
+			page
+		})
+	})).filter((item) => item.confidence >= .35).sort((a, b) => {
+		if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+		return a.page.url.localeCompare(b.page.url);
+	}).slice(0, DOCS_MARKDOWN_RECOVERY_MATCH_LIMIT).map(({ page, confidence }) => ({
+		title: page.title,
+		url: normalizeDocsUrlPath(page.url),
+		markdownUrl: toDocsMarkdownUrl(page.url),
+		description: page.description,
+		confidence
+	}));
+	return {
+		matches,
+		redirect: matches[0] && matches[0].confidence >= DOCS_MARKDOWN_RECOVERY_REDIRECT_CONFIDENCE ? matches[0] : void 0
+	};
+}
+function renderDocsMarkdownSitemapFooter(sitemap) {
+	const sitemapConfig = resolveDocsSitemapConfig(sitemap);
+	const lines = ["## Sitemap", ""];
+	if (sitemapConfig.enabled && sitemapConfig.markdown.enabled) {
+		lines.push(`See the full [sitemap](${sitemapConfig.markdown.route}) for all pages.`);
+		if (sitemapConfig.markdown.docsRoute) lines.push(`Docs-scoped sitemap: [${sitemapConfig.markdown.docsRoute}](${sitemapConfig.markdown.docsRoute}).`);
+		lines.push(`Well-known sitemap: [${sitemapConfig.markdown.wellKnownRoute}](${sitemapConfig.markdown.wellKnownRoute}).`);
+	} else if (sitemapConfig.enabled && sitemapConfig.xml.enabled) lines.push(`See the XML [sitemap](${sitemapConfig.xml.route}) for all pages.`);
+	else lines.push("Sitemap discovery is not enabled for this deployment.");
+	return lines.join("\n");
+}
+function appendDocsMarkdownSitemapFooter(markdown, sitemap) {
+	if (/^##\s+Sitemap\s*$/im.test(markdown)) return markdown;
+	return `${markdown.replace(/\s+$/g, "")}\n\n${renderDocsMarkdownSitemapFooter(sitemap)}\n`;
+}
+function normalizeDocsMarkdownLastUpdated(value) {
+	if (!value) return void 0;
+	const trimmed = value.trim();
+	const dateOnly = trimmed.match(/^\d{4}-\d{2}-\d{2}/)?.[0];
+	if (dateOnly) return dateOnly;
+	const date = new Date(trimmed);
+	if (Number.isNaN(date.getTime())) return void 0;
+	return date.toISOString().slice(0, 10);
+}
+function resolveDocsMarkdownMetadataUrl(value, origin) {
+	if (!origin) return value;
+	try {
+		return new URL(value, origin).toString();
+	} catch {
+		return value;
+	}
+}
+function renderDocsMarkdownFrontmatter({ title, description, canonicalUrl, markdownUrl, lastUpdated, agent }) {
+	return [
+		"---",
+		`title: ${toYamlString(title)}`,
+		...description ? [`description: ${toYamlString(description)}`] : [],
+		`canonical_url: ${toYamlString(canonicalUrl)}`,
+		`markdown_url: ${toYamlString(markdownUrl)}`,
+		...lastUpdated ? [`last_updated: ${toYamlString(lastUpdated)}`] : [],
+		...renderPageAgentFrontmatterYamlLines(agent),
+		"---"
+	].join("\n");
+}
+function hasDocsMarkdownFrontmatter(markdown) {
+	return /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/.test(markdown);
+}
+function prependDocsMarkdownFrontmatter(markdown, metadata) {
+	if (hasDocsMarkdownFrontmatter(markdown)) return markdown;
+	return `${renderDocsMarkdownFrontmatter(metadata)}\n\n${markdown.replace(/^\r?\n+/, "")}`;
+}
+function resolveDocsMarkdownPageMetadata(page, options) {
+	return {
+		title: page.title,
+		description: page.description,
+		canonicalUrl: resolveDocsMarkdownMetadataUrl(page.url, options?.origin),
+		markdownUrl: resolveDocsMarkdownMetadataUrl(page.markdownUrl ?? toDocsMarkdownUrl(page.url), options?.origin),
+		lastUpdated: normalizeDocsMarkdownLastUpdated(page.lastmod ?? page.lastModified),
+		agent: page.agent
+	};
+}
+function renderDocsMarkdownNotFound({ entry = "docs", apiRoute, requestedPath, origin, pages, sitemap }) {
+	const normalizedEntry = normalizeDocsPathSegment(entry) || "docs";
+	const resolvedApiRoute = resolveDocsDiscoveryApiRoute(apiRoute);
+	const agentSpecApiRoute = resolvedApiRoute === DEFAULT_DOCS_API_ROUTE ? DEFAULT_AGENT_SPEC_ROUTE : `${resolvedApiRoute}?agent=spec`;
+	const normalizedRequest = normalizeRequestedMarkdownPath(normalizedEntry, requestedPath);
+	const slugPrefix = `/${normalizedEntry}/`;
+	const requestedSlug = normalizedRequest === `/${normalizedEntry}` ? "" : normalizedRequest.slice(slugPrefix.length);
+	const encodedRequestedSlug = requestedSlug.split("/").map(encodeURIComponent).join("/");
+	const requestedMarkdownRoute = toDocsMarkdownUrl(normalizedRequest);
+	const requestedApiRoute = requestedSlug ? `${resolvedApiRoute}?format=markdown&path=${encodedRequestedSlug}` : `${resolvedApiRoute}?format=markdown`;
+	const sitemapConfig = resolveDocsSitemapConfig(sitemap);
+	const recovery = resolveDocsMarkdownRecovery({
+		entry: normalizedEntry,
+		requestedPath,
+		pages
+	});
+	const lines = [
+		"# Docs Page Not Found",
+		"",
+		`Could not find a markdown page for \`${requestedMarkdownRoute}\`.`
+	];
+	if (recovery.matches.length > 0) {
+		lines.push("", "## Closest Matches", "");
+		for (const match of recovery.matches) {
+			const confidence = `${Math.round(match.confidence * 1e3) / 10}%`;
+			lines.push(`- [${match.title}](${match.markdownUrl}) (${confidence} confidence)${match.description ? ` - ${match.description}` : ""}`);
+		}
+	}
+	lines.push("", "## Recovery", "", "- If a closest match looks right, fetch that markdown URL directly.", "- If the match is uncertain, search the docs first and then fetch the smallest page that answers the task.", "- Use the sitemap routes below to browse the full docs index before guessing another slug.", "", "## Discovery Routes", "", "Use these discovery routes to find the right page:", "", `- Agent discovery spec: \`${DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE}\``, `- Agent discovery fallback: \`${DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE}\``, `- Agent discovery API: \`${agentSpecApiRoute}\``, `- API catalog: \`${DEFAULT_API_CATALOG_ROUTE}\``, `- Agent Skills index: \`${DEFAULT_AGENT_SKILLS_INDEX_ROUTE}\``, `- Agent instructions: \`${DEFAULT_AGENTS_MD_ROUTE}\``, `- Agent search endpoint: \`${resolvedApiRoute}?query={query}&audience=agent\``, `- Docs index markdown: \`/${normalizedEntry}.md\``, `- Requested markdown API route: \`${requestedApiRoute}\``);
+	if (sitemapConfig.enabled) {
+		if (sitemapConfig.markdown.enabled) {
+			lines.push(`- Semantic sitemap: \`${sitemapConfig.markdown.route}\``);
+			if (sitemapConfig.markdown.docsRoute) lines.push(`- Docs-scoped sitemap alias: \`${sitemapConfig.markdown.docsRoute}\``);
+			lines.push(`- Semantic sitemap well-known alias: \`${sitemapConfig.markdown.wellKnownRoute}\``);
+		}
+		if (sitemapConfig.xml.enabled) lines.push(`- XML sitemap: \`${sitemapConfig.xml.route}\``);
+	} else lines.push(`- Sitemap discovery, if enabled: \`${DEFAULT_SITEMAP_MD_ROUTE}\`, \`${DEFAULT_SITEMAP_MD_DOCS_ROUTE}\`, \`${DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE}\`, or \`${DEFAULT_SITEMAP_XML_ROUTE}\``);
+	lines.push("", "The agent discovery spec is the safest first step because it lists the active markdown, sitemap, robots, search, MCP, and feedback routes for this deployment.");
+	return appendDocsMarkdownSitemapFooter(prependDocsMarkdownFrontmatter(lines.join("\n"), {
+		title: "Docs Page Not Found",
+		description: `Could not find a markdown page for ${requestedMarkdownRoute}.`,
+		canonicalUrl: resolveDocsMarkdownMetadataUrl(normalizedRequest, origin),
+		markdownUrl: resolveDocsMarkdownMetadataUrl(requestedMarkdownRoute, origin)
+	}), sitemap);
+}
+function hashDocsMarkdownRepresentation(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function createDocsMarkdownEtag(document) {
+	return `W/"${document.length.toString(16)}-${hashDocsMarkdownRepresentation(document)}"`;
+}
+function normalizeDocsMarkdownEtag(value) {
+	return value.trim().replace(/^W\//i, "");
+}
+function requestMatchesDocsMarkdownEtag(request, etag) {
+	const header = request.headers.get("if-none-match");
+	if (!header) return false;
+	if (header.trim() === "*") return true;
+	const expected = normalizeDocsMarkdownEtag(etag);
+	return header.split(",").some((candidate) => normalizeDocsMarkdownEtag(candidate) === expected);
+}
+function resolveDocsMarkdownHttpDate(value) {
+	if (!value) return void 0;
+	if (typeof value === "string" && !/(?:T|\s)\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?/.test(value.trim())) return;
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) return void 0;
+	return date.toUTCString();
+}
+function extractDocsMarkdownLastModified(document) {
+	const frontmatter = document.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+	if (!frontmatter) return void 0;
+	const raw = frontmatter.match(/^last_updated:\s*(.+?)\s*$/m)?.[1]?.trim();
+	if (!raw) return void 0;
+	if (raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+	return raw;
+}
+function requestHasFreshDocsMarkdownDate(request, lastModified) {
+	if (!lastModified || request.headers.has("if-none-match")) return false;
+	const ifModifiedSince = request.headers.get("if-modified-since");
+	if (!ifModifiedSince) return false;
+	const resourceTime = Date.parse(lastModified);
+	const requestTime = Date.parse(ifModifiedSince);
+	return Number.isFinite(resourceTime) && Number.isFinite(requestTime) && Math.floor(resourceTime / 1e3) <= Math.floor(requestTime / 1e3);
+}
+function resolveDocsMarkdownContentLocation(canonicalUrl) {
+	const url = new URL(canonicalUrl);
+	url.pathname = toDocsMarkdownUrl(url.pathname);
+	return url.toString();
+}
+/** Build one standards-aware Markdown response for every framework adapter. */
+function createDocsMarkdownResponse(options) {
+	const { request, document, entry = "docs", requestedPath, origin = new URL(request.url).origin, pages, sitemap, locale } = options;
+	const canonicalUrl = options.canonicalUrl ?? resolveDocsMarkdownCanonicalUrl({
+		origin,
+		entry,
+		requestedPath,
+		locale
+	});
+	const contentLocation = options.contentLocation ?? resolveDocsMarkdownContentLocation(canonicalUrl);
+	const varyHeader = getDocsMarkdownVaryHeader(request);
+	const sharedHeaders = {
+		"Content-Location": contentLocation,
+		Link: `<${canonicalUrl}>; rel="canonical"`,
+		"X-Robots-Tag": "noindex",
+		...locale ? { "Content-Language": locale } : {},
+		...varyHeader ? { Vary: varyHeader } : {}
+	};
+	if (!document) {
+		const recovery = resolveDocsMarkdownRecovery({
+			entry,
+			requestedPath,
+			pages,
+			sitemap
+		});
+		if (recovery.redirect) return new Response(null, {
+			status: 307,
+			headers: {
+				...sharedHeaders,
+				"Cache-Control": "no-store",
+				Location: new URL(recovery.redirect.markdownUrl, request.url).toString()
+			}
+		});
+		return new Response(renderDocsMarkdownNotFound({
+			entry,
+			apiRoute: options.apiRoute,
+			requestedPath,
+			origin,
+			pages,
+			sitemap
+		}), {
+			status: 404,
+			headers: {
+				...sharedHeaders,
+				"Cache-Control": "no-store",
+				"Content-Type": "text/markdown; charset=utf-8"
+			}
+		});
+	}
+	const etag = createDocsMarkdownEtag(document);
+	const lastModified = resolveDocsMarkdownHttpDate(options.lastModified ?? extractDocsMarkdownLastModified(document));
+	const responseHeaders = {
+		...sharedHeaders,
+		"Cache-Control": options.cacheControl ?? "public, max-age=0, s-maxage=3600",
+		"Content-Type": "text/markdown; charset=utf-8",
+		ETag: etag,
+		...lastModified ? { "Last-Modified": lastModified } : {}
+	};
+	if (requestMatchesDocsMarkdownEtag(request, etag) || requestHasFreshDocsMarkdownDate(request, lastModified)) {
+		const { "Content-Type": _contentType, ...notModifiedHeaders } = responseHeaders;
+		return new Response(null, {
+			status: 304,
+			headers: notModifiedHeaders
+		});
+	}
+	return new Response(document, { headers: responseHeaders });
+}
+function findDocsMarkdownPage(entry, pages, requestedPath) {
+	const normalizedRequest = normalizeRequestedMarkdownPath(entry, requestedPath);
+	for (const page of pages) if (normalizeDocsUrlPath(page.url) === normalizedRequest) return page;
+	const normalizedSlug = normalizeDocsPathSegment(requestedPath.replace(/^\//, "").replace(/\.md$/i, ""));
+	for (const page of pages) if (page.slug !== void 0 && normalizeDocsPathSegment(page.slug) === normalizedSlug) return page;
+	return null;
+}
+function shouldRenderLlmsDirective(options) {
+	if (options?.llms === false) return false;
+	if (options?.llms && typeof options.llms === "object" && options.llms.enabled === false) return false;
+	return true;
+}
+function resolveDocsAgentDocumentContext({ entry = "docs", apiRoute, apiCatalog: explicitApiCatalog, search, mcp, feedback, llms, sitemap, robots, openapi, markdown }) {
+	const feedbackRoute = feedback?.route ?? DEFAULT_AGENT_FEEDBACK_ROUTE;
+	const resolvedApiRoute = resolveDocsDiscoveryApiRoute(apiRoute);
+	const openapiConfig = resolveDocsOpenApiDiscoveryConfig(openapi);
+	return {
+		apiRoute: resolvedApiRoute,
+		normalizedEntry: normalizeDocsPathSegment(entry) || "docs",
+		siteTitle: compactSkillText(llms?.siteTitle ?? "Documentation"),
+		siteDescription: llms?.siteDescription ? compactSkillText(llms.siteDescription) : void 0,
+		llmsEnabled: llms?.enabled ?? true,
+		searchEnabled: isSearchEnabled(search),
+		mcpEnabled: mcp.enabled,
+		feedbackEnabled: feedback?.enabled ?? false,
+		sitemapConfig: resolveDocsSitemapConfig(sitemap),
+		robotsEnabled: isRobotsDiscoveryEnabled(robots),
+		openapiConfig: {
+			...openapiConfig,
+			url: resolveDocsOpenApiDiscoveryUrl(openapiConfig, resolvedApiRoute)
+		},
+		feedbackRoute,
+		feedbackSchemaRoute: feedback?.schemaRoute ?? `${feedbackRoute}/schema`,
+		llmsSections: resolveDocsLlmsTxtSections(llms),
+		markdownAcceptHeader: markdown?.acceptHeader === false ? null : "text/markdown",
+		markdownSignatureAgentHeader: markdown?.signatureAgentHeader === false ? null : DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER,
+		apiCatalogEnabled: explicitApiCatalog ?? llms?.apiCatalog ?? true
+	};
+}
+function appendDocsMarkdownNegotiationStartLines(lines, context, variant) {
+	if (context.markdownAcceptHeader) lines.push(variant === "skill" ? `- You can also request ${context.markdownAcceptHeader} from normal page URLs.` : `- Normal docs pages can return markdown with Accept: ${context.markdownAcceptHeader}.`);
+	if (context.markdownSignatureAgentHeader) lines.push(variant === "skill" ? `- Requests with ${context.markdownSignatureAgentHeader} on normal page URLs receive markdown automatically.` : `- Normal docs pages can also return markdown when ${context.markdownSignatureAgentHeader} is present.`);
+}
+function appendDocsSearchStartLine(lines, context, variant) {
+	if (!context.searchEnabled) return;
+	lines.push(variant === "skill" ? `- Search with ${context.apiRoute}?query={query}&audience=agent when you do not know the page.` : `- Search with ${context.apiRoute}?query={query}&audience=agent when the route is unknown.`);
+}
+function appendDocsOpenApiStartLine(lines, context, variant) {
+	if (!context.openapiConfig.enabled || !context.openapiConfig.url) return;
+	lines.push(variant === "skill" ? `- Fetch ${context.openapiConfig.url} for the machine-readable OpenAPI schema before scraping API reference pages.` : `- Fetch ${context.openapiConfig.url} before scraping API reference pages; prefer schemas over prose.`);
+}
+function appendDocsLlmsStartLines(lines, context, variant) {
+	if (!context.llmsEnabled) return;
+	lines.push(variant === "skill" ? `- Use ${DEFAULT_LLMS_TXT_ROUTE} for a compact docs index.` : `- Use ${DEFAULT_LLMS_TXT_ROUTE} as the compact docs map.`, variant === "skill" ? `- Use ${DEFAULT_LLMS_FULL_TXT_ROUTE} for full markdown context.` : `- Use ${DEFAULT_LLMS_FULL_TXT_ROUTE} when you need the full markdown bundle.`);
+	for (const section of context.llmsSections) lines.push(variant === "skill" ? `- Use ${section.route} for the ${section.title} llms.txt section.` : `- Use ${section.route} for the ${section.title} section map.`);
+}
+function appendDocsSitemapStartLines(lines, context, variant) {
+	if (!context.sitemapConfig.enabled) return;
+	if (variant === "skill") {
+		if (context.sitemapConfig.xml.enabled) lines.push(`- Use ${context.sitemapConfig.xml.route} to check canonical page freshness.`);
+		if (context.sitemapConfig.markdown.enabled) lines.push(`- Use ${context.sitemapConfig.markdown.route} for a semantic docs map.`);
+		return;
+	}
+	if (context.sitemapConfig.markdown.enabled) lines.push(`- Use ${context.sitemapConfig.markdown.route} for a semantic sitemap with sections.`);
+	if (context.sitemapConfig.xml.enabled) lines.push(`- Use ${context.sitemapConfig.xml.route} for canonical URLs and freshness metadata.`);
+}
+function appendDocsRobotsStartLine(lines, context, variant) {
+	if (!context.robotsEnabled) return;
+	lines.push(variant === "skill" ? `- Check ${DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE} for crawler and AI-agent access policy.` : `- Check ${DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE} before crawling broadly.`);
+}
+function appendDocsMcpStartLine(lines, context, variant) {
+	if (!context.mcpEnabled) return;
+	lines.push(variant === "skill" ? `- Use ${DEFAULT_MCP_WELL_KNOWN_ROUTE} or ${DEFAULT_MCP_PUBLIC_ROUTE} for MCP tools when your environment supports MCP.` : `- Use MCP at ${DEFAULT_MCP_PUBLIC_ROUTE} or ${DEFAULT_MCP_WELL_KNOWN_ROUTE} when your environment supports MCP tools.`);
+}
+function appendDocsFeedbackStartLine(lines, context, variant) {
+	if (!context.feedbackEnabled) return;
+	lines.push(variant === "skill" ? `- Read ${context.feedbackSchemaRoute} before posting agent feedback to ${context.feedbackRoute}.` : `- Read ${context.feedbackSchemaRoute} before posting feedback to ${context.feedbackRoute}.`);
+}
+function appendDocsAgentStartHereLines(lines, context, variant) {
+	const agentSpecFallback = context.apiRoute === DEFAULT_DOCS_API_ROUTE ? DEFAULT_AGENT_SPEC_ROUTE : `${context.apiRoute}?agent=spec`;
+	lines.push(variant === "skill" ? `- Fetch ${DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE}; fall back to ${DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE} or ${agentSpecFallback}.` : `- Read ${DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE} first; fall back to ${DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE} or ${agentSpecFallback}.`);
+	if (context.apiCatalogEnabled) lines.push(variant === "skill" ? `- Use ${DEFAULT_API_CATALOG_ROUTE} for standards-based API discovery.` : `- Use ${DEFAULT_API_CATALOG_ROUTE} for RFC 9727 API discovery.`);
+	lines.push(variant === "skill" ? `- Use ${DEFAULT_AGENT_SKILLS_INDEX_ROUTE} for hashed skill discovery.` : `- Use ${DEFAULT_AGENT_SKILLS_INDEX_ROUTE} for integrity-checked skills.`, variant === "skill" ? `- Fetch /${context.normalizedEntry}.md for the root docs page.` : `- Read /${context.normalizedEntry}.md for the root docs page.`, variant === "skill" ? `- Fetch /${context.normalizedEntry}/{slug}.md for page-specific context.` : `- Read /${context.normalizedEntry}/{slug}.md for page-specific context.`);
+	if (variant === "skill") {
+		appendDocsMarkdownNegotiationStartLines(lines, context, variant);
+		appendDocsSearchStartLine(lines, context, variant);
+		appendDocsOpenApiStartLine(lines, context, variant);
+		appendDocsLlmsStartLines(lines, context, variant);
+		appendDocsSitemapStartLines(lines, context, variant);
+		appendDocsRobotsStartLine(lines, context, variant);
+		appendDocsMcpStartLine(lines, context, variant);
+		appendDocsFeedbackStartLine(lines, context, variant);
+		return;
+	}
+	appendDocsLlmsStartLines(lines, context, variant);
+	appendDocsSitemapStartLines(lines, context, variant);
+	appendDocsRobotsStartLine(lines, context, variant);
+	appendDocsSearchStartLine(lines, context, variant);
+	appendDocsOpenApiStartLine(lines, context, variant);
+	appendDocsMcpStartLine(lines, context, variant);
+	appendDocsFeedbackStartLine(lines, context, variant);
+	appendDocsMarkdownNegotiationStartLines(lines, context, variant);
+}
+function appendDocsLlmsRouteLines(lines, context) {
+	if (!context.llmsEnabled) return;
+	lines.push(`- llms.txt: ${DEFAULT_LLMS_TXT_ROUTE}`, `- llms-full.txt: ${DEFAULT_LLMS_FULL_TXT_ROUTE}`, `- llms well-known aliases: ${DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE}, ${DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE}`);
+	for (const section of context.llmsSections) {
+		lines.push(`- ${section.title} llms.txt: ${section.route}`);
+		lines.push(`- ${section.title} llms-full.txt: ${section.fullRoute}`);
+	}
+}
+function appendDocsOpenApiRouteLines(lines, context) {
+	if (!context.openapiConfig.enabled || !context.openapiConfig.url) return;
+	lines.push(`- OpenAPI schema: ${context.openapiConfig.url}`);
+	if (context.openapiConfig.apiReferencePath) lines.push(`- API reference: ${context.openapiConfig.apiReferencePath}`);
+}
+function appendDocsSitemapRouteLines(lines, context) {
+	if (!context.sitemapConfig.enabled) return;
+	if (context.sitemapConfig.xml.enabled) lines.push(`- Sitemap XML: ${context.sitemapConfig.xml.route}`);
+	if (context.sitemapConfig.markdown.enabled) lines.push(`- Sitemap Markdown: ${context.sitemapConfig.markdown.route}`, ...context.sitemapConfig.markdown.docsRoute ? [`- Sitemap docs alias: ${context.sitemapConfig.markdown.docsRoute}`] : [], `- Sitemap well-known alias: ${context.sitemapConfig.markdown.wellKnownRoute}`);
+}
+function appendDocsMcpRouteLines(lines, context) {
+	if (!context.mcpEnabled) return;
+	lines.push(`- MCP: ${DEFAULT_MCP_PUBLIC_ROUTE}, ${DEFAULT_MCP_WELL_KNOWN_ROUTE}`);
+}
+function appendDocsAgentPublicRouteLines(lines, context, variant) {
+	if (variant === "skill") {
+		lines.push(`- Agent instructions: ${DEFAULT_AGENTS_MD_ROUTE}`, `- Agent instructions well-known alias: ${DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE}`, `- Agent instructions API format: ${context.apiRoute}?format=agents`, `- Skill document: ${DEFAULT_SKILL_MD_ROUTE}`, `- Skill well-known alias: ${DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE}`, `- Skill API format: ${context.apiRoute}?format=skill`, `- Agent discovery: ${DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE}`, `- Agent discovery fallback: ${DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE}`);
+		if (context.apiCatalogEnabled) lines.push(`- API catalog (RFC 9727): ${DEFAULT_API_CATALOG_ROUTE}`);
+		lines.push(`- Agent Skills index: ${DEFAULT_AGENT_SKILLS_INDEX_ROUTE}`, `- Agent Skills artifacts: ${DEFAULT_AGENT_SKILLS_ROUTE_PATTERN}`, `- Markdown root: /${context.normalizedEntry}.md`, `- Markdown pages: /${context.normalizedEntry}/{slug}.md`);
+		if (context.robotsEnabled) lines.push(`- Robots policy: ${DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE}`);
+		appendDocsLlmsRouteLines(lines, context);
+		appendDocsOpenApiRouteLines(lines, context);
+		appendDocsSitemapRouteLines(lines, context);
+		appendDocsMcpRouteLines(lines, context);
+		return;
+	}
+	lines.push(`- Agent instructions: ${DEFAULT_AGENTS_MD_ROUTE}`, `- Agent instructions well-known alias: ${DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE}`, `- Agent instructions API format: ${context.apiRoute}?format=agents`, `- Agent instructions aliases: ${DEFAULT_AGENT_MD_ROUTE}, ${DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE}`, `- Site skill: ${DEFAULT_SKILL_MD_ROUTE}`, `- Site skill well-known alias: ${DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE}`, `- Site skill API format: ${context.apiRoute}?format=skill`, `- Markdown root: /${context.normalizedEntry}.md`, `- Markdown pages: /${context.normalizedEntry}/{slug}.md`, `- Agent discovery: ${DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE}`, `- Agent discovery fallback: ${DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE}`);
+	if (context.apiCatalogEnabled) lines.push(`- API catalog (RFC 9727): ${DEFAULT_API_CATALOG_ROUTE}`);
+	lines.push(`- Agent Skills index: ${DEFAULT_AGENT_SKILLS_INDEX_ROUTE}`, `- Agent Skills artifacts: ${DEFAULT_AGENT_SKILLS_ROUTE_PATTERN}`);
+	appendDocsLlmsRouteLines(lines, context);
+	if (context.robotsEnabled) lines.push(`- Robots policy: ${DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE}`);
+	appendDocsSitemapRouteLines(lines, context);
+	appendDocsOpenApiRouteLines(lines, context);
+	appendDocsMcpRouteLines(lines, context);
+}
+function renderDocsMarkdownDocument(page, options) {
+	const explicitAgentContent = page.agentRawContent ?? page.agentContent;
+	if (explicitAgentContent !== void 0) return appendDocsMarkdownSitemapFooter(prependDocsMarkdownFrontmatter(upsertPageAgentContractMarkdown(explicitAgentContent, page.agent), resolveDocsMarkdownPageMetadata(page, options)), options?.sitemap);
+	const relatedLines = renderDocsRelatedMarkdownLines(page.related);
+	const lines = [`# ${page.title}`, `URL: ${page.url}`];
+	if (shouldRenderLlmsDirective(options)) lines.push(DOCS_LLMS_TXT_DIRECTIVE_LINE);
+	if (page.description) lines.push(`Description: ${page.description}`);
+	lines.push(...relatedLines);
+	lines.push("", upsertPageAgentContractMarkdown(page.agentFallbackRawContent ?? page.agentFallbackContent ?? page.rawContent ?? page.content, page.agent));
+	return appendDocsMarkdownSitemapFooter(prependDocsMarkdownFrontmatter(lines.join("\n"), resolveDocsMarkdownPageMetadata(page, options)), options?.sitemap);
+}
+function renderDocsSkillDocument(options) {
+	const { origin } = options;
+	const context = resolveDocsAgentDocumentContext(options);
+	const lines = [
+		"---",
+		"name: docs",
+		`description: ${toYamlString(truncateSkillDescription(`Use ${context.siteTitle} through markdown routes, llms.txt, robots.txt, agent discovery, search, and MCP when available.`))}`,
+		"---",
+		"",
+		`# ${context.siteTitle} Skill`,
+		"",
+		`Base URL: ${origin}`
+	];
+	if (context.siteDescription) lines.push(`Description: ${context.siteDescription}`);
+	lines.push("", "## When To Use", "Use this skill when you need to read or implement against this documentation site.", "", "## Start Here");
+	appendDocsAgentStartHereLines(lines, context, "skill");
+	lines.push("", "## Routes");
+	appendDocsAgentPublicRouteLines(lines, context, "skill");
+	lines.push("", "## Reusable Framework Skills", "For framework setup, CLI, page actions, Ask AI, or configuration work, install the reusable Farming Labs skills:", "", "```sh", "npx skills add farming-labs/docs", "```");
+	return lines.join("\n");
+}
+function renderDocsAgentsDocument(options) {
+	const { origin } = options;
+	const context = resolveDocsAgentDocumentContext(options);
+	const lines = [
+		"# Agent Instructions",
+		"",
+		`Site: ${context.siteTitle}`,
+		`Base URL: ${origin}`
+	];
+	if (context.siteDescription) lines.push(`Description: ${context.siteDescription}`);
+	lines.push("", "## Start Here");
+	appendDocsAgentStartHereLines(lines, context, "agents");
+	lines.push("", "## Working Rules", "- Prefer markdown routes, llms.txt, sitemap.md, OpenAPI schemas, and MCP tools over scraping rendered HTML.", "- Treat generated context files as discovery aids, then fetch the smallest page or section that answers the task.", "- Preserve canonical docs URLs when citing pages back to humans.", "- If a markdown route returns a recovery page, use its closest matches, sitemap, and discovery spec before guessing another slug.", "", "## Public Routes");
+	appendDocsAgentPublicRouteLines(lines, context, "agents");
+	lines.push("", "## Framework Maintenance", "- For @farming-labs/docs projects, keep the framework package current before debugging missing agent surfaces.", "", "```sh", "npx @farming-labs/docs@latest upgrade --latest", "```", "", "- For framework setup, configuration, CLI, Ask AI, page actions, or theme work, install the reusable Skills pack:", "", "```sh", "npx skills add farming-labs/docs", "```");
+	return lines.join("\n");
+}
+/** Resolve only the task tools that the advertised MCP endpoint actually exposes. */
+function resolveDocsAgentContractMcpTools(mcp) {
+	if (!mcp.enabled) return void 0;
+	const tools = {};
+	if (mcp.tools.listTasks !== false) tools.list = "list_tasks";
+	if (mcp.tools.readTask !== false) tools.read = "read_task";
+	return tools.list || tools.read ? tools : void 0;
+}
+function buildDocsAgentDiscoverySpec({ origin, entry = "docs", apiRoute, apiCatalog: explicitApiCatalog, i18n = null, search, mcp, feedback, llms, sitemap, robots, openapi, markdown, publishedSkills = [], agentCard }) {
+	const normalizedEntry = normalizeDocsPathSegment(entry) || "docs";
+	const resolvedApiRoute = resolveDocsDiscoveryApiRoute(apiRoute);
+	const apiQueryRoute = (query) => `${resolvedApiRoute}?${query}`;
+	const localesEnabled = i18n !== null;
+	const searchEnabled = isSearchEnabled(search);
+	const feedbackRoute = feedback?.route ?? DEFAULT_AGENT_FEEDBACK_ROUTE;
+	const feedbackSchemaRoute = feedback?.schemaRoute ?? `${feedbackRoute}/schema`;
+	const llmsEnabled = llms?.enabled ?? true;
+	const llmsSections = resolveDocsLlmsTxtSections(llms);
+	const sitemapConfig = resolveDocsSitemapConfig(sitemap, { baseUrl: llms?.baseUrl });
+	const robotsEnabled = isRobotsDiscoveryEnabled(robots);
+	const openapiConfig = resolveDocsOpenApiDiscoveryConfig(openapi);
+	const defaultOpenapiRoute = apiQueryRoute("format=openapi");
+	const openapiUrl = resolveDocsOpenApiDiscoveryUrl(openapiConfig, resolvedApiRoute);
+	const agentContractMcpTools = resolveDocsAgentContractMcpTools(mcp);
+	const apiCatalogEnabled = explicitApiCatalog ?? llms?.apiCatalog ?? true;
+	const protectedResource = mcp.enabled && mcp.security?.authenticate ? mcp.security.protectedResource : void 0;
+	const protectedResourceMetadataRoutes = protectedResource ? getDocsMcpProtectedResourceMetadataRoutes(mcp.route) : [];
+	return {
+		version: "1",
+		name: "@farming-labs/docs",
+		baseUrl: origin,
+		site: {
+			title: llms?.siteTitle ?? "Documentation",
+			description: llms?.siteDescription,
+			entry: normalizedEntry,
+			baseUrl: llms?.baseUrl ?? origin
+		},
+		locales: {
+			enabled: localesEnabled,
+			available: i18n?.locales ?? [],
+			default: i18n?.defaultLocale ?? null,
+			queryParam: "lang",
+			fallbackQueryParam: "locale"
+		},
+		capabilities: {
+			markdownRoutes: true,
+			agentMdOverrides: true,
+			agentBlocks: true,
+			structuredAgentContracts: true,
+			agents: true,
+			llms: llmsEnabled,
+			skills: true,
+			apiCatalog: apiCatalogEnabled,
+			agentSkillsDiscovery: true,
+			mcp: mcp.enabled,
+			search: searchEnabled,
+			sitemap: sitemapConfig.enabled,
+			robots: robotsEnabled,
+			structuredData: true,
+			apiReference: openapiConfig.enabled,
+			openapi: openapiConfig.enabled,
+			agentFeedback: feedback?.enabled ?? false,
+			locales: localesEnabled
+		},
+		api: {
+			docs: resolvedApiRoute,
+			config: apiQueryRoute("format=config"),
+			diagnostics: apiQueryRoute("format=diagnostics"),
+			agentSpec: resolvedApiRoute === DEFAULT_DOCS_API_ROUTE ? DEFAULT_AGENT_SPEC_ROUTE : apiQueryRoute("agent=spec"),
+			agentSpecDefault: DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE,
+			agentSpecFallback: DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE,
+			agentSpecWellKnown: DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE,
+			agentSpecWellKnownJson: DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE,
+			agentSpecQuery: apiQueryRoute("agent=spec"),
+			agents: apiQueryRoute("format=agents"),
+			...apiCatalogEnabled ? {
+				apiCatalog: DEFAULT_API_CATALOG_ROUTE,
+				apiCatalogQuery: apiQueryRoute(`format=${DEFAULT_API_CATALOG_FORMAT}`)
+			} : {},
+			agentSkillsIndex: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+			legacySkillsIndex: DEFAULT_LEGACY_SKILLS_INDEX_ROUTE,
+			...agentCard ? { agentCard: DEFAULT_A2A_AGENT_CARD_ROUTE } : {},
+			openapi: defaultOpenapiRoute
+		},
+		apiCatalog: {
+			enabled: apiCatalogEnabled,
+			route: apiCatalogEnabled ? DEFAULT_API_CATALOG_ROUTE : null,
+			api: apiCatalogEnabled ? apiQueryRoute(`format=${DEFAULT_API_CATALOG_FORMAT}`) : null,
+			mediaType: API_CATALOG_MEDIA_TYPE,
+			profile: API_CATALOG_PROFILE_URI
+		},
+		config: {
+			format: DEFAULT_DOCS_CONFIG_FORMAT,
+			endpoint: apiQueryRoute("format=config")
+		},
+		markdown: {
+			enabled: true,
+			acceptHeader: markdown?.acceptHeader === false ? null : "text/markdown",
+			signatureAgentHeader: markdown?.signatureAgentHeader === false ? null : DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER,
+			pagePattern: `/${normalizedEntry}/{slug}.md`,
+			rootPage: `/${normalizedEntry}.md`,
+			apiPattern: apiQueryRoute("format=markdown&path={slug}"),
+			resolutionOrder: [
+				"agent.md",
+				"agent audience projection",
+				"shared page markdown"
+			]
+		},
+		agentContract: {
+			enabled: true,
+			schemaVersion: "page-agent-contract.v1",
+			source: "page-frontmatter",
+			frontmatterPath: "agent",
+			markdownSection: "Agent Contract",
+			mcpField: "agent",
+			...agentContractMcpTools ? { mcpTools: agentContractMcpTools } : {},
+			usefulContractFields: ["task", "outcome"],
+			fields: PAGE_AGENT_CONTRACT_FIELD_SCHEMA
+		},
+		llms: {
+			enabled: llmsEnabled,
+			defaultTxt: DEFAULT_LLMS_TXT_ROUTE,
+			defaultFull: DEFAULT_LLMS_FULL_TXT_ROUTE,
+			txt: apiQueryRoute("format=llms"),
+			full: apiQueryRoute("format=llms-full"),
+			publicTxt: DEFAULT_LLMS_TXT_ROUTE,
+			publicFull: DEFAULT_LLMS_FULL_TXT_ROUTE,
+			wellKnownTxt: DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE,
+			wellKnownFull: DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE,
+			...llmsSections.length > 0 ? { sections: llmsSections.map((section) => ({
+				title: section.title,
+				description: section.description,
+				match: section.match,
+				txt: section.route,
+				full: section.fullRoute
+			})) } : {}
+		},
+		sitemap: {
+			enabled: sitemapConfig.enabled,
+			xml: {
+				enabled: sitemapConfig.xml.enabled,
+				route: sitemapConfig.xml.route,
+				api: apiQueryRoute("format=sitemap-xml"),
+				defaultRoute: DEFAULT_SITEMAP_XML_ROUTE
+			},
+			markdown: {
+				enabled: sitemapConfig.markdown.enabled,
+				route: sitemapConfig.markdown.route,
+				docsRoute: sitemapConfig.markdown.docsRoute,
+				wellKnownRoute: sitemapConfig.markdown.wellKnownRoute,
+				api: apiQueryRoute("format=sitemap-md"),
+				defaultRoute: DEFAULT_SITEMAP_MD_ROUTE,
+				defaultDocsRoute: DEFAULT_SITEMAP_MD_DOCS_ROUTE,
+				defaultWellKnownRoute: DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE
+			}
+		},
+		robots: {
+			enabled: robotsEnabled,
+			route: DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE,
+			defaultRoute: DEFAULT_AGENT_DISCOVERY_ROBOTS_TXT_ROUTE
+		},
+		structuredData: {
+			enabled: true,
+			format: "application/ld+json",
+			schema: "https://schema.org/TechArticle",
+			fields: [
+				"headline",
+				"description",
+				"url",
+				"dateModified",
+				"breadcrumb",
+				"mainEntity"
+			],
+			canonicalUrlField: "url",
+			breadcrumbType: "BreadcrumbList",
+			agentContractType: "HowTo"
+		},
+		openapi: {
+			enabled: openapiConfig.enabled,
+			url: openapiUrl ?? null,
+			source: openapiConfig.source ?? null,
+			specUrl: openapiConfig.specUrl ?? null,
+			apiReferencePath: openapiConfig.apiReferencePath ?? null,
+			format: "OpenAPI 3.1"
+		},
+		search: {
+			enabled: searchEnabled,
+			endpoint: apiQueryRoute("query={query}"),
+			agentEndpoint: apiQueryRoute("query={query}&audience=agent"),
+			method: "GET",
+			queryParam: "query",
+			localeParam: "lang",
+			audienceParam: "audience",
+			defaultAudience: "human",
+			supportedAudiences: ["human", "agent"]
+		},
+		agents: {
+			enabled: true,
+			file: "AGENTS.md",
+			route: DEFAULT_AGENTS_MD_ROUTE,
+			wellKnown: DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE,
+			api: apiQueryRoute("format=agents"),
+			generatedFallback: true,
+			aliases: [DEFAULT_AGENT_MD_ROUTE, DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE]
+		},
+		skills: {
+			enabled: true,
+			file: "skill.md",
+			route: DEFAULT_SKILL_MD_ROUTE,
+			wellKnown: DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE,
+			api: apiQueryRoute("format=skill"),
+			generatedFallback: true,
+			registry: "skills.sh",
+			install: "npx skills add farming-labs/docs",
+			discovery: {
+				schema: AGENT_SKILLS_DISCOVERY_SCHEMA_URI,
+				index: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+				artifact: DEFAULT_AGENT_SKILLS_ROUTE_PATTERN,
+				archive: DEFAULT_AGENT_SKILLS_ARCHIVE_ROUTE_PATTERN,
+				file: `${DEFAULT_AGENT_SKILLS_ROUTE_PATTERN.replace("/SKILL.md", "/{path}")}`,
+				legacyIndex: DEFAULT_LEGACY_SKILLS_INDEX_ROUTE,
+				apiIndex: apiQueryRoute(`format=${DEFAULT_AGENT_SKILLS_INDEX_FORMAT}`),
+				apiArtifact: apiQueryRoute("format=agent-skill&name={name}"),
+				apiFile: apiQueryRoute("format=agent-skill-file&name={name}&path={path}"),
+				digest: "sha256"
+			},
+			published: publishedSkills.map((skill) => ({
+				name: skill.name,
+				description: skill.description,
+				type: skill.type,
+				url: skill.url,
+				digest: skill.digest,
+				files: skill.files.map((file) => ({
+					path: file.path,
+					url: file.url,
+					digest: file.digest
+				}))
+			})),
+			recommended: [{
+				name: "getting-started",
+				description: "Use for installation, init, framework setup, theme CSS, and first docs.config wiring."
+			}]
+		},
+		mcp: {
+			enabled: mcp.enabled,
+			endpoint: mcp.route,
+			defaultEndpoint: DEFAULT_MCP_PUBLIC_ROUTE,
+			publicEndpoint: DEFAULT_MCP_PUBLIC_ROUTE,
+			wellKnownEndpoint: DEFAULT_MCP_WELL_KNOWN_ROUTE,
+			publicEndpoints: [DEFAULT_MCP_PUBLIC_ROUTE, DEFAULT_MCP_WELL_KNOWN_ROUTE],
+			canonicalEndpoint: mcp.route,
+			name: mcp.name,
+			version: mcp.version,
+			tools: mcp.tools,
+			...protectedResource ? { protectedResource: {
+				metadataEndpoints: protectedResourceMetadataRoutes,
+				authorizationServers: protectedResource.authorizationServers,
+				scopesSupported: protectedResource.scopesSupported,
+				requiredScopes: protectedResource.requiredScopes
+			} } : {}
+		},
+		feedback: {
+			enabled: feedback?.enabled ?? false,
+			schema: feedbackSchemaRoute,
+			submit: feedbackRoute,
+			schemaQuery: apiQueryRoute("feedback=agent&schema=1"),
+			submitQuery: apiQueryRoute("feedback=agent")
+		},
+		instructions: {
+			preferMarkdownRoutes: true,
+			useMcpWhenAvailable: true,
+			useOpenApiWhenAvailable: true,
+			readFeedbackSchemaBeforeSubmitting: true,
+			doNotAssumeFeedbackPayloadShape: true
+		}
+	};
+}
+function acceptsDocsMarkdown(request) {
+	const accept = request.headers.get("accept");
+	if (!accept) return false;
+	const ranges = accept.split(",").map((value) => {
+		const [rawMediaType = "", ...params] = value.split(";").map((part) => part.trim().toLowerCase());
+		const qualityParam = params.find((param) => param.split("=", 1)[0]?.trim() === "q");
+		const parsedQuality = qualityParam ? Number.parseFloat(qualityParam.slice(qualityParam.indexOf("=") + 1).trim()) : 1;
+		return {
+			mediaType: rawMediaType,
+			quality: Number.isFinite(parsedQuality) ? Math.min(1, Math.max(0, parsedQuality)) : 0
+		};
+	});
+	const qualityFor = (mediaType) => {
+		const matches = ranges.filter((range) => range.mediaType === mediaType);
+		return matches.length > 0 ? Math.max(...matches.map((range) => range.quality)) : void 0;
+	};
+	const markdownQuality = qualityFor("text/markdown");
+	if (!markdownQuality || markdownQuality <= 0) return false;
+	const htmlQuality = qualityFor("text/html") ?? qualityFor("text/*") ?? qualityFor("*/*");
+	return htmlQuality === void 0 || htmlQuality <= markdownQuality;
+}
+function buildDocsUserAgentHeaderPattern(patterns) {
+	return `.*(?:${patterns.map(toCaseInsensitiveHeaderPattern).join("|")}).*`;
+}
+function toCaseInsensitiveHeaderPattern(value) {
+	return value.split("").map((char) => {
+		if (/^[a-z]$/i.test(char)) return `[${char.toLowerCase()}${char.toUpperCase()}]`;
+		return escapeRegex(char);
+	}).join("");
+}
+function escapeRegex(value) {
+	return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function normalizeRequestedMarkdownPath(entry, requestedPath) {
+	const normalizedEntry = `/${normalizeDocsPathSegment(entry) || "docs"}`;
+	const trimmed = requestedPath.trim().replace(/\.md$/i, "");
+	if (!trimmed) return normalizedEntry;
+	const normalized = normalizeDocsUrlPath(trimmed.startsWith("/") ? trimmed : `/${trimmed}`);
+	if (normalized === normalizedEntry || normalized.startsWith(`${normalizedEntry}/`)) return normalized;
+	const slug = normalizeDocsPathSegment(trimmed);
+	return slug ? normalizeDocsUrlPath(`${normalizedEntry}/${slug}`) : normalizedEntry;
+}
+function isSearchEnabled(search) {
+	if (search === false) return false;
+	if (search && typeof search === "object" && search.enabled === false) return false;
+	return true;
+}
+function isRobotsDiscoveryEnabled(robots) {
+	if (robots === false) return false;
+	if (robots && typeof robots === "object" && robots.enabled === false) return false;
+	return true;
+}
+function resolveDocsOpenApiDiscoveryConfig(openapi) {
+	if (openapi === false || openapi === void 0) return { enabled: false };
+	if (openapi === true) return {
+		enabled: true,
+		url: DEFAULT_OPENAPI_SCHEMA_ROUTE,
+		urlSource: "default",
+		source: "generated"
+	};
+	if (openapi.enabled === false) return { enabled: false };
+	return {
+		enabled: true,
+		url: openapi.url ?? DEFAULT_OPENAPI_SCHEMA_ROUTE,
+		urlSource: openapi.urlSource ?? (openapi.url === void 0 ? "default" : "configured"),
+		source: openapi.source ?? "generated",
+		specUrl: openapi.specUrl,
+		apiReferencePath: openapi.apiReferencePath
+	};
+}
+function resolveDocsOpenApiDiscoveryUrl(openapi, apiRoute) {
+	return openapi.urlSource === "default" && openapi.url === DEFAULT_OPENAPI_SCHEMA_ROUTE ? `${apiRoute}?format=openapi` : openapi.url;
+}
+function compactSkillText(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function truncateSkillDescription(value) {
+	const normalized = compactSkillText(value);
+	if (normalized.length <= 1024) return normalized;
+	return `${normalized.slice(0, 1021).trimEnd()}...`;
+}
+function toYamlString(value) {
+	return JSON.stringify(value);
+}
+
+//#endregion
+export { renderDocsAgentsDocument as $, DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE as $t, buildDocsAgentFeedbackSchema as A, buildDocsSitemapManifest as At, getDocsMarkdownVaryHeader as B, renderDocsRelatedMarkdownLines as Bt, DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN as C, resolveDocsAudienceExposure as Ct, DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN as D, DEFAULT_SITEMAP_MD_ROUTE as Dt, DOCS_MARKDOWN_SIGNATURE_AGENT_HEADER as E, DEFAULT_SITEMAP_MD_DOCS_ROUTE as Et, createDocsStandardsDiscoveryResponse as F, resolveDocsSitemapConfig as Ft, isDocsDiagnosticsRequest as G, PAGE_AGENT_STRUCTURED_CONTRACT_FIELDS as Gt, isDocsAgentDiscoveryRequest as H, PAGE_AGENT_CONTRACT_FIELDS as Ht, detectDocsMarkdownAgentRequest as I, resolveDocsSitemapPageLastmod as It, isDocsSkillRequest as J, normalizePageAgentFrontmatter as Jt, isDocsLlmsTxtPublicRequest as K, getPageAgentFrontmatterIssues as Kt, findDocsMarkdownPage as L, resolveDocsSitemapRequest as Lt, buildDocsDiagnostics as M, readDocsSitemapManifestFromContentMap as Mt, buildDocsMcpEndpointCandidates as N, renderDocsSitemapMarkdown as Nt, acceptsDocsMarkdown as O, DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE as Ot, createDocsMarkdownResponse as P, renderDocsSitemapXml as Pt, parseDocsAgentFeedbackData as Q, upsertPageAgentContractMarkdown as Qt, getDocsLlmsTxtMaxCharsIssue as R, toDocsSitemapMarkdownUrl as Rt, DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE as S, resolveDocsAgentMdxContent as St, DOCS_CONFIG_MAP_TOP_LEVEL_KEYS as T, DEFAULT_SITEMAP_MANIFEST_PATH as Tt, isDocsAgentsRequest as U, PAGE_AGENT_CONTRACT_FIELD_SCHEMA as Ut, hasDocsMarkdownSignatureAgent as V, PAGE_AGENT_CONTRACT_END_MARKER as Vt, isDocsConfigRequest as W, PAGE_AGENT_CONTRACT_START_MARKER as Wt, normalizeDocsPathSegment as X, renderPageAgentFrontmatterYamlLines as Xt, matchesDocsLlmsTxtSection as Y, renderPageAgentContractMarkdown as Yt, normalizeDocsUrlPath as Z, stripGeneratedPageAgentContractMarkdown as Zt, DEFAULT_LLMS_TXT_MAX_CHARS as _, selectDocsLlmsTxtContent as _t, DEFAULT_AGENT_MD_ROUTE as a, getDocsMcpResourcePaths as an, resolveDocsAgentFeedbackConfig as at, DEFAULT_OPENAPI_SCHEMA_ROUTE as b, findDocsAudienceMdxIssues as bt, DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE as c, isDocsMcpProtectedResourceMetadataPath as cn, resolveDocsLlmsTxtFormat as ct, DEFAULT_DOCS_CONFIG_FORMAT as d, normalizeDocsMcpAuthorizationServerUrls as dn, resolveDocsMarkdownCanonicalUrl as dt, DEFAULT_MCP_PUBLIC_ROUTE as en, renderDocsLlmsTxt as et, DEFAULT_DOCS_CONFIG_ROUTE as f, normalizeDocsMcpEndpointPath as fn, resolveDocsMarkdownRecovery as ft, DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE as g, resolveDocsSkillFormat as gt, DEFAULT_LLMS_FULL_TXT_ROUTE as h, resolveDocsRequestApiRoute as ht, DEFAULT_AGENT_FEEDBACK_ROUTE as i, getDocsMcpProtectedResourceMetadataRoutes as in, resolveDocsAgentContractMcpTools as it, buildDocsConfigMap as j, createDocsSitemapResponse as jt, buildDocsAgentDiscoverySpec as k, DEFAULT_SITEMAP_XML_ROUTE as kt, DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE as l, isDocsMcpRequest as ln, resolveDocsLlmsTxtRequest as lt, DEFAULT_DOCS_DIAGNOSTICS_ROUTE as m, resolveDocsMcpResourceLocation as mn, resolveDocsOpenApiDiscoveryConfig as mt, DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE as n, DEFAULT_MCP_WELL_KNOWN_ROUTE as nn, renderDocsMarkdownNotFound as nt, DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE as o, hasDocsMcpProtectedResourceConfig as on, resolveDocsAgentFeedbackRequest as ot, DEFAULT_DOCS_DIAGNOSTICS_FORMAT as p, resolveDocsMcpProtectedResourceMetadataLocation as pn, resolveDocsMarkdownRequest as pt, isDocsPublicGetRequest as q, hasStructuredPageAgentContract as qt, DEFAULT_AGENT_FEEDBACK_PAYLOAD_SCHEMA as r, buildDocsMcpProtectedResourceMetadataRoute as rn, renderDocsSkillDocument as rt, DEFAULT_AGENT_SPEC_ROUTE as s, isDocsMcpOAuthScopeToken as sn, resolveDocsAgentsFormat as st, DEFAULT_AGENTS_MD_ROUTE as t, DEFAULT_MCP_ROUTE as tn, renderDocsMarkdownDocument as tt, DEFAULT_DOCS_API_ROUTE as u, isDocsMcpResourcePath as un, resolveDocsLlmsTxtSections as ut, DEFAULT_LLMS_TXT_ROUTE as v, toDocsMarkdownUrl as vt, DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN as w, resolveDocsAudienceMdxContent as wt, DEFAULT_SKILL_MD_ROUTE as x, findDocsAudienceMdxTags as xt, DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE as y, validateDocsAgentFeedbackPayload as yt, getDocsMarkdownCanonicalLinkHeader as z, normalizeDocsRelated as zt };