@farming-labs/docs 0.2.61 → 0.2.62

package/dist/mcp.mjs

@@ -1,4426 +0,0 @@
-import { a as emitDocsAnalyticsEvent, i as emitDocsAgentTraceEvent, n as createDocsAgentTraceContext, r as createDocsAgentTraceId } from "./analytics-Bx44lg6d.mjs";
-import { Bt as renderDocsRelatedMarkdownLines, Jt as normalizePageAgentFrontmatter, Qt as upsertPageAgentContractMarkdown, cn as isDocsMcpProtectedResourceMetadataPath, dn as normalizeDocsMcpAuthorizationServerUrls, fn as normalizeDocsMcpEndpointPath, mn as resolveDocsMcpResourceLocation, pn as resolveDocsMcpProtectedResourceMetadataLocation, qt as hasStructuredPageAgentContract, sn as isDocsMcpOAuthScopeToken, un as isDocsMcpResourcePath, wt as resolveDocsAudienceMdxContent, zt as normalizeDocsRelated } from "./agent-Fl0pjVNF.mjs";
-import "./standards-discovery-C54V_aJH.mjs";
-import { C as resolvePageSidebarFolderIndexBehavior, E as emitDocsTelemetryAgentSurfaceEvent, O as emitDocsTelemetryMcpToolEvent, k as emitDocsTelemetryProjectEvent, m as parseDocsMarkdownSections, p as findDocsMarkdownSection, u as performDocsSearch, x as stripGeneratedAgentProvenance } from "./search-9OnMGMvt.mjs";
-import { a as normalizeAgentScopeValues, i as normalizeAgentLocale, n as agentVersionConstraintsOverlap, r as normalizeAgentFramework, t as agentVersionConstraintMatches } from "./agent-scope-C_U--OZ7.mjs";
-import matter from "gray-matter";
-import fs from "node:fs";
-import path from "node:path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import * as z from "zod/v4";
-
-//#region src/mcp.ts
-const DEFAULT_MCP_VERSION = "0.0.0";
-const DEFAULT_MCP_NAME = "@farming-labs/docs";
-const DEFAULT_MCP_CONTEXT_TOKEN_BUDGET = 4e3;
-const MIN_MCP_CONTEXT_TOKEN_BUDGET = 256;
-const MAX_MCP_CONTEXT_TOKEN_BUDGET = 32e3;
-const UTF8_ENCODER = new TextEncoder();
-const DEFAULT_DOCS_MCP_MAX_BODY_BYTES = 1024 * 1024;
-const DEFAULT_DOCS_MCP_CORS_MAX_AGE_SECONDS = 600;
-const DEFAULT_DOCS_MCP_CORS_ALLOWED_HEADERS = Object.freeze([
-	"Accept",
-	"Authorization",
-	"Content-Type",
-	"Last-Event-ID",
-	"MCP-Protocol-Version",
-	"MCP-Session-Id"
-]);
-const DEFAULT_DOCS_MCP_CORS_EXPOSED_HEADERS = Object.freeze([
-	"MCP-Protocol-Version",
-	"MCP-Session-Id",
-	"WWW-Authenticate"
-]);
-function freezeDocsConfigSchemaOptions(options) {
-	for (const option of options) {
-		if (option.values) Object.freeze(option.values);
-		if (option.children) {
-			freezeDocsConfigSchemaOptions([...option.children]);
-			Object.freeze(option.children);
-		}
-		Object.freeze(option);
-	}
-	return Object.freeze(options);
-}
-function freezeDocsConfigSchemaExamples(examples) {
-	for (const example of examples) Object.freeze(example);
-	return Object.freeze(examples);
-}
-const DOCS_CONFIG_SCHEMA_OPTIONS_TEMPLATE = [
-	{
-		path: "entry",
-		name: "entry",
-		type: "string",
-		default: "docs",
-		description: "URL path prefix for documentation routes, for example \"docs\" creates /docs.",
-		docs: "/docs/overview"
-	},
-	{
-		path: "docsPath",
-		name: "docsPath",
-		type: "string",
-		default: "same as entry",
-		description: "Public route prefix for docs pages when it differs from the source entry directory.",
-		docs: "/docs/overview"
-	},
-	{
-		path: "contentDir",
-		name: "contentDir",
-		type: "string",
-		default: "same as entry",
-		description: "Path to markdown content files. Adapters outside Next.js usually need this when content does not live under the route prefix.",
-		docs: "/docs/overview"
-	},
-	{
-		path: "i18n",
-		name: "i18n",
-		type: "DocsI18nConfig",
-		description: "Locale discovery, default locale, and localized docs content configuration.",
-		docs: "/docs/reference"
-	},
-	{
-		path: "staticExport",
-		name: "staticExport",
-		type: "boolean",
-		default: false,
-		description: "Enable full static builds. Search, AI, and runtime API routes are hidden.",
-		docs: "/docs/overview"
-	},
-	{
-		path: "theme",
-		name: "theme",
-		type: "DocsTheme",
-		description: "Theme instance from a theme factory such as fumadocs() or pixelBorder().",
-		docs: "/docs/customization/themes"
-	},
-	{
-		path: "analytics",
-		name: "analytics",
-		type: "boolean | DocsAnalyticsConfig",
-		default: false,
-		description: "Built-in privacy-aware product and agent surface analytics."
-	},
-	{
-		path: "telemetry",
-		name: "telemetry",
-		type: "boolean | DocsTelemetryConfig",
-		description: "Project telemetry controls for framework and agent-surface events."
-	},
-	{
-		path: "observability",
-		name: "observability",
-		type: "boolean | DocsObservabilityConfig",
-		description: "Tracing and observability callbacks for search, AI, and agent operations."
-	},
-	{
-		path: "nav",
-		name: "nav",
-		type: "{ title?: string; url?: string }",
-		description: "Sidebar and discovery metadata for the docs site. Non-Next.js adapters usually require it.",
-		children: [{
-			path: "nav.title",
-			name: "title",
-			type: "string",
-			description: "Human-readable docs site title."
-		}, {
-			path: "nav.url",
-			name: "url",
-			type: "string",
-			description: "Public base URL for generated absolute links and metadata."
-		}]
-	},
-	{
-		path: "github",
-		name: "github",
-		type: "string | GithubConfig",
-		description: "GitHub repository metadata for \"Edit on GitHub\" links and page action prompt templates.",
-		docs: "/docs/customization/page-actions"
-	},
-	{
-		path: "themeToggle",
-		name: "themeToggle",
-		type: "boolean | ThemeToggleConfig",
-		default: true,
-		description: "Enable or customize the light/dark mode toggle."
-	},
-	{
-		path: "breadcrumb",
-		name: "breadcrumb",
-		type: "boolean | BreadcrumbConfig",
-		default: true,
-		description: "Enable or customize breadcrumb navigation."
-	},
-	{
-		path: "sidebar",
-		name: "sidebar",
-		type: "boolean | SidebarConfig",
-		default: true,
-		description: "Enable or customize the docs sidebar.",
-		children: [{
-			path: "sidebar.style",
-			name: "style",
-			type: "string",
-			description: "Theme-specific sidebar style variant when supported."
-		}, {
-			path: "sidebar.defaultOpen",
-			name: "defaultOpen",
-			type: "boolean",
-			description: "Whether collapsible sidebar groups start open by default."
-		}]
-	},
-	{
-		path: "icons",
-		name: "icons",
-		type: "Record<string, Component>",
-		description: "Shared icon registry for frontmatter icon fields and built-in MDX components."
-	},
-	{
-		path: "components",
-		name: "components",
-		type: "Record<string, Component>",
-		description: "Custom MDX component registry and built-in component overrides."
-	},
-	{
-		path: "onCopyClick",
-		name: "onCopyClick",
-		type: "(data: CodeBlockCopyData) => void",
-		description: "Callback fired when a visitor copies a code block, including title, content, url, and language."
-	},
-	{
-		path: "feedback",
-		name: "feedback",
-		type: "boolean | FeedbackConfig",
-		default: false,
-		description: "Human page feedback UI. Agent feedback endpoints remain default-on unless opted out.",
-		docs: "/docs/customization/feedback"
-	},
-	{
-		path: "readingTime",
-		name: "readingTime",
-		type: "boolean | ReadingTimeConfig",
-		default: false,
-		description: "Opt-in estimated reading time label with per-page overrides and label format."
-	},
-	{
-		path: "lastUpdated",
-		name: "lastUpdated",
-		type: "boolean | LastUpdatedConfig",
-		description: "Last-updated metadata and labels derived from source history or page data."
-	},
-	{
-		path: "ordering",
-		name: "ordering",
-		type: "\"alphabetical\" | \"numeric\" | OrderingItem[]",
-		description: "Navigation ordering strategy or explicit ordered navigation entries."
-	},
-	{
-		path: "agent",
-		name: "agent",
-		type: "DocsAgentConfig",
-		description: "Agent compaction defaults and offline-by-default usefulness evaluations.",
-		docs: "/docs/getting-started/agent-ready-docs",
-		children: [
-			{
-				path: "agent.skills",
-				name: "skills",
-				type: "string | readonly string[] | DocsAgentSkillsConfig",
-				description: "Project skill files or collection directories published through discovery, static export, and MCP.",
-				children: [{
-					path: "agent.skills.paths",
-					name: "paths",
-					type: "string | readonly string[]",
-					description: "Workspace-contained SKILL.md file, skill directory, or collection directory paths."
-				}, {
-					path: "agent.skills.paths[]",
-					name: "path",
-					type: "string",
-					description: "One workspace-contained Agent Skill path."
-				}]
-			},
-			{
-				path: "agent.a2a",
-				name: "a2a",
-				type: "DocsAgentA2AConfig",
-				description: "Opt-in Agent Card metadata for a separately implemented real A2A service.",
-				children: [
-					{
-						path: "agent.a2a.interfaceUrl",
-						name: "interfaceUrl",
-						type: "string",
-						description: "HTTP(S) URL of the real A2A interface."
-					},
-					{
-						path: "agent.a2a.name",
-						name: "name",
-						type: "string",
-						description: "Public A2A agent name."
-					},
-					{
-						path: "agent.a2a.description",
-						name: "description",
-						type: "string",
-						description: "Public A2A agent description."
-					},
-					{
-						path: "agent.a2a.documentationUrl",
-						name: "documentationUrl",
-						type: "string",
-						description: "HTTP(S) documentation URL for the A2A service."
-					},
-					{
-						path: "agent.a2a.provider.organization",
-						name: "organization",
-						type: "string",
-						description: "A2A service provider organization."
-					},
-					{
-						path: "agent.a2a.provider.url",
-						name: "url",
-						type: "string",
-						description: "HTTP(S) provider URL."
-					},
-					{
-						path: "agent.a2a.version",
-						name: "version",
-						type: "string",
-						default: "1.0.0",
-						description: "A2A service version advertised by the card."
-					},
-					{
-						path: "agent.a2a.protocolVersion",
-						name: "protocolVersion",
-						type: "string",
-						default: "0.3",
-						description: "A2A protocol version implemented by the configured interface."
-					},
-					{
-						path: "agent.a2a.protocolBinding",
-						name: "protocolBinding",
-						type: "string",
-						default: "HTTP+JSON",
-						description: "A2A transport binding implemented by the configured interface."
-					}
-				]
-			},
-			{
-				path: "agent.compact",
-				name: "compact",
-				type: "DocsAgentCompactConfig",
-				description: "Defaults for generated agent.md compaction.",
-				children: [
-					{
-						path: "agent.compact.apiKey",
-						name: "apiKey",
-						type: "string",
-						description: "Direct compaction provider API key; prefer apiKeyEnv."
-					},
-					{
-						path: "agent.compact.apiKeyEnv",
-						name: "apiKeyEnv",
-						type: "string",
-						description: "Environment variable containing the compaction provider API key."
-					},
-					{
-						path: "agent.compact.baseUrl",
-						name: "baseUrl",
-						type: "string",
-						description: "Compaction provider base URL."
-					},
-					{
-						path: "agent.compact.model",
-						name: "model",
-						type: "string",
-						description: "Compaction model identifier."
-					},
-					{
-						path: "agent.compact.aggressiveness",
-						name: "aggressiveness",
-						type: "number",
-						default: .3,
-						description: "Compression aggressiveness from 0 to 1."
-					},
-					{
-						path: "agent.compact.maxOutputTokens",
-						name: "maxOutputTokens",
-						type: "number",
-						description: "Upper output token target."
-					},
-					{
-						path: "agent.compact.minOutputTokens",
-						name: "minOutputTokens",
-						type: "number",
-						description: "Lower output token target."
-					},
-					{
-						path: "agent.compact.protectJson",
-						name: "protectJson",
-						type: "boolean",
-						description: "Preserve JSON objects during compaction when supported."
-					}
-				]
-			},
-			{
-				path: "agent.evaluations",
-				name: "evaluations",
-				type: "boolean | DocsAgentEvaluationsConfig",
-				description: "Offline-by-default golden tasks for retrieval, citation, version, example, answer, and budget evaluation, with explicit external-provider and execution opt-ins.",
-				children: [
-					{
-						path: "agent.evaluations.enabled",
-						name: "enabled",
-						type: "boolean",
-						default: true,
-						description: "Enable configured golden-task evaluation."
-					},
-					{
-						path: "agent.evaluations.tokenBudget",
-						name: "tokenBudget",
-						type: "number",
-						default: 4e3,
-						description: "Default hard UTF-8 context-byte ceiling for golden tasks."
-					},
-					{
-						path: "agent.evaluations.topK",
-						name: "topK",
-						type: "number",
-						default: 5,
-						description: "Default number of ranked search results evaluated per task."
-					},
-					{
-						path: "agent.evaluations.surface",
-						name: "surface",
-						type: "\"mcp-context\" | \"configured-search\" | \"ask-ai-context\"",
-						default: "mcp-context",
-						description: "Retrieval/context surface measured by the golden task suite."
-					},
-					{
-						path: "agent.evaluations.allowNetwork",
-						name: "allowNetwork",
-						type: "boolean",
-						default: false,
-						description: "Allow external search, HTTP answers, and explicit executable-example verification during evaluation."
-					},
-					{
-						path: "agent.evaluations.searchTimeoutMs",
-						name: "searchTimeoutMs",
-						type: "number",
-						default: 3e4,
-						description: "Per-task configured search and Ask AI retrieval timeout in milliseconds."
-					},
-					{
-						path: "agent.evaluations.answer",
-						name: "answer",
-						type: "DocsAgentEvaluationAnswerProvider",
-						description: "Opt-in callback or HTTP provider used to evaluate actual generated answers and citations.",
-						children: [
-							{
-								path: "agent.evaluations.answer.provider",
-								name: "provider",
-								type: "\"callback\" | \"http\"",
-								description: "Answer evaluation provider kind."
-							},
-							{
-								path: "agent.evaluations.answer.run",
-								name: "run",
-								type: "DocsAgentEvaluationAnswerRunner",
-								description: "Callback invoked with retrieved context and source references."
-							},
-							{
-								path: "agent.evaluations.answer.endpoint",
-								name: "endpoint",
-								type: "string",
-								description: "HTTP endpoint used by the opt-in HTTP answer provider."
-							},
-							{
-								path: "agent.evaluations.answer.headers",
-								name: "headers",
-								type: "Record<string, string>",
-								description: "Optional HTTP request headers; values are never reported.",
-								children: [{
-									path: "agent.evaluations.answer.headers.*",
-									name: "header",
-									type: "string",
-									description: "One custom HTTP header value."
-								}]
-							},
-							{
-								path: "agent.evaluations.answer.timeoutMs",
-								name: "timeoutMs",
-								type: "number",
-								default: 3e4,
-								description: "Callback or HTTP answer provider timeout in milliseconds."
-							}
-						]
-					},
-					{
-						path: "agent.evaluations.tasks",
-						name: "tasks",
-						type: "DocsAgentGoldenTask[]",
-						description: "Golden task fixtures evaluated by docs doctor and docs review; the default MCP context surface runs offline.",
-						children: [
-							{
-								path: "agent.evaluations.tasks[]",
-								name: "task",
-								type: "DocsAgentGoldenTask",
-								description: "One golden task entry."
-							},
-							{
-								path: "agent.evaluations.tasks[].id",
-								name: "id",
-								type: "string",
-								description: "Stable task identifier shown in diagnostics."
-							},
-							{
-								path: "agent.evaluations.tasks[].query",
-								name: "query",
-								type: "string",
-								description: "User-shaped retrieval query."
-							},
-							{
-								path: "agent.evaluations.tasks[].tokenBudget",
-								name: "tokenBudget",
-								type: "number",
-								description: "Per-task UTF-8 context-byte ceiling override."
-							},
-							{
-								path: "agent.evaluations.tasks[].topK",
-								name: "topK",
-								type: "number",
-								description: "Per-task ranked retrieval depth override."
-							},
-							{
-								path: "agent.evaluations.tasks[].surface",
-								name: "surface",
-								type: "\"mcp-context\" | \"configured-search\" | \"ask-ai-context\"",
-								description: "Per-task evaluation surface override."
-							},
-							{
-								path: "agent.evaluations.tasks[].filters",
-								name: "filters",
-								type: "DocsAgentGoldenTaskFilters",
-								description: "Framework, version, and locale retrieval scope.",
-								children: [
-									{
-										path: "agent.evaluations.tasks[].filters.framework",
-										name: "framework",
-										type: "string",
-										description: "Required framework, such as nextjs or astro."
-									},
-									{
-										path: "agent.evaluations.tasks[].filters.version",
-										name: "version",
-										type: "string",
-										description: "Exact version requested by the task."
-									},
-									{
-										path: "agent.evaluations.tasks[].filters.locale",
-										name: "locale",
-										type: "string",
-										description: "Required locale."
-									}
-								]
-							},
-							{
-								path: "agent.evaluations.tasks[].expect",
-								name: "expect",
-								type: "DocsAgentGoldenTaskExpectation",
-								description: "Evaluator-only source, rank, citation, scope, answer, example, and budget expectations.",
-								children: [
-									{
-										path: "agent.evaluations.tasks[].expect.relevantSources",
-										name: "relevantSources",
-										type: "string[]",
-										description: "Canonical page or section URLs that should answer the task."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.allowedSources",
-										name: "allowedSources",
-										type: "string[]",
-										description: "Additional legitimate citations that do not reduce precision."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.forbiddenSources",
-										name: "forbiddenSources",
-										type: "string[]",
-										description: "Sources that must not be retrieved or cited."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.requiredCitations",
-										name: "requiredCitations",
-										type: "string[]",
-										description: "Citations that must appear; defaults to relevantSources."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.minRecallAtK",
-										name: "minRecallAtK",
-										type: "number",
-										default: 1,
-										description: "Minimum relevant-source recall in the top K results."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.maxFirstRelevantRank",
-										name: "maxFirstRelevantRank",
-										type: "number",
-										description: "Maximum acceptable rank of the first relevant source."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.minUsefulByteRatio",
-										name: "minUsefulByteRatio",
-										type: "number",
-										description: "Minimum share of context bytes supplied by relevant sources."
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.scope",
-										name: "scope",
-										type: "DocsAgentGoldenTaskFilters",
-										description: "Framework, version, and locale assertions checked against returned sources without pre-filtering retrieval.",
-										children: [
-											{
-												path: "agent.evaluations.tasks[].expect.scope.framework",
-												name: "framework",
-												type: "string",
-												description: "Framework the returned sources must select."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.scope.version",
-												name: "version",
-												type: "string",
-												description: "Version the returned sources must select."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.scope.locale",
-												name: "locale",
-												type: "string",
-												description: "Locale the returned sources must select."
-											}
-										]
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.answer",
-										name: "answer",
-										type: "DocsAgentGoldenAnswerExpectation",
-										description: "Required answer text and citation assertions for an explicitly configured answer provider.",
-										children: [
-											{
-												path: "agent.evaluations.tasks[].expect.answer.includes",
-												name: "includes",
-												type: "string[]",
-												description: "Literal fragments required in the actual answer."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.answer.excludes",
-												name: "excludes",
-												type: "string[]",
-												description: "Literal fragments forbidden in the actual answer."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.answer.requiredCitations",
-												name: "requiredCitations",
-												type: "string[]",
-												description: "Citations required in the actual answer."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.answer.allowedCitations",
-												name: "allowedCitations",
-												type: "string[]",
-												description: "Additional valid actual-answer citations."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.answer.forbiddenCitations",
-												name: "forbiddenCitations",
-												type: "string[]",
-												description: "Citations forbidden in the actual answer."
-											}
-										]
-									},
-									{
-										path: "agent.evaluations.tasks[].expect.examples",
-										name: "examples",
-										type: "DocsAgentGoldenExpectedExample[]",
-										description: "Runnable examples that must be present in returned context.",
-										children: [
-											{
-												path: "agent.evaluations.tasks[].expect.examples[]",
-												name: "example",
-												type: "DocsAgentGoldenExpectedExample",
-												description: "One expected code example."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].source",
-												name: "source",
-												type: "string",
-												description: "Canonical source URL containing the example."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].language",
-												name: "language",
-												type: "string",
-												description: "Expected code-fence language."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].framework",
-												name: "framework",
-												type: "string",
-												description: "Expected framework metadata."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].packageManager",
-												name: "packageManager",
-												type: "string",
-												description: "Expected package-manager metadata."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].title",
-												name: "title",
-												type: "string",
-												description: "Expected code-fence title metadata."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].runnable",
-												name: "runnable",
-												type: "boolean",
-												default: true,
-												description: "Whether the example must be marked runnable."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].includes",
-												name: "includes",
-												type: "string[]",
-												description: "Literal code fragments that must appear."
-											},
-											{
-												path: "agent.evaluations.tasks[].expect.examples[].verification",
-												name: "verification",
-												type: "\"present\" | \"syntax\" | \"execute\"",
-												description: "Required verification strength; defaults to present when runnable is false and syntax otherwise. Runtime execution is always explicit."
-											}
-										]
-									}
-								]
-							}
-						]
-					}
-				]
-			}
-		]
-	},
-	{
-		path: "review",
-		name: "review",
-		type: "boolean | DocsReviewConfig",
-		description: "Docs review scoring, CI behavior, and diagnostic rule severities.",
-		docs: "/docs/reference",
-		children: [
-			{
-				path: "review.enabled",
-				name: "enabled",
-				type: "boolean",
-				default: true,
-				description: "Enable Docs Review."
-			},
-			{
-				path: "review.score",
-				name: "score",
-				type: "DocsReviewScoreConfig",
-				description: "Healthy threshold and finding severity weights.",
-				children: [{
-					path: "review.score.threshold",
-					name: "threshold",
-					type: "number",
-					default: 80,
-					description: "Minimum healthy review score."
-				}, {
-					path: "review.score.weights",
-					name: "weights",
-					type: "{ error?: number; warn?: number; suggestion?: number }",
-					description: "Point deductions for each finding severity.",
-					children: [
-						{
-							path: "review.score.weights.error",
-							name: "error",
-							type: "number",
-							default: 20,
-							description: "Point deduction for an error finding."
-						},
-						{
-							path: "review.score.weights.warn",
-							name: "warn",
-							type: "number",
-							default: 8,
-							description: "Point deduction for a warning finding."
-						},
-						{
-							path: "review.score.weights.suggestion",
-							name: "suggestion",
-							type: "number",
-							default: 2,
-							description: "Point deduction for a suggestion finding."
-						}
-					]
-				}]
-			},
-			{
-				path: "review.ci",
-				name: "ci",
-				type: "boolean | DocsReviewCiConfig",
-				description: "GitHub Actions reporting and blocking behavior.",
-				children: [
-					{
-						path: "review.ci.enabled",
-						name: "enabled",
-						type: "boolean",
-						default: true,
-						description: "Enable review workflow generation."
-					},
-					{
-						path: "review.ci.name",
-						name: "name",
-						type: "string",
-						default: "docs-review",
-						description: "GitHub Actions job and check name."
-					},
-					{
-						path: "review.ci.mode",
-						name: "mode",
-						type: "\"off\" | \"warn\" | \"block\"",
-						default: "warn",
-						description: "Whether CI is disabled, advisory, or blocking.",
-						values: [
-							"off",
-							"warn",
-							"block"
-						]
-					},
-					{
-						path: "review.ci.annotations",
-						name: "annotations",
-						type: "boolean",
-						default: true,
-						description: "Emit GitHub workflow annotations."
-					},
-					{
-						path: "review.ci.comment",
-						name: "comment",
-						type: "boolean",
-						default: true,
-						description: "Allow the official action or bot to post PR comments."
-					}
-				]
-			},
-			{
-				path: "review.rules",
-				name: "rules",
-				type: "DocsReviewRulesConfig",
-				description: "Per-rule severity overrides.",
-				children: [
-					["brokenLinks", "error"],
-					["frontmatter", "error"],
-					["duplicateSlugs", "error"],
-					["invalidMdx", "error"],
-					["configExamples", "warn"],
-					["codeFenceMetadata", "warn"],
-					["runnableMetadata", "warn"],
-					["agentContext", "warn"],
-					["commandHealth", "warn"],
-					["relatedCoverage", "suggestion"],
-					["configConfidence", "warn"],
-					["agentSurfaceDrift", "error"],
-					["goldenTasks", "warn"]
-				].map(([name, defaultValue]) => ({
-					path: `review.rules.${name}`,
-					name,
-					type: "DocsReviewSeverity",
-					default: defaultValue,
-					description: `Severity override for the ${name} review rule.`,
-					values: [
-						"off",
-						"suggestion",
-						"warn",
-						"error"
-					]
-				}))
-			}
-		]
-	},
-	{
-		path: "pageActions",
-		name: "pageActions",
-		type: "PageActionsConfig",
-		description: "Copy Markdown and Open in LLM actions for docs pages.",
-		docs: "/docs/customization/page-actions",
-		children: [{
-			path: "pageActions.copyMarkdown",
-			name: "copyMarkdown",
-			type: "boolean | PageActionConfig",
-			description: "Show a Copy Markdown action for the current page."
-		}, {
-			path: "pageActions.openDocs",
-			name: "openDocs",
-			type: "boolean | OpenDocsActionConfig",
-			description: "Show provider actions that open the current docs page in an LLM.",
-			children: [
-				{
-					path: "pageActions.openDocs.target",
-					name: "target",
-					type: "\"page\" | \"markdown\"",
-					default: "page",
-					description: "Whether provider URLs receive the rendered page URL or the .md markdown route."
-				},
-				{
-					path: "pageActions.openDocs.providers",
-					name: "providers",
-					type: "Array<string | PromptProviderConfig>",
-					description: "Provider IDs or provider objects. Built-ins include chatgpt, claude, cursor, and t3."
-				},
-				{
-					path: "pageActions.openDocs.prompt",
-					name: "prompt",
-					type: "string",
-					description: "Prompt text prepended to the provider URL when opening docs."
-				}
-			]
-		}]
-	},
-	{
-		path: "ai",
-		name: "ai",
-		type: "AIConfig",
-		description: "RAG-powered Ask AI configuration.",
-		docs: "/docs/customization/ask-ai",
-		children: [
-			{
-				path: "ai.enabled",
-				name: "enabled",
-				type: "boolean",
-				description: "Enable or disable Ask AI."
-			},
-			{
-				path: "ai.model",
-				name: "model",
-				type: "string | AIModelConfig",
-				description: "Model ID or model routing config."
-			},
-			{
-				path: "ai.providers",
-				name: "providers",
-				type: "Record<string, AIProviderConfig>",
-				description: "Provider base URLs and optional API keys."
-			},
-			{
-				path: "ai.systemPrompt",
-				name: "systemPrompt",
-				type: "string",
-				description: "Additional instruction text for generated answers."
-			},
-			{
-				path: "ai.useMcp",
-				name: "useMcp",
-				type: "boolean | DocsAskAIMcpConfig",
-				description: "Use the built-in MCP search tool as Ask AI's retrieval provider."
-			}
-		]
-	},
-	{
-		path: "search",
-		name: "search",
-		type: "boolean | DocsSearchConfig",
-		default: true,
-		description: "Built-in simple search, Typesense, Algolia, MCP, or a custom adapter.",
-		docs: "/docs/customization/search",
-		children: [{
-			path: "search.provider",
-			name: "provider",
-			type: "\"simple\" | \"typesense\" | \"algolia\" | \"mcp\" | \"custom\"",
-			default: "simple",
-			description: "Search backend used by the docs UI and MCP search tool."
-		}, {
-			path: "search.maxResults",
-			name: "maxResults",
-			type: "number",
-			description: "Maximum result count returned by search requests."
-		}]
-	},
-	{
-		path: "cloud",
-		name: "cloud",
-		type: "DocsCloudConfig",
-		description: "Docs Cloud integration settings mirrored into docs.json by cloud CLI commands.",
-		children: [
-			{
-				path: "cloud.apiKey.env",
-				name: "env",
-				type: "string",
-				default: "DOCS_CLOUD_API_KEY",
-				description: "Environment variable that stores the Docs Cloud API key. The key value is never written to docs.json."
-			},
-			{
-				path: "cloud.deploy.enabled",
-				name: "enabled",
-				type: "boolean",
-				default: true,
-				description: "Enable the docs deploy command for hosted preview docs."
-			},
-			{
-				path: "cloud.publish.mode",
-				name: "mode",
-				type: "\"draft-pr\" | \"direct-commit\"",
-				default: "draft-pr",
-				description: "How Docs Cloud publishes generated docs changes."
-			},
-			{
-				path: "cloud.publish.baseBranch",
-				name: "baseBranch",
-				type: "string",
-				default: "main",
-				description: "Branch generated docs work should target."
-			}
-		]
-	},
-	{
-		path: "llmsTxt",
-		name: "llmsTxt",
-		type: "boolean | LlmsTxtConfig",
-		default: true,
-		description: "Generated /llms.txt, /llms-full.txt, optional section files, and basePath-aware aliases.",
-		docs: "/docs/getting-started/agent-ready-docs"
-	},
-	{
-		path: "changelog",
-		name: "changelog",
-		type: "boolean | ChangelogConfig",
-		default: false,
-		description: "Generate changelog feed and entry pages from dated MDX entries.",
-		docs: "/docs/customization/changelog"
-	},
-	{
-		path: "mcp",
-		name: "mcp",
-		type: "boolean | DocsMcpConfig",
-		default: true,
-		description: "Built-in MCP server over stdio plus HTTP routes at /mcp and /.well-known/mcp, backed by /api/docs/mcp.",
-		docs: "/docs/customization/mcp",
-		children: [
-			{
-				path: "mcp.enabled",
-				name: "enabled",
-				type: "boolean",
-				default: true,
-				description: "Enable the built-in MCP server."
-			},
-			{
-				path: "mcp.route",
-				name: "route",
-				type: "string",
-				default: "/api/docs/mcp",
-				description: "Canonical Streamable HTTP route used by the MCP endpoint."
-			},
-			{
-				path: "mcp.name",
-				name: "name",
-				type: "string",
-				default: "nav.title or @farming-labs/docs",
-				description: "Human-readable MCP server name reported to clients."
-			},
-			{
-				path: "mcp.version",
-				name: "version",
-				type: "string",
-				default: "0.0.0",
-				description: "Version string reported to MCP clients."
-			},
-			{
-				path: "mcp.security",
-				name: "security",
-				type: "DocsMcpSecurityConfig",
-				description: "Streamable HTTP Origin validation, optional authentication, and request-size controls. The stdio transport is unaffected.",
-				children: [
-					{
-						path: "mcp.security.allowedOrigins",
-						name: "allowedOrigins",
-						type: "\"same-origin\" | string[] | callback",
-						default: "same-origin",
-						description: "Allow a supplied Origin header when it matches the MCP request origin, an explicit list, or a custom policy callback. Origin-less non-browser clients remain supported."
-					},
-					{
-						path: "mcp.security.authenticate",
-						name: "authenticate",
-						type: "DocsMcpAuthenticate",
-						default: "public (callback omitted)",
-						description: "Opt-in HTTP authentication callback. Return a principal to continue, null for 401, or a Response to control the rejection."
-					},
-					{
-						path: "mcp.security.protectedResource",
-						name: "protectedResource",
-						type: "DocsMcpProtectedResourceConfig",
-						description: "Opt-in RFC 9728 OAuth protected-resource metadata and endpoint-wide scope enforcement. Active only with authenticate.",
-						children: [
-							{
-								path: "mcp.security.protectedResource.authorizationServers",
-								name: "authorizationServers",
-								type: "string[]",
-								description: "One or more HTTPS OAuth issuer URLs without query or fragment; loopback HTTP is accepted for development."
-							},
-							{
-								path: "mcp.security.protectedResource.scopesSupported",
-								name: "scopesSupported",
-								type: "string[]",
-								description: "OAuth scopes advertised through RFC 9728 scopes_supported metadata."
-							},
-							{
-								path: "mcp.security.protectedResource.requiredScopes",
-								name: "requiredScopes",
-								type: "string[]",
-								description: "Scopes required on every principal returned by authenticate; missing scopes receive a challenged 403."
-							},
-							{
-								path: "mcp.security.protectedResource.resourceName",
-								name: "resourceName",
-								type: "string",
-								default: "resolved MCP server name",
-								description: "Human-readable protected-resource name shown during authorization."
-							},
-							{
-								path: "mcp.security.protectedResource.resourceDocumentation",
-								name: "resourceDocumentation",
-								type: "string",
-								description: "Absolute HTTP(S) URL with human-readable authentication guidance."
-							}
-						]
-					},
-					{
-						path: "mcp.security.maxBodyBytes",
-						name: "maxBodyBytes",
-						type: "number",
-						default: DEFAULT_DOCS_MCP_MAX_BODY_BYTES,
-						description: "Maximum accepted Streamable HTTP POST body size in bytes."
-					},
-					{
-						path: "mcp.security.cors",
-						name: "cors",
-						type: "boolean | DocsMcpCorsConfig",
-						default: true,
-						description: "Emit exact-Origin CORS responses for Origins accepted by allowedOrigins. Use an object for credentials, additional headers, and preflight cache controls.",
-						children: [
-							{
-								path: "mcp.security.cors.allowedHeaders",
-								name: "allowedHeaders",
-								type: "string[]",
-								description: "Additional request headers accepted during browser preflight."
-							},
-							{
-								path: "mcp.security.cors.exposedHeaders",
-								name: "exposedHeaders",
-								type: "string[]",
-								description: "Additional MCP response headers exposed to browser JavaScript."
-							},
-							{
-								path: "mcp.security.cors.allowCredentials",
-								name: "allowCredentials",
-								type: "boolean",
-								default: false,
-								description: "Allow credentialed browser requests using the validated exact Origin. Wildcard credentials are never emitted."
-							},
-							{
-								path: "mcp.security.cors.maxAgeSeconds",
-								name: "maxAgeSeconds",
-								type: "number",
-								default: DEFAULT_DOCS_MCP_CORS_MAX_AGE_SECONDS,
-								description: "Browser preflight cache lifetime in seconds."
-							}
-						]
-					}
-				]
-			},
-			{
-				path: "mcp.tools",
-				name: "tools",
-				type: "DocsMcpToolsConfig",
-				default: "all enabled",
-				description: "Fine-grained built-in MCP tool toggles.",
-				children: [
-					{
-						path: "mcp.tools.listDocs",
-						name: "listDocs",
-						type: "boolean",
-						default: true,
-						description: "Expose the list_docs tool."
-					},
-					{
-						path: "mcp.tools.listPages",
-						name: "listPages",
-						type: "boolean",
-						default: true,
-						description: "Expose the list_pages tool."
-					},
-					{
-						path: "mcp.tools.listTasks",
-						name: "listTasks",
-						type: "boolean",
-						default: true,
-						description: "Expose the list_tasks tool."
-					},
-					{
-						path: "mcp.tools.readTask",
-						name: "readTask",
-						type: "boolean",
-						default: true,
-						description: "Expose the read_task tool."
-					},
-					{
-						path: "mcp.tools.getNavigation",
-						name: "getNavigation",
-						type: "boolean",
-						default: true,
-						description: "Expose the get_navigation tool."
-					},
-					{
-						path: "mcp.tools.searchDocs",
-						name: "searchDocs",
-						type: "boolean",
-						default: true,
-						description: "Expose the search_docs tool."
-					},
-					{
-						path: "mcp.tools.readPage",
-						name: "readPage",
-						type: "boolean",
-						default: true,
-						description: "Expose the read_page tool."
-					},
-					{
-						path: "mcp.tools.getCodeExamples",
-						name: "getCodeExamples",
-						type: "boolean",
-						default: true,
-						description: "Expose the get_code_examples tool."
-					},
-					{
-						path: "mcp.tools.getConfigSchema",
-						name: "getConfigSchema",
-						type: "boolean",
-						default: true,
-						description: "Expose the get_config_schema tool."
-					},
-					{
-						path: "mcp.tools.getContext",
-						name: "getContext",
-						type: "boolean",
-						default: true,
-						description: "Expose deterministic get_context retrieval with a conservative UTF-8 byte ceiling."
-					}
-				]
-			}
-		]
-	},
-	{
-		path: "apiReference",
-		name: "apiReference",
-		type: "boolean | ApiReferenceConfig",
-		default: false,
-		description: "Generated API reference pages from framework route conventions or a hosted OpenAPI document.",
-		docs: "/docs/customization/api-reference",
-		children: [{
-			path: "apiReference.specUrl",
-			name: "specUrl",
-			type: "string",
-			description: "Remote OpenAPI JSON URL when the backend owns the schema."
-		}, {
-			path: "apiReference.path",
-			name: "path",
-			type: "string",
-			description: "Docs route where the API reference is rendered."
-		}]
-	},
-	{
-		path: "codeBlocks",
-		name: "codeBlocks",
-		type: "{ validate?: boolean | DocsCodeBlocksValidateConfig }",
-		default: false,
-		description: "Code block intelligence for MD/MDX fences, including execution planning and optional sandboxed validation.",
-		docs: "/docs/configuration#code-block-validation",
-		children: [
-			{
-				path: "codeBlocks.validate",
-				name: "validate",
-				type: "boolean | DocsCodeBlocksValidateConfig",
-				description: "Enable `docs codeblocks validate` for fenced code examples."
-			},
-			{
-				path: "codeBlocks.validate.planner",
-				name: "planner",
-				type: "\"metadata\" | \"openai\" | \"openai-compatible\" | \"cloud\" | DocsCodeBlocksPlannerConfig",
-				default: "metadata",
-				description: "Planner that turns code fence metadata into an execution plan. Use OpenAI-compatible providers when metadata alone is not enough."
-			},
-			{
-				path: "codeBlocks.validate.runner",
-				name: "runner",
-				type: "\"local\" | \"vercel-sandbox\" | \"e2b\" | \"daytona\" | \"cloud\" | DocsCodeBlocksRunnerConfig",
-				default: "local",
-				description: "Runner used to execute planned snippets. Vercel Sandbox, E2B, and Daytona use provider tokens from env vars."
-			},
-			{
-				path: "codeBlocks.validate.env",
-				name: "env",
-				type: "Record<string, string>",
-				description: "Runtime env mapping, for example `{ OPENAI_API_KEY: \"OPENAI_TEST_API_KEY\" }`."
-			}
-		]
-	},
-	{
-		path: "sitemap",
-		name: "sitemap",
-		type: "boolean | DocsSitemapConfig",
-		default: true,
-		description: "Generated sitemap.xml, sitemap.md, /docs/sitemap.md, and /.well-known/sitemap.md."
-	},
-	{
-		path: "robots",
-		name: "robots",
-		type: "boolean | DocsRobotsConfig",
-		default: true,
-		description: "Runtime or generated robots.txt policy for docs routes, agent-readable files, and AI crawler user agents."
-	},
-	{
-		path: "metadata",
-		name: "metadata",
-		type: "DocsMetadata",
-		description: "SEO and JSON-LD inputs such as titleTemplate and description."
-	},
-	{
-		path: "og",
-		name: "og",
-		type: "OGConfig",
-		description: "Dynamic Open Graph image configuration."
-	}
-];
-const DOCS_CONFIG_SCHEMA_OPTIONS = freezeDocsConfigSchemaOptions(DOCS_CONFIG_SCHEMA_OPTIONS_TEMPLATE);
-const DOCS_CONFIG_SCHEMA_EXAMPLES = freezeDocsConfigSchemaExamples([
-	{
-		title: "Minimal config",
-		code: `import { defineDocs } from "@farming-labs/docs";
-import { fumadocs } from "@farming-labs/theme";
-
-export default defineDocs({
-  entry: "docs",
-  theme: fumadocs(),
-});`
-	},
-	{
-		title: "MCP tool toggles",
-		code: `export default defineDocs({
-  entry: "docs",
-  mcp: {
-    tools: {
-      listDocs: true,
-      getConfigSchema: true,
-      getCodeExamples: true,
-    },
-  },
-});`
-	},
-	{
-		title: "Opt-in OAuth MCP authentication",
-		code: `export default defineDocs({
-  mcp: {
-    security: {
-      protectedResource: {
-        authorizationServers: ["https://auth.example.com"],
-        scopesSupported: ["docs:read"],
-        requiredScopes: ["docs:read"],
-      },
-      async authenticate({ request }) {
-        const user = await authenticateRequest(request);
-        return user ? { id: user.id, scopes: user.scopes } : null;
-      },
-    },
-  },
-});`
-	},
-	{
-		title: "Code block validation",
-		code: `export default defineDocs({
-  entry: "docs",
-  codeBlocks: {
-    validate: {
-      planner: {
-        provider: "openai",
-        model: "gpt-4.1-mini",
-        apiKeyEnv: "OPENAI_API_KEY",
-      },
-      runner: {
-        provider: "vercel-sandbox",
-        tokenEnv: "VERCEL_TOKEN",
-      },
-      env: {
-        OPENAI_API_KEY: "OPENAI_TEST_API_KEY",
-      },
-    },
-  },
-});`
-	}
-]);
-const searchDocsInputSchema = z.object({
-	query: z.string().trim().min(1),
-	limit: z.number().int().min(1).max(25).optional(),
-	locale: z.string().min(1).optional()
-});
-const readPageInputSchema = z.object({
-	path: z.string().min(1),
-	locale: z.string().min(1).optional(),
-	section: z.string().trim().min(1).optional(),
-	maxChars: z.number().int().min(256).max(1e6).optional()
-});
-const listTasksInputSchema = z.object({
-	query: z.string().trim().min(1).optional(),
-	framework: z.string().trim().min(1).optional(),
-	version: z.string().trim().min(1).optional(),
-	package: z.string().trim().min(1).optional(),
-	locale: z.string().min(1).optional()
-});
-const readTaskInputSchema = readPageInputSchema;
-const pageAgentAppliesToOutputSchema = z.object({
-	framework: z.array(z.string()).optional(),
-	version: z.array(z.string()).optional(),
-	package: z.array(z.string()).optional()
-});
-const pageAgentCommandOutputSchema = z.union([z.string(), z.object({
-	run: z.string(),
-	cwd: z.string().optional(),
-	description: z.string().optional()
-})]);
-const pageAgentVerificationOutputSchema = z.union([z.string(), z.object({
-	description: z.string().optional(),
-	run: z.string().optional(),
-	expect: z.string().optional()
-})]);
-const pageAgentFailureModeOutputSchema = z.union([z.string(), z.object({
-	symptom: z.string(),
-	resolution: z.string().optional()
-})]);
-const pageAgentContractOutputSchema = z.object({
-	tokenBudget: z.number().optional(),
-	task: z.string().optional(),
-	outcome: z.string().optional(),
-	appliesTo: pageAgentAppliesToOutputSchema.optional(),
-	prerequisites: z.array(z.string()).optional(),
-	files: z.array(z.string()).optional(),
-	commands: z.array(pageAgentCommandOutputSchema).optional(),
-	sideEffects: z.array(z.string()).optional(),
-	verification: z.array(pageAgentVerificationOutputSchema).optional(),
-	rollback: z.array(z.string()).optional(),
-	failureModes: z.array(pageAgentFailureModeOutputSchema).optional()
-});
-const taskSummaryOutputSchema = z.object({
-	slug: z.string(),
-	url: z.string(),
-	title: z.string(),
-	description: z.string().optional(),
-	task: z.string().optional(),
-	outcome: z.string().optional(),
-	appliesTo: pageAgentAppliesToOutputSchema.optional()
-});
-const listTasksOutputSchema = z.object({
-	resultCount: z.number().int().nonnegative(),
-	tasks: z.array(taskSummaryOutputSchema)
-});
-const readTaskOutputSchema = z.object({
-	page: z.object({
-		slug: z.string(),
-		url: z.string(),
-		title: z.string(),
-		description: z.string().optional(),
-		sourcePath: z.string().optional(),
-		lastModified: z.string().optional()
-	}),
-	contract: pageAgentContractOutputSchema
-});
-const listPagesInputSchema = z.object({ locale: z.string().min(1).optional() });
-const listDocsInputSchema = z.object({
-	section: z.string().trim().min(1).optional(),
-	locale: z.string().min(1).optional()
-});
-const getNavigationInputSchema = z.object({ locale: z.string().min(1).optional() });
-const getConfigSchemaInputSchema = z.object({
-	option: z.string().trim().min(1).optional(),
-	query: z.string().trim().min(1).optional()
-});
-const getCodeExamplesInputSchema = z.object({
-	query: z.string().trim().min(1).optional(),
-	path: z.string().min(1).optional(),
-	framework: z.string().trim().min(1).optional(),
-	packageManager: z.string().trim().min(1).optional(),
-	language: z.string().trim().min(1).optional(),
-	runnable: z.boolean().optional(),
-	limit: z.number().int().min(1).max(50).optional(),
-	locale: z.string().min(1).optional()
-});
-const getContextInputSchema = z.object({
-	query: z.string().trim().min(1),
-	framework: z.string().trim().min(1).optional(),
-	version: z.string().trim().min(1).optional(),
-	locale: z.string().trim().min(1).optional(),
-	tokenBudget: z.number().int().min(MIN_MCP_CONTEXT_TOKEN_BUDGET).max(MAX_MCP_CONTEXT_TOKEN_BUDGET).default(DEFAULT_MCP_CONTEXT_TOKEN_BUDGET)
-});
-const relatedLinkOutputSchema = z.object({ href: z.string() });
-const pageAgentContractSummaryOutputSchema = z.object({
-	hasContract: z.boolean(),
-	task: z.string().optional(),
-	outcome: z.string().optional(),
-	appliesTo: pageAgentAppliesToOutputSchema.optional()
-});
-const pageSummaryOutputSchema = z.object({
-	slug: z.string(),
-	url: z.string(),
-	title: z.string(),
-	description: z.string().optional(),
-	agent: pageAgentContractSummaryOutputSchema.optional(),
-	icon: z.string().optional(),
-	sourcePath: z.string().optional(),
-	lastModified: z.string().optional()
-});
-const docsSectionOutputSchema = z.lazy(() => z.object({
-	slug: z.string(),
-	title: z.string(),
-	url: z.string().optional(),
-	description: z.string().optional(),
-	icon: z.string().optional(),
-	pageCount: z.number().int().nonnegative(),
-	pages: z.array(pageSummaryOutputSchema),
-	sections: z.array(docsSectionOutputSchema)
-}));
-const listPagesOutputSchema = z.object({ pages: z.array(pageSummaryOutputSchema) });
-const listDocsOutputSchema = z.object({
-	section: z.string().optional(),
-	resultCount: z.number().int().nonnegative(),
-	sectionCount: z.number().int().nonnegative(),
-	pages: z.array(pageSummaryOutputSchema),
-	rootPages: z.array(pageSummaryOutputSchema),
-	sections: z.array(docsSectionOutputSchema)
-});
-const navigationPageOutputSchema = z.object({
-	type: z.literal("page"),
-	name: z.string(),
-	url: z.string(),
-	icon: z.string().optional(),
-	description: z.string().optional()
-});
-const navigationNodeOutputSchema = z.lazy(() => z.discriminatedUnion("type", [navigationPageOutputSchema, z.object({
-	type: z.literal("folder"),
-	name: z.string(),
-	icon: z.string().optional(),
-	index: navigationPageOutputSchema.optional(),
-	children: z.array(navigationNodeOutputSchema)
-})]));
-const navigationOutputSchema = z.object({
-	navigation: z.object({
-		name: z.string(),
-		children: z.array(navigationNodeOutputSchema)
-	}),
-	markdown: z.string()
-});
-const searchResultOutputSchema = z.object({
-	id: z.string(),
-	url: z.string(),
-	content: z.string(),
-	description: z.string().optional(),
-	type: z.enum([
-		"page",
-		"heading",
-		"text"
-	]),
-	score: z.number().optional(),
-	section: z.string().optional()
-});
-const searchDocsOutputSchema = z.object({ results: z.array(searchResultOutputSchema) });
-const codeExampleOutputSchema = z.object({
-	id: z.string(),
-	page: z.object({
-		slug: z.string(),
-		url: z.string(),
-		title: z.string(),
-		description: z.string().optional(),
-		sourcePath: z.string().optional(),
-		lastModified: z.string().optional()
-	}),
-	language: z.string().optional(),
-	title: z.string().optional(),
-	framework: z.string().optional(),
-	packageManager: z.string().optional(),
-	runnable: z.boolean(),
-	meta: z.record(z.string(), z.union([z.string(), z.boolean()])),
-	code: z.string()
-});
-const codeExamplesOutputSchema = z.object({ examples: z.array(codeExampleOutputSchema) });
-const configSchemaOptionOutputSchema = z.lazy(() => z.object({
-	path: z.string(),
-	name: z.string(),
-	type: z.string(),
-	default: z.union([
-		z.string(),
-		z.boolean(),
-		z.number(),
-		z.null()
-	]).optional(),
-	description: z.string(),
-	docs: z.string().optional(),
-	values: z.array(z.string()).optional(),
-	children: z.array(configSchemaOptionOutputSchema).optional()
-}));
-const configSchemaOutputSchema = z.object({
-	schemaVersion: z.literal(1),
-	configFile: z.literal("docs.config.ts"),
-	description: z.string(),
-	filters: z.object({
-		option: z.string().optional(),
-		query: z.string().optional()
-	}).optional(),
-	resultCount: z.number().int().nonnegative(),
-	options: z.array(configSchemaOptionOutputSchema),
-	examples: z.array(z.object({
-		title: z.string(),
-		code: z.string()
-	}))
-});
-const readPageOutputSchema = z.object({
-	page: z.object({
-		slug: z.string(),
-		url: z.string(),
-		title: z.string(),
-		description: z.string().optional(),
-		related: z.array(relatedLinkOutputSchema).optional(),
-		icon: z.string().optional(),
-		sourcePath: z.string().optional(),
-		lastModified: z.string().optional(),
-		locale: z.string().optional(),
-		framework: z.string().optional(),
-		version: z.string().optional(),
-		tags: z.array(z.string()).optional()
-	}),
-	document: z.string(),
-	section: z.string().optional(),
-	anchor: z.string().optional(),
-	chars: z.number().int().nonnegative(),
-	totalChars: z.number().int().nonnegative(),
-	truncated: z.boolean()
-});
-const contextSourceOutputSchema = z.object({
-	id: z.string(),
-	title: z.string(),
-	pageUrl: z.string(),
-	url: z.string(),
-	section: z.string().optional(),
-	anchor: z.string().optional(),
-	sourcePath: z.string().optional(),
-	lastModified: z.string().optional(),
-	locale: z.string().optional(),
-	framework: z.string().optional(),
-	version: z.string().optional(),
-	tags: z.array(z.string()).optional(),
-	score: z.number().optional(),
-	content: z.string(),
-	chars: z.number().int().nonnegative(),
-	utf8Bytes: z.number().int().nonnegative(),
-	truncated: z.boolean()
-});
-const contextOutputSchema = z.object({
-	query: z.string(),
-	filters: z.object({
-		framework: z.string().optional(),
-		version: z.string().optional(),
-		locale: z.string().optional()
-	}),
-	budget: z.object({
-		requestedTokens: z.number().int().positive(),
-		strategy: z.literal("utf8-bytes"),
-		maxUtf8Bytes: z.number().int().positive(),
-		usedUtf8Bytes: z.number().int().nonnegative(),
-		conservativeTokenUpperBound: z.number().int().nonnegative(),
-		remainingUtf8Bytes: z.number().int().nonnegative(),
-		truncated: z.boolean()
-	}),
-	resultCount: z.number().int().nonnegative(),
-	candidateCount: z.number().int().nonnegative(),
-	context: z.string(),
-	sources: z.array(contextSourceOutputSchema)
-});
-function normalizeDocsMcpRoute(route) {
-	return normalizeDocsMcpEndpointPath(route);
-}
-function resolveDocsMcpConfig(mcp, defaults = {}) {
-	if (mcp === false) return {
-		enabled: false,
-		route: normalizeDocsMcpRoute(defaults.defaultRoute),
-		name: defaults.defaultName ?? DEFAULT_MCP_NAME,
-		version: defaults.defaultVersion ?? DEFAULT_MCP_VERSION,
-		tools: {
-			listDocs: true,
-			listPages: true,
-			readPage: true,
-			listTasks: true,
-			readTask: true,
-			searchDocs: true,
-			getNavigation: true,
-			getCodeExamples: true,
-			getConfigSchema: true,
-			getContext: true
-		},
-		security: resolveDocsMcpSecurityConfig()
-	};
-	const config = mcp && typeof mcp === "object" ? mcp : {};
-	return {
-		enabled: typeof mcp === "boolean" ? mcp : config.enabled ?? true,
-		route: normalizeDocsMcpRoute(config.route ?? defaults.defaultRoute),
-		name: config.name ?? defaults.defaultName ?? DEFAULT_MCP_NAME,
-		version: config.version ?? defaults.defaultVersion ?? DEFAULT_MCP_VERSION,
-		tools: {
-			listDocs: config.tools?.listDocs ?? true,
-			listPages: config.tools?.listPages ?? true,
-			readPage: config.tools?.readPage ?? true,
-			listTasks: config.tools?.listTasks ?? true,
-			readTask: config.tools?.readTask ?? true,
-			searchDocs: config.tools?.searchDocs ?? true,
-			getNavigation: config.tools?.getNavigation ?? true,
-			getCodeExamples: config.tools?.getCodeExamples ?? true,
-			getConfigSchema: config.tools?.getConfigSchema ?? true,
-			getContext: config.tools?.getContext ?? true
-		},
-		security: resolveDocsMcpSecurityConfig(config.security)
-	};
-}
-function resolveDocsMcpSecurityConfig(security) {
-	const configuredMaxBodyBytes = security?.maxBodyBytes;
-	const maxBodyBytes = typeof configuredMaxBodyBytes === "number" && Number.isFinite(configuredMaxBodyBytes) && configuredMaxBodyBytes > 0 ? Math.floor(configuredMaxBodyBytes) : DEFAULT_DOCS_MCP_MAX_BODY_BYTES;
-	return {
-		allowedOrigins: security?.allowedOrigins ?? "same-origin",
-		authenticate: security?.authenticate,
-		protectedResource: resolveDocsMcpProtectedResourceConfig(security?.protectedResource),
-		maxBodyBytes,
-		cors: resolveDocsMcpCorsConfig(security?.cors)
-	};
-}
-function resolveDocsMcpProtectedResourceConfig(config) {
-	if (!config || typeof config !== "object") return void 0;
-	const configuredAuthorizationServers = config.authorizationServers;
-	if (!Array.isArray(configuredAuthorizationServers) || configuredAuthorizationServers.length === 0 || configuredAuthorizationServers.some((value) => typeof value !== "string" || value.trim().length === 0)) throw new TypeError("mcp.security.protectedResource.authorizationServers must contain at least one authorization server issuer URL.");
-	const authorizationServerCandidates = normalizeMcpStringList(configuredAuthorizationServers);
-	const authorizationServers = normalizeDocsMcpAuthorizationServerUrls(authorizationServerCandidates);
-	if (authorizationServers.length !== authorizationServerCandidates.length) throw new TypeError("mcp.security.protectedResource.authorizationServers must use HTTPS issuer URLs without query strings or fragments; HTTP is allowed only for loopback development.");
-	const resourceName = normalizeMcpOptionalString(config.resourceName);
-	const resourceDocumentation = normalizeMcpOptionalHttpUrl(config.resourceDocumentation);
-	if (config.resourceDocumentation !== void 0 && !resourceDocumentation) throw new TypeError("mcp.security.protectedResource.resourceDocumentation must be an absolute HTTP or HTTPS URL.");
-	return {
-		authorizationServers,
-		scopesSupported: normalizeMcpScopeList(config.scopesSupported, "mcp.security.protectedResource.scopesSupported"),
-		requiredScopes: normalizeMcpScopeList(config.requiredScopes, "mcp.security.protectedResource.requiredScopes"),
-		...resourceName ? { resourceName } : {},
-		...resourceDocumentation ? { resourceDocumentation } : {}
-	};
-}
-function normalizeMcpStringList(values) {
-	if (!Array.isArray(values)) return [];
-	return Array.from(new Set(values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)));
-}
-function normalizeMcpScopeList(values, path) {
-	if (values === void 0) return [];
-	if (!Array.isArray(values) || values.some((value) => typeof value !== "string" || !isDocsMcpOAuthScopeToken(value.trim()))) throw new TypeError(`${path} must contain valid OAuth scope tokens.`);
-	return normalizeMcpStringList(values);
-}
-function normalizeMcpOptionalString(value) {
-	if (typeof value !== "string") return void 0;
-	return value.trim() || void 0;
-}
-function normalizeMcpOptionalHttpUrl(value) {
-	const normalized = normalizeMcpOptionalString(value);
-	if (!normalized) return void 0;
-	try {
-		const url = new URL(normalized);
-		return (url.protocol === "https:" || url.protocol === "http:") && !url.username && !url.password ? normalized : void 0;
-	} catch {
-		return;
-	}
-}
-function resolveDocsMcpCorsConfig(cors) {
-	const config = cors && typeof cors === "object" ? cors : {};
-	const configuredMaxAge = config.maxAgeSeconds;
-	const maxAgeSeconds = typeof configuredMaxAge === "number" && Number.isFinite(configuredMaxAge) && configuredMaxAge >= 0 ? Math.floor(configuredMaxAge) : DEFAULT_DOCS_MCP_CORS_MAX_AGE_SECONDS;
-	return {
-		enabled: cors !== false,
-		allowedHeaders: mergeHttpHeaderNames(DEFAULT_DOCS_MCP_CORS_ALLOWED_HEADERS, config.allowedHeaders),
-		exposedHeaders: mergeHttpHeaderNames(DEFAULT_DOCS_MCP_CORS_EXPOSED_HEADERS, config.exposedHeaders),
-		allowCredentials: config.allowCredentials === true,
-		maxAgeSeconds
-	};
-}
-function mergeHttpHeaderNames(defaults, configured) {
-	const headers = /* @__PURE__ */ new Map();
-	for (const header of [...defaults, ...configured ?? []]) {
-		const normalized = header.trim();
-		if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(normalized)) continue;
-		const key = normalized.toLowerCase();
-		if (!headers.has(key)) headers.set(key, normalized);
-	}
-	return [...headers.values()];
-}
-function createFilesystemDocsMcpSource(options = {}) {
-	const rootDir = options.rootDir ?? process.cwd();
-	const entry = normalizePathSegment(options.entry ?? "docs") || "docs";
-	const contentDir = options.contentDir ?? entry;
-	const contentDirAbs = path.resolve(rootDir, contentDir);
-	const cache = /* @__PURE__ */ new Map();
-	const navigationCache = /* @__PURE__ */ new Map();
-	function getPages() {
-		const cached = cache.get("__default__");
-		if (cached) return cached;
-		const pages = scanFilesystemDocsPages(contentDirAbs, entry, rootDir);
-		cache.set("__default__", pages);
-		return pages;
-	}
-	function getNavigation() {
-		const cached = navigationCache.get("__default__");
-		if (cached) return cached;
-		const tree = buildNavigationTreeFromPages(getPages(), options.siteTitle ?? "Documentation", options.ordering);
-		navigationCache.set("__default__", tree);
-		return tree;
-	}
-	return {
-		entry,
-		siteTitle: options.siteTitle ?? "Documentation",
-		getPages,
-		getNavigation
-	};
-}
-function nowMs() {
-	return Date.now();
-}
-function durationMs(startedAt) {
-	return Math.max(0, Date.now() - startedAt);
-}
-function createStructuredTextResult(structuredContent, text) {
-	return {
-		content: [{
-			type: "text",
-			text: text ?? JSON.stringify(structuredContent, null, 2)
-		}],
-		structuredContent
-	};
-}
-async function createDocsMcpServer(options) {
-	const resolved = resolveDocsMcpConfig(options.mcp, {
-		defaultName: options.defaultName ?? options.source.siteTitle ?? DEFAULT_MCP_NAME,
-		defaultVersion: options.defaultVersion
-	});
-	const toolSearchConfig = resolveMcpToolSearchConfig(options.search, resolved.route);
-	const server = new McpServer({
-		name: resolved.name,
-		version: resolved.version
-	});
-	const telemetryConfig = {
-		telemetry: options.telemetry,
-		mcp: options.mcp,
-		search: options.search
-	};
-	const telemetryFramework = options.telemetryFramework ?? "mcp";
-	function getSourcePages(locale) {
-		return options.source.getPages(locale, options.requestContext);
-	}
-	function getSourceNavigation(locale) {
-		return options.source.getNavigation(locale, options.requestContext);
-	}
-	function getSourceSkills() {
-		return options.source.getSkills?.(options.requestContext) ?? [];
-	}
-	function trackMcpTool(tool, values) {
-		emitDocsTelemetryMcpToolEvent(telemetryConfig, {
-			framework: telemetryFramework,
-			request: options.requestContext?.request,
-			tool,
-			locale: values?.locale,
-			resultCount: values?.resultCount
-		});
-	}
-	const defaultPages = dedupePages(await getSourcePages());
-	const defaultTree = await getSourceNavigation();
-	const defaultSkills = await getSourceSkills();
-	server.registerResource("docs-navigation", "docs://navigation", {
-		title: "Docs Navigation",
-		description: "Structured navigation tree for the documentation site.",
-		mimeType: "text/plain"
-	}, async () => ({ contents: [{
-		uri: "docs://navigation",
-		mimeType: "text/plain",
-		text: renderNavigationTree(defaultTree)
-	}] }));
-	for (const page of defaultPages) {
-		const resourceUri = toPageResourceUri(page.url);
-		server.registerResource(`page-${slugToKey(page.slug)}`, resourceUri, {
-			title: page.title,
-			description: page.description,
-			mimeType: "text/markdown"
-		}, async () => ({ contents: [{
-			uri: resourceUri,
-			mimeType: "text/markdown",
-			text: renderPageDocument(page)
-		}] }));
-	}
-	for (const skill of defaultSkills) for (const file of skill.files) {
-		const encodedPath = file.path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-		const resourceUri = `docs://skills/${encodeURIComponent(skill.name)}/${encodedPath}`;
-		server.registerResource(`skill-${encodeURIComponent(skill.name)}-${Buffer.from(file.path).toString("base64url")}`, resourceUri, {
-			title: `${skill.name}: ${file.path}`,
-			description: `${skill.description} (${file.digest})`,
-			mimeType: file.mediaType
-		}, async () => ({ contents: [typeof file.content === "string" ? {
-			uri: resourceUri,
-			mimeType: file.mediaType,
-			text: file.content
-		} : {
-			uri: resourceUri,
-			mimeType: file.mediaType,
-			blob: Buffer.from(file.content).toString("base64")
-		}] }));
-	}
-	if (resolved.tools.listPages) server.registerTool("list_pages", {
-		title: "List docs pages",
-		description: "List the known documentation pages with titles, slugs, and URLs.",
-		inputSchema: listPagesInputSchema,
-		outputSchema: listPagesOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ locale }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.list_pages");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "list_pages",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: { locale },
-			metadata: { tool: "list_pages" }
-		});
-		try {
-			const pages = toPageSummaries(dedupePages(await getSourcePages(locale)));
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				properties: {
-					tool: "list_pages",
-					resultCount: pages.length,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("list_pages", {
-				locale,
-				resultCount: pages.length
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_pages",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: { resultCount: pages.length },
-				metadata: { tool: "list_pages" }
-			});
-			return createStructuredTextResult({ pages });
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_pages",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "list_pages" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.listDocs) server.registerTool("list_docs", {
-		title: "List docs by section",
-		description: "List documentation pages grouped by section, optionally narrowed to one section.",
-		inputSchema: listDocsInputSchema,
-		outputSchema: listDocsOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ section, locale }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.list_docs");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "list_docs",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				section,
-				locale
-			},
-			metadata: { tool: "list_docs" }
-		});
-		try {
-			const docs = listDocsBySection(dedupePages(await getSourcePages(locale)), {
-				section,
-				entry: options.source.entry
-			});
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				properties: {
-					tool: "list_docs",
-					section,
-					resultCount: docs.resultCount,
-					sectionCount: docs.sectionCount,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("list_docs", {
-				locale,
-				resultCount: docs.resultCount
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_docs",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: {
-					resultCount: docs.resultCount,
-					sectionCount: docs.sectionCount
-				},
-				metadata: { tool: "list_docs" }
-			});
-			return createStructuredTextResult(docs);
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_docs",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "list_docs" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.listTasks) server.registerTool("list_tasks", {
-		title: "List documented tasks",
-		description: "List pages with actionable agent contracts, optionally filtered by text or applicability.",
-		inputSchema: listTasksInputSchema,
-		outputSchema: listTasksOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ query, framework, version, package: packageName, locale }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.list_tasks");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "list_tasks",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				queryLength: query?.length,
-				framework,
-				version,
-				package: packageName
-			},
-			metadata: { tool: "list_tasks" }
-		});
-		try {
-			const tasks = listDocsTasks(dedupePages(await getSourcePages(locale)), {
-				query,
-				framework,
-				version,
-				package: packageName
-			});
-			const result = {
-				resultCount: tasks.length,
-				tasks
-			};
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				input: query ? { query } : void 0,
-				properties: {
-					tool: "list_tasks",
-					framework,
-					version,
-					package: packageName,
-					resultCount: tasks.length,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("list_tasks", {
-				locale,
-				resultCount: tasks.length
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_tasks",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: { resultCount: tasks.length },
-				metadata: { tool: "list_tasks" }
-			});
-			return {
-				structuredContent: result,
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}]
-			};
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "list_tasks",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "list_tasks" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.readTask) server.registerTool("read_task", {
-		title: "Read a documented task",
-		description: "Read the full structured agent contract for a page by slug or URL path.",
-		inputSchema: readTaskInputSchema,
-		outputSchema: readTaskOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ path: requestedPath, locale }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.read_task");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "read_task",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				path: requestedPath,
-				locale
-			},
-			metadata: { tool: "read_task" }
-		});
-		try {
-			const page = findDocsPage(dedupePages(await getSourcePages(locale)), requestedPath, options.source.entry);
-			const contract = normalizePageAgentFrontmatter(page?.agent);
-			if (!page || !contract || !hasStructuredPageAgentContract(contract)) {
-				const elapsed = durationMs(startedAt);
-				const reason = page ? "contract_not_found" : "page_not_found";
-				const errorResult = { error: page ? `The docs page matched "${requestedPath}", but it has no actionable agent contract.` : `No docs page matched "${requestedPath}".` };
-				await emitDocsAnalyticsEvent(options.analytics, {
-					type: "mcp_tool",
-					source: "mcp",
-					locale,
-					properties: {
-						tool: "read_task",
-						path: requestedPath,
-						found: false,
-						reason,
-						durationMs: elapsed
-					}
-				});
-				trackMcpTool("read_task", {
-					locale,
-					resultCount: 0
-				});
-				await emitDocsAgentTraceEvent(options.observability, {
-					type: "tool.error",
-					source: "mcp",
-					traceId: trace.traceId,
-					parentSpanId: callSpanId,
-					name: "read_task",
-					startedAt: trace.startedAt,
-					endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					durationMs: elapsed,
-					status: "error",
-					locale,
-					outputPreview: {
-						found: false,
-						path: requestedPath
-					},
-					metadata: {
-						tool: "read_task",
-						reason
-					}
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify(errorResult, null, 2)
-					}],
-					isError: true
-				};
-			}
-			const result = {
-				page: {
-					slug: page.slug,
-					url: page.url,
-					title: page.title,
-					...page.description ? { description: page.description } : {},
-					...page.sourcePath ? { sourcePath: page.sourcePath } : {},
-					...page.lastModified ? { lastModified: page.lastModified } : {}
-				},
-				contract
-			};
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				path: page.url,
-				properties: {
-					tool: "read_task",
-					requestedPath,
-					slug: page.slug,
-					found: true,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("read_task", {
-				locale,
-				resultCount: 1
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "read_task",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				path: page.url,
-				outputPreview: {
-					found: true,
-					slug: page.slug
-				},
-				metadata: { tool: "read_task" }
-			});
-			return {
-				structuredContent: result,
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}]
-			};
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "read_task",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "read_task" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.getNavigation) server.registerTool("get_navigation", {
-		title: "Get docs navigation",
-		description: "Return the documentation navigation tree for the current docs site.",
-		inputSchema: getNavigationInputSchema,
-		outputSchema: navigationOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ locale }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.get_navigation");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "get_navigation",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: { locale },
-			metadata: { tool: "get_navigation" }
-		});
-		try {
-			const tree = await getSourceNavigation(locale);
-			const text = renderNavigationTree(tree);
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				properties: {
-					tool: "get_navigation",
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("get_navigation", { locale });
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_navigation",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: { chars: text.length },
-				metadata: { tool: "get_navigation" }
-			});
-			return createStructuredTextResult({
-				navigation: tree,
-				markdown: text
-			}, text);
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_navigation",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "get_navigation" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.getConfigSchema) server.registerTool("get_config_schema", {
-		title: "Get docs config schema",
-		description: "Return structured docs.config.ts option metadata, optionally filtered by option path or query.",
-		inputSchema: getConfigSchemaInputSchema,
-		outputSchema: configSchemaOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ option, query }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.get_config_schema");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "get_config_schema",
-			startedAt: trace.startedAt,
-			status: "started",
-			inputPreview: {
-				option,
-				queryLength: query?.length
-			},
-			metadata: { tool: "get_config_schema" }
-		});
-		try {
-			const schema = getDocsConfigSchema({
-				option,
-				query
-			});
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				input: query ? { query } : void 0,
-				properties: {
-					tool: "get_config_schema",
-					option,
-					queryLength: query?.length,
-					resultCount: schema.resultCount,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("get_config_schema", { resultCount: schema.resultCount });
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_config_schema",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				outputPreview: { resultCount: schema.resultCount },
-				metadata: { tool: "get_config_schema" }
-			});
-			return createStructuredTextResult(schema);
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_config_schema",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "get_config_schema" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.searchDocs) server.registerTool("search_docs", {
-		title: "Search documentation",
-		description: "Search the docs by keyword across titles, descriptions, and page content.",
-		inputSchema: searchDocsInputSchema,
-		outputSchema: searchDocsOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ query, limit, locale }) => {
-		const startedAt = nowMs();
-		const resolvedLimit = limit ?? 10;
-		const trace = createDocsAgentTraceContext("mcp.tool.search_docs");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "search_docs",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				queryLength: query.length,
-				limit: resolvedLimit,
-				locale
-			},
-			metadata: { tool: "search_docs" }
-		});
-		try {
-			const results = await performDocsSearch({
-				pages: toSearchSourcePages(dedupePages(await getSourcePages(locale))),
-				query,
-				search: toolSearchConfig ?? true,
-				audience: "agent",
-				locale,
-				siteTitle: options.source.siteTitle,
-				limit: resolvedLimit
-			});
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				input: { query },
-				properties: {
-					tool: "search_docs",
-					queryLength: query.length,
-					limit: resolvedLimit,
-					resultCount: results.length,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("search_docs", {
-				locale,
-				resultCount: results.length
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "search_docs",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: { resultCount: results.length },
-				metadata: { tool: "search_docs" }
-			});
-			return createStructuredTextResult({ results });
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "search_docs",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "search_docs" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.getCodeExamples) server.registerTool("get_code_examples", {
-		title: "Get docs code examples",
-		description: "Return fenced code examples from the docs with parsed metadata such as title, framework, packageManager, and runnable.",
-		inputSchema: getCodeExamplesInputSchema,
-		outputSchema: codeExamplesOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ query, path: requestedPath, framework, packageManager, language, runnable, limit, locale }) => {
-		const startedAt = nowMs();
-		const resolvedLimit = limit ?? 25;
-		const trace = createDocsAgentTraceContext("mcp.tool.get_code_examples");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "get_code_examples",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				queryLength: query?.length,
-				path: requestedPath,
-				framework,
-				packageManager,
-				language,
-				runnable,
-				limit: resolvedLimit
-			},
-			metadata: { tool: "get_code_examples" }
-		});
-		try {
-			const pages = dedupePages(await getSourcePages(locale));
-			const matchedPage = requestedPath ? findDocsPage(pages, requestedPath, options.source.entry) : null;
-			const examples = filterDocsCodeExamples((requestedPath ? matchedPage ? [matchedPage] : [] : pages).flatMap((page) => extractDocsMcpCodeExamples(page)), {
-				query,
-				framework,
-				packageManager,
-				language,
-				runnable,
-				limit: resolvedLimit
-			});
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				input: query ? { query } : void 0,
-				properties: {
-					tool: "get_code_examples",
-					queryLength: query?.length,
-					path: requestedPath,
-					framework,
-					packageManager,
-					language,
-					runnable,
-					limit: resolvedLimit,
-					resultCount: examples.length,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("get_code_examples", {
-				locale,
-				resultCount: examples.length
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_code_examples",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: { resultCount: examples.length },
-				metadata: { tool: "get_code_examples" }
-			});
-			return createStructuredTextResult({ examples });
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_code_examples",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "get_code_examples" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.getContext) server.registerTool("get_context", {
-		title: "Get budgeted docs context",
-		description: "Build deterministic, section-level documentation context for a query within a conservative UTF-8 byte ceiling derived from the requested token budget, with source URLs and accounting metadata.",
-		inputSchema: getContextInputSchema,
-		outputSchema: contextOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ query, framework, version, locale, tokenBudget }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.get_context");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "get_context",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				queryLength: query.length,
-				framework,
-				version,
-				locale,
-				tokenBudget
-			},
-			metadata: { tool: "get_context" }
-		});
-		try {
-			const result = await buildDocsMcpContext({
-				pages: dedupePages(await getSourcePages(locale)),
-				query,
-				framework,
-				version,
-				locale,
-				tokenBudget,
-				entry: options.source.entry,
-				siteTitle: options.source.siteTitle
-			});
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				input: { query },
-				properties: {
-					tool: "get_context",
-					queryLength: query.length,
-					framework,
-					version,
-					tokenBudget,
-					usedUtf8Bytes: result.budget.usedUtf8Bytes,
-					conservativeTokenUpperBound: result.budget.conservativeTokenUpperBound,
-					truncated: result.budget.truncated,
-					resultCount: result.resultCount,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("get_context", {
-				locale,
-				resultCount: result.resultCount
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_context",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				outputPreview: {
-					resultCount: result.resultCount,
-					candidateCount: result.candidateCount,
-					utf8Bytes: result.budget.usedUtf8Bytes,
-					conservativeTokenUpperBound: result.budget.conservativeTokenUpperBound,
-					truncated: result.budget.truncated
-				},
-				metadata: { tool: "get_context" }
-			});
-			return createStructuredTextResult(result, result.context || JSON.stringify(result, null, 2));
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "get_context",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "get_context" }
-			});
-			throw error;
-		}
-	});
-	if (resolved.tools.readPage) server.registerTool("read_page", {
-		title: "Read a docs page",
-		description: "Read a documentation page by slug or URL path, optionally selecting one heading and limiting returned characters.",
-		inputSchema: readPageInputSchema,
-		outputSchema: readPageOutputSchema,
-		annotations: { readOnlyHint: true }
-	}, async ({ path: requestedPath, locale, section, maxChars }) => {
-		const startedAt = nowMs();
-		const trace = createDocsAgentTraceContext("mcp.tool.read_page");
-		const callSpanId = createDocsAgentTraceId("span");
-		await emitDocsAgentTraceEvent(options.observability, {
-			type: "tool.call",
-			source: "mcp",
-			traceId: trace.traceId,
-			spanId: callSpanId,
-			name: "read_page",
-			startedAt: trace.startedAt,
-			status: "started",
-			locale,
-			inputPreview: {
-				path: requestedPath,
-				locale,
-				section,
-				maxChars
-			},
-			metadata: { tool: "read_page" }
-		});
-		try {
-			const page = findDocsPage(dedupePages(await getSourcePages(locale)), requestedPath, options.source.entry);
-			if (!page) {
-				const elapsed = durationMs(startedAt);
-				await emitDocsAnalyticsEvent(options.analytics, {
-					type: "agent_read",
-					source: "mcp",
-					locale,
-					properties: {
-						delivery: "mcp_tool",
-						tool: "read_page",
-						requestedPath,
-						found: false,
-						durationMs: elapsed
-					}
-				});
-				await emitDocsAnalyticsEvent(options.analytics, {
-					type: "mcp_tool",
-					source: "mcp",
-					locale,
-					properties: {
-						tool: "read_page",
-						path: requestedPath,
-						found: false,
-						durationMs: elapsed
-					}
-				});
-				trackMcpTool("read_page", {
-					locale,
-					resultCount: 0
-				});
-				await emitDocsAgentTraceEvent(options.observability, {
-					type: "tool.error",
-					source: "mcp",
-					traceId: trace.traceId,
-					parentSpanId: callSpanId,
-					name: "read_page",
-					startedAt: trace.startedAt,
-					endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					durationMs: elapsed,
-					status: "error",
-					locale,
-					outputPreview: {
-						found: false,
-						path: requestedPath
-					},
-					metadata: {
-						tool: "read_page",
-						reason: "not_found"
-					}
-				});
-				return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({ error: `No docs page matched "${requestedPath}".` }, null, 2)
-					}],
-					isError: true
-				};
-			}
-			const fullDocument = renderPageDocument(page);
-			const sectionDocument = getDocsMcpSourceMarkdown(page);
-			const selectedSection = section ? findDocsMarkdownSection(sectionDocument, section) ?? (sectionDocument !== fullDocument ? findDocsMarkdownSection(fullDocument, section) : void 0) : void 0;
-			if (section && !selectedSection) {
-				const sourceSections = parseDocsMarkdownSections(sectionDocument);
-				const availableSections = (sourceSections.length > 0 ? sourceSections : parseDocsMarkdownSections(fullDocument)).map((item) => ({
-					title: item.title,
-					anchor: item.anchor
-				}));
-				const errorText = renderBoundedDocsMcpSectionError({
-					requestedSection: section,
-					pageUrl: page.url,
-					availableSections,
-					maxChars
-				});
-				const elapsed = durationMs(startedAt);
-				trackMcpTool("read_page", {
-					locale,
-					resultCount: 0
-				});
-				await emitDocsAgentTraceEvent(options.observability, {
-					type: "tool.error",
-					source: "mcp",
-					traceId: trace.traceId,
-					parentSpanId: callSpanId,
-					name: "read_page",
-					startedAt: trace.startedAt,
-					endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					durationMs: elapsed,
-					status: "error",
-					locale,
-					path: page.url,
-					outputPreview: {
-						found: true,
-						sectionFound: false,
-						section
-					},
-					metadata: {
-						tool: "read_page",
-						reason: "section_not_found"
-					}
-				});
-				return {
-					content: [{
-						type: "text",
-						text: errorText
-					}],
-					isError: true
-				};
-			}
-			const selectedDocument = selectedSection?.content ?? fullDocument;
-			const limitedDocument = limitDocsMcpText(selectedDocument, maxChars);
-			const document = limitedDocument.text;
-			const elapsed = durationMs(startedAt);
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "agent_read",
-				source: "mcp",
-				locale,
-				path: page.url,
-				properties: {
-					delivery: "mcp_tool",
-					tool: "read_page",
-					requestedPath,
-					slug: page.slug,
-					found: true,
-					section: selectedSection?.title,
-					contentLength: document.length,
-					totalContentLength: selectedDocument.length,
-					truncated: limitedDocument.truncated,
-					durationMs: elapsed
-				}
-			});
-			await emitDocsAnalyticsEvent(options.analytics, {
-				type: "mcp_tool",
-				source: "mcp",
-				locale,
-				path: page.url,
-				properties: {
-					tool: "read_page",
-					requestedPath,
-					slug: page.slug,
-					found: true,
-					section: selectedSection?.title,
-					contentLength: document.length,
-					totalContentLength: selectedDocument.length,
-					truncated: limitedDocument.truncated,
-					durationMs: elapsed
-				}
-			});
-			trackMcpTool("read_page", {
-				locale,
-				resultCount: 1
-			});
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.result",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "read_page",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "success",
-				locale,
-				path: page.url,
-				outputPreview: {
-					found: true,
-					chars: document.length,
-					totalChars: selectedDocument.length,
-					truncated: limitedDocument.truncated,
-					section: selectedSection?.title,
-					slug: page.slug
-				},
-				metadata: { tool: "read_page" }
-			});
-			return createStructuredTextResult({
-				page: toStructuredDocsMcpPage(page),
-				document,
-				section: selectedSection?.title,
-				anchor: selectedSection?.anchor,
-				chars: document.length,
-				totalChars: selectedDocument.length,
-				truncated: limitedDocument.truncated
-			}, document);
-		} catch (error) {
-			const elapsed = durationMs(startedAt);
-			await emitDocsAgentTraceEvent(options.observability, {
-				type: "tool.error",
-				source: "mcp",
-				traceId: trace.traceId,
-				parentSpanId: callSpanId,
-				name: "read_page",
-				startedAt: trace.startedAt,
-				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				durationMs: elapsed,
-				status: "error",
-				locale,
-				outputPreview: { message: error instanceof Error ? error.message : "Unknown error" },
-				metadata: { tool: "read_page" }
-			});
-			throw error;
-		}
-	});
-	return server;
-}
-function createDocsMcpHttpHandler(options) {
-	const resolved = resolveDocsMcpConfig(options.mcp, {
-		defaultName: options.defaultName ?? options.source.siteTitle ?? DEFAULT_MCP_NAME,
-		defaultVersion: options.defaultVersion
-	});
-	const telemetryConfig = {
-		telemetry: options.telemetry,
-		mcp: options.mcp,
-		search: options.search
-	};
-	const telemetryFramework = options.telemetryFramework ?? "mcp";
-	const disabledMessage = "MCP is disabled. Remove `mcp: false` or set `mcp: { enabled: true }` in docs.config to enable it again.";
-	if (!resolved.enabled) return {
-		GET: async () => createJsonErrorResponse(404, disabledMessage),
-		POST: async ({ request }) => createJsonRpcErrorResponse({
-			status: 404,
-			code: -32e3,
-			message: disabledMessage,
-			id: readJsonRpcId(await parseJsonBody(request)),
-			data: { reason: "mcp_disabled" }
-		}),
-		DELETE: async () => createJsonErrorResponse(404, disabledMessage),
-		OPTIONS: async () => createJsonErrorResponse(404, disabledMessage)
-	};
-	async function createStatelessTransport(requestContext) {
-		const server = await createDocsMcpServer({
-			...options,
-			requestContext
-		});
-		const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
-		await server.connect(transport);
-		return {
-			server,
-			transport
-		};
-	}
-	async function handle(request) {
-		const originalUrl = new URL(request.url);
-		const method = request.method.toUpperCase();
-		const security = resolved.security ?? resolveDocsMcpSecurityConfig();
-		const metadataLocation = resolveDocsMcpProtectedResourceMetadataLocation(request, resolved.route);
-		if (metadataLocation || isDocsMcpProtectedResourceMetadataPath(originalUrl.pathname)) {
-			if (security.authenticate && security.protectedResource && metadataLocation && !isAllowedMcpProtectedResourceUrl(metadataLocation.resourceUrl)) return createMcpHttpSecurityErrorResponse(400, "Protected MCP requires HTTPS; HTTP is allowed only for loopback development");
-			return createDocsMcpProtectedResourceMetadataResponse({
-				request,
-				location: metadataLocation,
-				config: security.authenticate ? security.protectedResource : void 0,
-				defaultResourceName: resolved.name
-			});
-		}
-		if (security.authenticate && security.protectedResource && !isDocsMcpResourcePath(originalUrl.pathname, resolved.route)) return createJsonErrorResponse(404, "Not Found");
-		const resourceLocation = resolveDocsMcpResourceLocation(request, resolved.route);
-		if (security.authenticate && security.protectedResource && !isAllowedMcpProtectedResourceUrl(resourceLocation.resourceUrl)) return createMcpHttpSecurityErrorResponse(400, "Protected MCP requires HTTPS; HTTP is allowed only for loopback development");
-		const prepared = await prepareDocsMcpHttpRequest(request, security.maxBodyBytes);
-		if (prepared.status === "too-large") return createMcpRequestTooLargeResponse(security.maxBodyBytes);
-		request = prepared.request;
-		const url = new URL(request.url);
-		let originAllowed;
-		try {
-			originAllowed = await isDocsMcpOriginAllowed(request.clone(), security.allowedOrigins);
-		} catch {
-			return createMcpHttpSecurityErrorResponse(500, "MCP Origin policy failed");
-		}
-		if (!originAllowed) return createMcpHttpSecurityErrorResponse(403, "Forbidden Origin");
-		if (method === "OPTIONS") return createDocsMcpOptionsResponse(request, security.cors);
-		const withCors = (response) => applyDocsMcpCorsHeaders(response, request, security.cors);
-		let auth;
-		if (security.authenticate) {
-			let authentication;
-			try {
-				authentication = await security.authenticate({
-					request: request.clone(),
-					pathname: resourceLocation.resourceUrl.pathname,
-					resource: serializeMcpResourceIdentifier(resourceLocation.resourceUrl)
-				});
-			} catch {
-				return withCors(createMcpHttpSecurityErrorResponse(500, "MCP authentication failed"));
-			}
-			if (authentication instanceof Response) return withCors(authentication);
-			if (authentication === null || authentication === void 0) return withCors(createMcpUnauthorizedResponse(request, resourceLocation, security.protectedResource));
-			if (!isDocsMcpAuthPrincipal(authentication)) return withCors(createMcpHttpSecurityErrorResponse(500, "MCP authentication returned an invalid principal"));
-			if (findMissingMcpScopes(authentication.scopes, security.protectedResource?.requiredScopes).length > 0) return withCors(createMcpInsufficientScopeResponse(resourceLocation, security.protectedResource));
-			auth = authentication;
-		}
-		const sessionId = request.headers.get("mcp-session-id") ?? request.headers.get("Mcp-Session-Id");
-		const parsedBody = prepared.parsedBody;
-		const bodyParseFailed = prepared.bodyParseFailed;
-		const initializeRequest = method === "POST" && parsedBody && isInitializeRequest(parsedBody);
-		emitDocsTelemetryProjectEvent(telemetryConfig, {
-			framework: telemetryFramework,
-			request
-		});
-		emitDocsTelemetryAgentSurfaceEvent(telemetryConfig, {
-			framework: telemetryFramework,
-			request,
-			surface: "mcp",
-			properties: {
-				method,
-				initialize: Boolean(initializeRequest)
-			}
-		});
-		await emitDocsAnalyticsEvent(options.analytics, {
-			type: "mcp_request",
-			source: "mcp",
-			url: request.url,
-			path: url.pathname,
-			properties: {
-				method,
-				hasSession: Boolean(sessionId),
-				stateless: true,
-				initialize: Boolean(initializeRequest)
-			}
-		});
-		if (method === "POST" && bodyParseFailed) return withCors(createJsonRpcErrorResponse({
-			status: 400,
-			code: -32700,
-			message: "Parse error: Invalid JSON"
-		}));
-		return withCors(await (await createStatelessTransport({
-			transport: "http",
-			request: request.clone(),
-			auth
-		})).transport.handleRequest(request, parsedBody === void 0 ? void 0 : { parsedBody }));
-	}
-	return {
-		GET: async ({ request }) => handle(request),
-		POST: async ({ request }) => handle(request),
-		DELETE: async ({ request }) => handle(request),
-		OPTIONS: async ({ request }) => handle(request)
-	};
-}
-async function runDocsMcpStdio(options) {
-	const server = await createDocsMcpServer({
-		...options,
-		requestContext: { transport: "stdio" }
-	});
-	const transport = new StdioServerTransport();
-	await server.connect(transport);
-}
-async function isDocsMcpOriginAllowed(request, allowedOrigins) {
-	const origin = request.headers.get("origin");
-	if (!origin) return true;
-	if (typeof allowedOrigins === "function") return allowedOrigins({
-		origin,
-		request
-	});
-	const normalizedOrigin = normalizeHttpOrigin(origin);
-	if (allowedOrigins === "same-origin") return normalizedOrigin === new URL(request.url).origin;
-	return allowedOrigins.some((allowedOrigin) => normalizeHttpOrigin(allowedOrigin) === normalizedOrigin);
-}
-function normalizeHttpOrigin(value) {
-	try {
-		return new URL(value).origin;
-	} catch {
-		return value.trim();
-	}
-}
-function isDocsMcpAuthPrincipal(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const principal = value;
-	if (typeof principal.id !== "string" || principal.id.trim().length === 0) return false;
-	if (principal.scopes !== void 0 && (!Array.isArray(principal.scopes) || principal.scopes.some((scope) => typeof scope !== "string"))) return false;
-	return principal.claims === void 0 || typeof principal.claims === "object" && principal.claims !== null && !Array.isArray(principal.claims);
-}
-async function prepareDocsMcpHttpRequest(request, maxBodyBytes) {
-	if (request.method.toUpperCase() !== "POST") return {
-		status: "ok",
-		request,
-		bodyParseFailed: false
-	};
-	if (isContentLengthOverLimit(request, maxBodyBytes)) return { status: "too-large" };
-	const body = request.body;
-	if (!body) return {
-		status: "ok",
-		request,
-		bodyParseFailed: true
-	};
-	const reader = body.getReader();
-	const chunks = [];
-	let byteLength = 0;
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		byteLength += value.byteLength;
-		if (byteLength > maxBodyBytes) {
-			reader.cancel();
-			return { status: "too-large" };
-		}
-		chunks.push(value);
-	}
-	const bodyBytes = new Uint8Array(byteLength);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bodyBytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	const boundedRequest = new Request(request.url, {
-		method: request.method,
-		headers: new Headers(request.headers),
-		body: bodyBytes,
-		redirect: request.redirect,
-		signal: request.signal
-	});
-	try {
-		return {
-			status: "ok",
-			request: boundedRequest,
-			parsedBody: JSON.parse(new TextDecoder().decode(bodyBytes)),
-			bodyParseFailed: false
-		};
-	} catch {
-		return {
-			status: "ok",
-			request: boundedRequest,
-			bodyParseFailed: true
-		};
-	}
-}
-function isContentLengthOverLimit(request, maxBodyBytes) {
-	const rawContentLength = request.headers.get("content-length");
-	if (rawContentLength === null) return false;
-	const contentLength = Number(rawContentLength);
-	return Number.isFinite(contentLength) && contentLength > maxBodyBytes;
-}
-const DOCS_MCP_CORS_METHODS = [
-	"GET",
-	"POST",
-	"DELETE",
-	"OPTIONS"
-];
-const DOCS_MCP_CORS_REQUEST_METHODS = new Set([
-	"GET",
-	"POST",
-	"DELETE"
-]);
-function createDocsMcpOptionsResponse(request, cors) {
-	const allow = DOCS_MCP_CORS_METHODS.join(", ");
-	if (!request.headers.get("origin") || !cors.enabled) return new Response(null, {
-		status: 204,
-		headers: { Allow: allow }
-	});
-	const requestedMethod = request.headers.get("access-control-request-method")?.trim().toUpperCase();
-	if (requestedMethod && !DOCS_MCP_CORS_REQUEST_METHODS.has(requestedMethod)) return applyDocsMcpPreflightCorsHeaders(createMcpHttpSecurityErrorResponse(405, "CORS request method is not allowed"), request, cors);
-	const allowedHeaders = new Set(cors.allowedHeaders.map((header) => header.toLowerCase()));
-	const rejectedHeader = parseCorsRequestedHeaders(request.headers.get("access-control-request-headers")).find((header) => !allowedHeaders.has(header.toLowerCase()));
-	if (rejectedHeader) return applyDocsMcpPreflightCorsHeaders(createMcpHttpSecurityErrorResponse(403, `CORS request header is not allowed: ${rejectedHeader}`), request, cors);
-	return applyDocsMcpPreflightCorsHeaders(new Response(null, {
-		status: 204,
-		headers: { Allow: allow }
-	}), request, cors);
-}
-function parseCorsRequestedHeaders(value) {
-	if (!value) return [];
-	return value.split(",").map((header) => header.trim()).filter(Boolean);
-}
-function applyDocsMcpPreflightCorsHeaders(response, request, cors) {
-	const headers = buildDocsMcpCorsHeaders(response.headers, request, cors);
-	headers.set("Access-Control-Allow-Methods", DOCS_MCP_CORS_METHODS.join(", "));
-	headers.set("Access-Control-Allow-Headers", cors.allowedHeaders.join(", "));
-	headers.set("Access-Control-Max-Age", String(cors.maxAgeSeconds));
-	appendVaryHeader(headers, "Access-Control-Request-Method");
-	appendVaryHeader(headers, "Access-Control-Request-Headers");
-	return cloneResponseWithHeaders(response, headers);
-}
-function applyDocsMcpCorsHeaders(response, request, cors) {
-	if (!request.headers.has("origin") || !cors.enabled) return response;
-	const headers = buildDocsMcpCorsHeaders(response.headers, request, cors);
-	if (!headers.has("Access-Control-Allow-Origin")) return response;
-	if (cors.exposedHeaders.length > 0) headers.set("Access-Control-Expose-Headers", cors.exposedHeaders.join(", "));
-	return cloneResponseWithHeaders(response, headers);
-}
-function buildDocsMcpCorsHeaders(source, request, cors) {
-	const headers = new Headers(source);
-	headers.delete("Access-Control-Allow-Origin");
-	headers.delete("Access-Control-Allow-Credentials");
-	const origin = serializeCorsOrigin(request.headers.get("origin"));
-	if (!origin) return headers;
-	headers.set("Access-Control-Allow-Origin", origin);
-	if (cors.allowCredentials) headers.set("Access-Control-Allow-Credentials", "true");
-	else headers.delete("Access-Control-Allow-Credentials");
-	appendVaryHeader(headers, "Origin");
-	return headers;
-}
-function serializeCorsOrigin(value) {
-	if (!value) return null;
-	if (value.trim() === "null") return "null";
-	try {
-		const origin = new URL(value).origin;
-		return origin === "null" ? null : origin;
-	} catch {
-		return null;
-	}
-}
-function appendVaryHeader(headers, value) {
-	const values = (headers.get("Vary") ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
-	if (!values.some((entry) => entry.toLowerCase() === value.toLowerCase())) values.push(value);
-	headers.set("Vary", values.join(", "));
-}
-function cloneResponseWithHeaders(response, headers) {
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers
-	});
-}
-function createDocsMcpProtectedResourceMetadataResponse({ request, location, config, defaultResourceName }) {
-	const method = request.method.toUpperCase();
-	const headers = new Headers({
-		"Access-Control-Allow-Origin": "*",
-		"Access-Control-Expose-Headers": "Content-Type",
-		Allow: "GET, HEAD, OPTIONS",
-		"Cache-Control": config && location ? "public, max-age=300" : "no-store",
-		"Content-Type": "application/json",
-		"X-Robots-Tag": "noindex"
-	});
-	if (!config || !location) return new Response(method === "HEAD" ? null : JSON.stringify({ error: "Not Found" }), {
-		status: 404,
-		headers
-	});
-	if (method === "OPTIONS") {
-		headers.set("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
-		headers.set("Access-Control-Allow-Headers", "MCP-Protocol-Version");
-		headers.set("Access-Control-Max-Age", "600");
-		return new Response(null, {
-			status: 204,
-			headers
-		});
-	}
-	if (method !== "GET" && method !== "HEAD") return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-		status: 405,
-		headers
-	});
-	const metadata = {
-		resource: serializeMcpResourceIdentifier(location.resourceUrl),
-		authorization_servers: config.authorizationServers,
-		scopes_supported: config.scopesSupported.length > 0 ? config.scopesSupported : void 0,
-		bearer_methods_supported: ["header"],
-		resource_name: config.resourceName ?? defaultResourceName,
-		resource_documentation: config.resourceDocumentation
-	};
-	return new Response(method === "HEAD" ? null : JSON.stringify(metadata), { headers });
-}
-function serializeMcpResourceIdentifier(resourceUrl) {
-	return resourceUrl.pathname === "/" ? resourceUrl.origin : resourceUrl.href;
-}
-function isAllowedMcpProtectedResourceUrl(resourceUrl) {
-	if (resourceUrl.protocol === "https:") return true;
-	return resourceUrl.protocol === "http:" && (resourceUrl.hostname === "localhost" || resourceUrl.hostname === "127.0.0.1" || resourceUrl.hostname === "[::1]");
-}
-function findMissingMcpScopes(grantedScopes, requiredScopes) {
-	if (!requiredScopes || requiredScopes.length === 0) return [];
-	const granted = new Set(grantedScopes ?? []);
-	return requiredScopes.filter((scope) => !granted.has(scope));
-}
-function createMcpUnauthorizedResponse(request, location, config) {
-	if (!config) return createMcpHttpSecurityErrorResponse(401, "Unauthorized");
-	return createMcpOAuthErrorResponse(401, "invalid_token", buildMcpBearerChallenge({
-		error: request.headers.has("authorization") ? "invalid_token" : void 0,
-		resourceMetadata: location.metadataUrl.href,
-		scopes: config.requiredScopes
-	}));
-}
-function createMcpInsufficientScopeResponse(location, config) {
-	if (!config) return createMcpHttpSecurityErrorResponse(403, "Forbidden");
-	return createMcpOAuthErrorResponse(403, "insufficient_scope", buildMcpBearerChallenge({
-		error: "insufficient_scope",
-		resourceMetadata: location.metadataUrl.href,
-		scopes: config.requiredScopes
-	}));
-}
-function buildMcpBearerChallenge({ error, resourceMetadata, scopes }) {
-	return `Bearer ${[
-		...error ? [`error=${quoteHttpAuthParameter(error)}`] : [],
-		`resource_metadata=${quoteHttpAuthParameter(resourceMetadata)}`,
-		...scopes.length > 0 ? [`scope=${quoteHttpAuthParameter(scopes.join(" "))}`] : []
-	].join(", ")}`;
-}
-function quoteHttpAuthParameter(value) {
-	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-}
-function createMcpOAuthErrorResponse(status, error, challenge) {
-	return new Response(JSON.stringify({ error }), {
-		status,
-		headers: {
-			"Content-Type": "application/json",
-			"Cache-Control": "no-store",
-			"WWW-Authenticate": challenge
-		}
-	});
-}
-function createMcpRequestTooLargeResponse(maxBodyBytes) {
-	const response = createJsonRpcErrorResponse({
-		status: 413,
-		code: -32e3,
-		message: `Request body exceeds the ${maxBodyBytes} byte limit`,
-		data: {
-			reason: "request_too_large",
-			maxBodyBytes
-		}
-	});
-	response.headers.set("Cache-Control", "no-store");
-	return response;
-}
-function createMcpHttpSecurityErrorResponse(status, error) {
-	return new Response(JSON.stringify({ error }), {
-		status,
-		headers: {
-			"Content-Type": "application/json",
-			"Cache-Control": "no-store"
-		}
-	});
-}
-function createJsonErrorResponse(status, error) {
-	return new Response(JSON.stringify({ error }), {
-		status,
-		headers: { "Content-Type": "application/json" }
-	});
-}
-async function parseJsonBody(request) {
-	try {
-		return await request.clone().json();
-	} catch {
-		return;
-	}
-}
-function readJsonRpcId(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const id = value.id;
-	return typeof id === "string" || typeof id === "number" ? id : null;
-}
-function createJsonRpcErrorResponse({ status, code, message, id = null, data }) {
-	return new Response(JSON.stringify({
-		jsonrpc: "2.0",
-		id,
-		error: data ? {
-			code,
-			message,
-			data
-		} : {
-			code,
-			message
-		}
-	}), {
-		status,
-		headers: { "Content-Type": "application/json" }
-	});
-}
-function normalizePathSegment(value) {
-	return value.replace(/^\/+|\/+$/g, "");
-}
-function titleize(value) {
-	return value.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
-}
-function stripMarkdownForMcp(content) {
-	return content.replace(/^(import|export)\s.*$/gm, "").replace(/<[^>]+\/>/g, "").replace(/<\/?[A-Z][^>]*>/g, "").replace(/<\/?[a-z][^>]*>/g, "").replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/(\*{1,3}|_{1,3})(.*?)\1/g, "$2").replace(/```[\s\S]*?```/g, "").replace(/`([^`]+)`/g, "$1").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
-}
-function resolveFilesystemDocsPageSource(dir) {
-	return [
-		"page.mdx",
-		"page.md",
-		"page.svx"
-	].map((fileName) => path.join(dir, fileName)).find((candidate) => fs.existsSync(candidate));
-}
-function hasVisibleDescendantFilesystemDocsPage(dir) {
-	let entries;
-	try {
-		entries = fs.readdirSync(dir);
-	} catch {
-		return false;
-	}
-	for (const name of entries.sort()) {
-		const full = path.join(dir, name);
-		try {
-			if (!fs.statSync(full).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		const pageSource = resolveFilesystemDocsPageSource(full);
-		if (pageSource) try {
-			const data = matter(fs.readFileSync(pageSource, "utf-8")).data;
-			const hiddenFolderIndex = resolvePageSidebarFolderIndexBehavior(data.sidebar) === "hidden";
-			if (data.hidden !== true && !hiddenFolderIndex) return true;
-		} catch {
-			return true;
-		}
-		if (hasVisibleDescendantFilesystemDocsPage(full)) return true;
-	}
-	return false;
-}
-function scanFilesystemDocsPages(contentDirAbs, entry, rootDir) {
-	const pages = [];
-	function scan(dir, slugParts) {
-		if (!fs.existsSync(dir)) return;
-		const entries = fs.readdirSync(dir).sort();
-		for (const name of entries) {
-			const full = path.join(dir, name);
-			const stat = fs.statSync(full);
-			if (stat.isDirectory()) {
-				scan(full, [...slugParts, name]);
-				continue;
-			}
-			if (name === "agent.md") continue;
-			if (!name.endsWith(".md") && !name.endsWith(".mdx") && !name.endsWith(".svx")) continue;
-			const { data, content } = matter(fs.readFileSync(full, "utf-8"));
-			const baseName = name.replace(/\.(md|mdx|svx)$/, "");
-			const isIndex = baseName === "index" || baseName === "page" || baseName === "+page";
-			if (isIndex && resolvePageSidebarFolderIndexBehavior(data.sidebar) === "hidden" && hasVisibleDescendantFilesystemDocsPage(dir)) continue;
-			const humanRawContent = resolveDocsAudienceMdxContent(content, "human");
-			const pageAgentRawContent = resolveDocsAudienceMdxContent(content, "agent");
-			const pageAgentContent = pageAgentRawContent !== humanRawContent ? stripMarkdownForMcp(pageAgentRawContent) : void 0;
-			const slug = isIndex ? slugParts.join("/") : [...slugParts, baseName].join("/");
-			const url = slug ? `/${entry}/${slug}` : `/${entry}`;
-			const agentDoc = isIndex ? readFilesystemAgentDoc(dir) : void 0;
-			const title = data.title ?? (isIndex ? slugParts.length > 0 ? titleize(slugParts[slugParts.length - 1]) : "Documentation" : titleize(baseName));
-			pages.push({
-				slug,
-				url,
-				title,
-				description: data.description,
-				relatedInput: data.related,
-				agent: normalizePageAgentFrontmatter(data.agent),
-				icon: data.icon,
-				sourcePath: path.relative(rootDir, full).replace(/\\/g, "/"),
-				lastModified: stat.mtime.toISOString(),
-				locale: typeof data.locale === "string" ? data.locale : void 0,
-				framework: typeof data.framework === "string" ? data.framework : void 0,
-				version: typeof data.version === "string" ? data.version : void 0,
-				tags: Array.isArray(data.tags) ? data.tags.filter((tag) => typeof tag === "string") : void 0,
-				content: stripMarkdownForMcp(humanRawContent),
-				rawContent: humanRawContent,
-				agentFallbackContent: pageAgentContent,
-				agentFallbackRawContent: pageAgentRawContent !== humanRawContent ? pageAgentRawContent : void 0,
-				order: typeof data.order === "number" ? data.order : Number.POSITIVE_INFINITY,
-				...agentDoc
-			});
-		}
-	}
-	scan(contentDirAbs, []);
-	return resolveRelatedForMcpPages(pages);
-}
-function readFilesystemAgentDoc(dir) {
-	const agentPath = path.join(dir, "agent.md");
-	if (!fs.existsSync(agentPath)) return void 0;
-	const { content } = matter(stripGeneratedAgentProvenance(fs.readFileSync(agentPath, "utf-8")));
-	const agentContent = resolveDocsAudienceMdxContent(content, "agent");
-	return {
-		agentContent: stripMarkdownForMcp(agentContent),
-		agentRawContent: agentContent
-	};
-}
-function resolveRelatedForMcpPages(pages) {
-	return pages.map(({ relatedInput, ...page }) => {
-		const related = normalizeDocsRelated(relatedInput);
-		return related.length > 0 ? {
-			...page,
-			related
-		} : page;
-	});
-}
-function buildNavigationTreeFromPages(pages, siteTitle, ordering) {
-	const bySlug = new Map(pages.map((page) => [page.slug, page]));
-	const rootPage = bySlug.get("");
-	function childOrderFor(parentSlug) {
-		if (!Array.isArray(ordering)) return void 0;
-		if (!parentSlug) return ordering;
-		let items = ordering;
-		for (const segment of parentSlug.split("/")) {
-			items = (items?.find((item) => item.slug === segment))?.children;
-			if (!items) return void 0;
-		}
-		return items;
-	}
-	function sortChildSlugs(childSlugs, parentSlug) {
-		const explicitOrder = childOrderFor(parentSlug);
-		if (explicitOrder) {
-			const explicit = new Set(explicitOrder.map((item) => item.slug));
-			const ordered = [];
-			for (const item of explicitOrder) {
-				const childSlug = parentSlug ? `${parentSlug}/${item.slug}` : item.slug;
-				if (childSlugs.includes(childSlug)) ordered.push(childSlug);
-			}
-			for (const childSlug of childSlugs) {
-				const segment = childSlug.split("/").pop() ?? childSlug;
-				if (!explicit.has(segment)) ordered.push(childSlug);
-			}
-			return ordered;
-		}
-		if (ordering === "numeric") return [...childSlugs].sort((left, right) => {
-			const leftPage = bySlug.get(left);
-			const rightPage = bySlug.get(right);
-			const leftOrder = leftPage?.order ?? Number.POSITIVE_INFINITY;
-			const rightOrder = rightPage?.order ?? Number.POSITIVE_INFINITY;
-			if (leftOrder !== rightOrder) return leftOrder - rightOrder;
-			return left.localeCompare(right);
-		});
-		return [...childSlugs].sort((left, right) => left.localeCompare(right));
-	}
-	function buildLevel(parentSlug) {
-		const prefix = parentSlug ? `${parentSlug}/` : "";
-		const childSet = /* @__PURE__ */ new Set();
-		for (const page of pages) {
-			if (!page.slug.startsWith(prefix) || page.slug === parentSlug) continue;
-			const remainder = page.slug.slice(prefix.length);
-			if (!remainder) continue;
-			const [firstSegment] = remainder.split("/");
-			childSet.add(parentSlug ? `${parentSlug}/${firstSegment}` : firstSegment);
-		}
-		const childSlugs = sortChildSlugs([...childSet], parentSlug);
-		const nodes = [];
-		for (const childSlug of childSlugs) {
-			const page = bySlug.get(childSlug);
-			const hasChildren = pages.some((candidate) => candidate.slug.startsWith(`${childSlug}/`));
-			const segment = childSlug.split("/").pop() ?? childSlug;
-			const name = page?.title ?? titleize(segment);
-			const icon = page?.icon;
-			const description = page?.description;
-			if (hasChildren) {
-				nodes.push({
-					type: "folder",
-					name,
-					icon,
-					index: page ? {
-						type: "page",
-						name: page.title,
-						url: page.url,
-						icon: page.icon,
-						description: page.description
-					} : void 0,
-					children: buildLevel(childSlug)
-				});
-				continue;
-			}
-			if (!page) continue;
-			nodes.push({
-				type: "page",
-				name,
-				url: page.url,
-				icon,
-				description
-			});
-		}
-		return nodes;
-	}
-	const children = [];
-	if (rootPage) children.push({
-		type: "page",
-		name: rootPage.title,
-		url: rootPage.url,
-		icon: rootPage.icon,
-		description: rootPage.description
-	});
-	children.push(...buildLevel(""));
-	return {
-		name: siteTitle,
-		children
-	};
-}
-function dedupePages(pages) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const page of pages) seen.set(page.url, page);
-	return [...seen.values()];
-}
-function toSearchSourcePages(pages) {
-	return pages.map((page) => ({
-		title: page.title,
-		url: page.url,
-		content: page.content,
-		rawContent: page.rawContent,
-		sourcePath: page.sourcePath,
-		lastModified: page.lastModified,
-		locale: page.locale,
-		framework: page.framework,
-		version: page.version,
-		tags: page.tags,
-		agentContent: page.agentContent,
-		agentRawContent: page.agentRawContent,
-		agentFallbackContent: page.agentFallbackContent,
-		agentFallbackRawContent: page.agentFallbackRawContent,
-		description: page.description,
-		related: page.related,
-		agent: page.agent
-	}));
-}
-function getDocsConfigSchema(filters = {}) {
-	const option = filters.option?.trim();
-	const query = filters.query?.trim();
-	let options = DOCS_CONFIG_SCHEMA_OPTIONS.map(cloneConfigSchemaOption);
-	if (option) options = selectConfigSchemaOptions(option);
-	if (query) options = filterConfigSchemaOptionsByQuery(options, query);
-	return {
-		schemaVersion: 1,
-		configFile: "docs.config.ts",
-		description: "Configuration schema for @farming-labs/docs defineDocs(). Use option for an exact top-level or nested path, or query for keyword filtering.",
-		filters: option || query ? {
-			...option ? { option } : {},
-			...query ? { query } : {}
-		} : void 0,
-		resultCount: countConfigSchemaOptions(options),
-		options,
-		examples: DOCS_CONFIG_SCHEMA_EXAMPLES.map((example) => ({ ...example }))
-	};
-}
-function cloneConfigSchemaOption(option) {
-	return {
-		...option,
-		values: option.values ? [...option.values] : void 0,
-		children: option.children?.map(cloneConfigSchemaOption)
-	};
-}
-function selectConfigSchemaOptions(optionPath) {
-	const needle = normalizeConfigSchemaToken(optionPath);
-	return flattenConfigSchemaOptions(DOCS_CONFIG_SCHEMA_OPTIONS).filter((option) => {
-		return normalizeConfigSchemaToken(option.path) === needle;
-	}).map(cloneConfigSchemaOption);
-}
-function filterConfigSchemaOptionsByQuery(options, query) {
-	return options.flatMap((option) => {
-		if (configSchemaOptionMatchesQuery(option, query)) return [cloneConfigSchemaOption(option)];
-		const children = option.children ? filterConfigSchemaOptionsByQuery(option.children, query) : [];
-		if (children.length === 0) return [];
-		return [{
-			...cloneConfigSchemaOption(option),
-			children
-		}];
-	});
-}
-function configSchemaOptionMatchesQuery(option, query) {
-	const searchText = [
-		option.path,
-		option.name,
-		option.type,
-		option.default,
-		option.description,
-		option.docs,
-		option.values?.join(" ")
-	].filter((value) => value !== void 0 && value !== null).join(" ");
-	const lowerSearchText = searchText.toLowerCase();
-	const lowerQuery = query.toLowerCase();
-	return lowerSearchText.includes(lowerQuery) || normalizeConfigSchemaToken(searchText).includes(normalizeConfigSchemaToken(query));
-}
-function flattenConfigSchemaOptions(options) {
-	return options.flatMap((option) => [option, ...option.children ? flattenConfigSchemaOptions(option.children) : []]);
-}
-function countConfigSchemaOptions(options) {
-	return flattenConfigSchemaOptions(options).length;
-}
-function normalizeConfigSchemaToken(value) {
-	return value.trim().toLowerCase().replace(/^docs\.config\.?/, "").replace(/[`'"]/g, "").replace(/[_\-\s]+/g, "");
-}
-function isSelfMcpSearchEndpoint(search, route) {
-	if (!search || search === true || typeof search !== "object" || search.provider !== "mcp") return false;
-	const endpoint = search.endpoint.trim();
-	if (!endpoint.startsWith("/")) return false;
-	return normalizeDocsMcpRoute(endpoint) === normalizeDocsMcpRoute(route);
-}
-function resolveMcpToolSearchConfig(search, route) {
-	if (!isSelfMcpSearchEndpoint(search, route)) return search;
-	const config = search;
-	return {
-		provider: "simple",
-		enabled: config.enabled,
-		maxResults: config.maxResults,
-		chunking: config.chunking
-	};
-}
-function toAgentContractSummary(value) {
-	const agent = normalizePageAgentFrontmatter(value);
-	const hasContract = hasStructuredPageAgentContract(agent);
-	return {
-		hasContract,
-		...hasContract && agent?.task ? { task: agent.task } : {},
-		...hasContract && agent?.outcome ? { outcome: agent.outcome } : {},
-		...hasContract && agent?.appliesTo ? { appliesTo: agent.appliesTo } : {}
-	};
-}
-function toPageSummaries(pages) {
-	return pages.map((page) => ({
-		slug: page.slug,
-		url: page.url,
-		title: page.title,
-		description: page.description,
-		icon: page.icon,
-		agent: toAgentContractSummary(page.agent)
-	}));
-}
-function toDocsListPageSummary(page) {
-	return {
-		slug: page.slug,
-		url: page.url,
-		title: page.title,
-		description: page.description,
-		agent: toAgentContractSummary(page.agent),
-		icon: page.icon,
-		sourcePath: page.sourcePath,
-		lastModified: page.lastModified
-	};
-}
-function listDocsTasks(pages, filters) {
-	const query = filters.query?.toLowerCase();
-	const applicabilityFilters = [
-		["framework", filters.framework],
-		["version", filters.version],
-		["package", filters.package]
-	];
-	return pages.flatMap((page) => {
-		const agent = normalizePageAgentFrontmatter(page.agent);
-		if (!agent || !hasStructuredPageAgentContract(agent)) return [];
-		for (const [field, expected] of applicabilityFilters) {
-			if (!expected) continue;
-			const actualValue = agent.appliesTo?.[field];
-			if (!(typeof actualValue === "string" ? [actualValue] : actualValue ?? []).some((value) => value.toLowerCase() === expected.toLowerCase())) return [];
-		}
-		if (query) {
-			if (![
-				page.slug,
-				page.url,
-				page.title,
-				page.description,
-				JSON.stringify(agent)
-			].filter(Boolean).join("\n").toLowerCase().includes(query)) return [];
-		}
-		return [{
-			slug: page.slug,
-			url: page.url,
-			title: page.title,
-			...page.description ? { description: page.description } : {},
-			...agent.task ? { task: agent.task } : {},
-			...agent.outcome ? { outcome: agent.outcome } : {},
-			...agent.appliesTo ? { appliesTo: agent.appliesTo } : {}
-		}];
-	});
-}
-function listDocsBySection(pages, filters) {
-	const allPages = pages.map(toDocsListPageSummary);
-	const tree = buildDocsSectionTree(pages);
-	const requestedSection = filters.section?.trim();
-	if (!requestedSection) return {
-		resultCount: allPages.length,
-		sectionCount: countDocsSections(tree.sections),
-		pages: allPages,
-		rootPages: tree.rootPages,
-		sections: tree.sections
-	};
-	const section = findDocsSection(tree.sections, requestedSection, filters.entry);
-	if (section) {
-		const sections = [cloneDocsSection(section)];
-		const matchedPages = flattenDocsSectionPages(sections[0]);
-		return {
-			section: requestedSection,
-			resultCount: matchedPages.length,
-			sectionCount: countDocsSections(sections),
-			pages: matchedPages,
-			rootPages: [],
-			sections
-		};
-	}
-	const page = allPages.find((candidate) => docsListPageMatches(candidate, requestedSection, filters.entry));
-	if (page) return {
-		section: requestedSection,
-		resultCount: 1,
-		sectionCount: 0,
-		pages: [page],
-		rootPages: [page],
-		sections: []
-	};
-	return {
-		section: requestedSection,
-		resultCount: 0,
-		sectionCount: 0,
-		pages: [],
-		rootPages: [],
-		sections: []
-	};
-}
-function buildDocsSectionTree(pages) {
-	const sectionSlugs = /* @__PURE__ */ new Set();
-	for (const page of pages) {
-		const parts = page.slug.split("/").filter(Boolean);
-		for (let index = 1; index < parts.length; index += 1) sectionSlugs.add(parts.slice(0, index).join("/"));
-	}
-	const rootPages = [];
-	const sections = [];
-	const sectionBySlug = /* @__PURE__ */ new Map();
-	function getOrCreateSection(slug) {
-		const existing = sectionBySlug.get(slug);
-		if (existing) return existing;
-		const parts = slug.split("/").filter(Boolean);
-		const section = {
-			slug,
-			title: titleize(parts.at(-1) ?? slug),
-			pageCount: 0,
-			pages: [],
-			sections: []
-		};
-		sectionBySlug.set(slug, section);
-		if (parts.length <= 1) sections.push(section);
-		else getOrCreateSection(parts.slice(0, -1).join("/")).sections.push(section);
-		return section;
-	}
-	for (const page of pages) {
-		const summary = toDocsListPageSummary(page);
-		const parts = page.slug.split("/").filter(Boolean);
-		if (parts.length === 0) {
-			rootPages.push(summary);
-			continue;
-		}
-		const isSectionIndex = sectionSlugs.has(page.slug);
-		if (parts.length === 1 && !isSectionIndex) {
-			rootPages.push(summary);
-			continue;
-		}
-		if (isSectionIndex) {
-			const section = getOrCreateSection(page.slug);
-			hydrateDocsSection(section, summary);
-			pushUniqueDocsPage(section.pages, summary, "start");
-			continue;
-		}
-		pushUniqueDocsPage(getOrCreateSection(parts.slice(0, -1).join("/")).pages, summary, "end");
-	}
-	updateDocsSectionPageCounts(sections);
-	return {
-		rootPages,
-		sections
-	};
-}
-function hydrateDocsSection(section, page) {
-	section.title = page.title;
-	section.url = page.url;
-	section.description = page.description;
-	section.icon = page.icon;
-}
-function pushUniqueDocsPage(pages, page, position) {
-	if (pages.some((candidate) => candidate.url === page.url)) return;
-	if (position === "start") {
-		pages.unshift(page);
-		return;
-	}
-	pages.push(page);
-}
-function updateDocsSectionPageCounts(sections) {
-	let total = 0;
-	for (const section of sections) {
-		section.pageCount = section.pages.length + updateDocsSectionPageCounts(section.sections);
-		total += section.pageCount;
-	}
-	return total;
-}
-function findDocsSection(sections, section, entry) {
-	for (const candidate of sections) {
-		if (docsListSectionMatches(candidate, section, entry)) return candidate;
-		const child = findDocsSection(candidate.sections, section, entry);
-		if (child) return child;
-	}
-}
-function docsListSectionMatches(section, value, entry) {
-	return docsListCandidates(section, entry).includes(normalizeDocsListMatchValue(value));
-}
-function docsListPageMatches(page, value, entry) {
-	return docsListCandidates(page, entry).includes(normalizeDocsListMatchValue(value));
-}
-function docsListCandidates(value, entry) {
-	return [
-		value.slug,
-		value.url,
-		value.title,
-		value.url ? stripDocsEntryFromPath(value.url, entry) : void 0,
-		stripDocsEntryFromPath(value.slug, entry)
-	].filter((candidate) => Boolean(candidate)).map(normalizeDocsListMatchValue);
-}
-function stripDocsEntryFromPath(value, entry) {
-	const normalized = normalizePathSegment(value.replace(/\.md$/i, ""));
-	const normalizedEntry = normalizePathSegment(entry ?? "");
-	if (!normalizedEntry) return normalized;
-	if (normalized === normalizedEntry) return "";
-	if (normalized.startsWith(`${normalizedEntry}/`)) return normalized.slice(normalizedEntry.length + 1);
-	return normalized;
-}
-function normalizeDocsListMatchValue(value) {
-	return normalizePathSegment(value.replace(/^https?:\/\/[^/]+/i, "").replace(/\.md$/i, "")).trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-").replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "");
-}
-function cloneDocsSection(section) {
-	return {
-		...section,
-		pages: section.pages.map((page) => ({ ...page })),
-		sections: section.sections.map(cloneDocsSection)
-	};
-}
-function flattenDocsSectionPages(section) {
-	const seen = /* @__PURE__ */ new Set();
-	const pages = [];
-	function add(page) {
-		if (seen.has(page.url)) return;
-		seen.add(page.url);
-		pages.push({ ...page });
-	}
-	function visit(current) {
-		current.pages.forEach(add);
-		current.sections.forEach(visit);
-	}
-	visit(section);
-	return pages;
-}
-function countDocsSections(sections) {
-	return sections.reduce((total, section) => total + 1 + countDocsSections(section.sections), 0);
-}
-function extractDocsMcpCodeExamples(page) {
-	const source = page.agentRawContent ?? page.agentFallbackRawContent ?? page.agentContent ?? page.agentFallbackContent ?? page.rawContent ?? page.content;
-	if (!source) return [];
-	const examples = [];
-	const lines = source.split("\n");
-	let index = 0;
-	let openFence = null;
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!openFence) {
-			const openMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-			if (!openMatch) continue;
-			openFence = {
-				marker: openMatch[1],
-				info: openMatch[2]?.trim() ?? "",
-				code: []
-			};
-			continue;
-		}
-		if (isClosingFence(trimmed, openFence.marker)) {
-			const parsed = parseCodeFenceInfo(openFence.info);
-			const meta = parsed.meta;
-			const title = readStringMeta(meta, "title");
-			const framework = readStringMeta(meta, "framework");
-			const packageManager = readStringMeta(meta, "packageManager");
-			const runnable = readBooleanMeta(meta, "runnable") ?? false;
-			index += 1;
-			examples.push({
-				id: `${page.url}#code-${index}`,
-				page: {
-					slug: page.slug,
-					url: page.url,
-					title: page.title,
-					description: page.description,
-					sourcePath: page.sourcePath,
-					lastModified: page.lastModified
-				},
-				language: parsed.language,
-				title,
-				framework,
-				packageManager,
-				runnable,
-				meta,
-				code: openFence.code.join("\n")
-			});
-			openFence = null;
-			continue;
-		}
-		openFence.code.push(line);
-	}
-	return examples;
-}
-function filterDocsCodeExamples(examples, filters) {
-	const query = filters.query?.toLowerCase();
-	const framework = filters.framework?.toLowerCase();
-	const packageManager = filters.packageManager?.toLowerCase();
-	const language = filters.language?.toLowerCase();
-	return examples.filter((example) => {
-		if (framework && example.framework?.toLowerCase() !== framework) return false;
-		if (packageManager && example.packageManager?.toLowerCase() !== packageManager) return false;
-		if (language && example.language?.toLowerCase() !== language) return false;
-		if (filters.runnable !== void 0 && example.runnable !== filters.runnable) return false;
-		if (!query) return true;
-		return getCodeExampleSearchText(example).toLowerCase().includes(query);
-	}).slice(0, filters.limit);
-}
-function isClosingFence(trimmedLine, marker) {
-	if (!trimmedLine.startsWith(marker)) return false;
-	return trimmedLine.slice(marker.length).trim().length === 0;
-}
-function parseCodeFenceInfo(info) {
-	const trimmed = info.trim();
-	if (!trimmed) return { meta: {} };
-	const firstToken = trimmed.match(/^(\S+)/)?.[1] ?? "";
-	const language = firstToken && !firstToken.includes("=") ? firstToken : void 0;
-	const attributeSource = language ? trimmed.slice(firstToken.length).trim() : trimmed;
-	const meta = {};
-	const attributePattern = /([A-Za-z_:][\w:.-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\s"']+)))?/g;
-	let match;
-	while (match = attributePattern.exec(attributeSource)) {
-		const key = match[1];
-		meta[key] = match[2] ?? match[3] ?? match[4] ?? true;
-	}
-	return {
-		language,
-		meta
-	};
-}
-function readStringMeta(meta, key) {
-	const value = meta[key];
-	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
-}
-function readBooleanMeta(meta, key) {
-	const value = meta[key];
-	if (typeof value === "boolean") return value;
-	if (typeof value !== "string") return void 0;
-	const normalized = value.trim().toLowerCase();
-	if (!normalized || normalized === "true" || normalized === "1" || normalized === "yes") return true;
-	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
-	return true;
-}
-function getCodeExampleSearchText(example) {
-	return [
-		example.id,
-		example.page.slug,
-		example.page.url,
-		example.page.title,
-		example.page.description,
-		example.page.sourcePath,
-		example.language,
-		example.title,
-		example.framework,
-		example.packageManager,
-		...Object.entries(example.meta).map(([key, value]) => `${key} ${String(value)}`),
-		example.code
-	].filter((value) => typeof value === "string").join("\n");
-}
-function limitDocsMcpText(value, maxChars) {
-	if (maxChars === void 0 || value.length <= maxChars) return {
-		text: value,
-		truncated: false
-	};
-	if (maxChars <= 1) return {
-		text: value.slice(0, maxChars),
-		truncated: true
-	};
-	const suffix = "…";
-	const available = Math.max(0, maxChars - 1);
-	let selected = value.slice(0, available);
-	const paragraphBreak = selected.lastIndexOf("\n\n");
-	const lineBreak = selected.lastIndexOf("\n");
-	const preferredBreak = paragraphBreak >= available * .6 ? paragraphBreak : lineBreak;
-	if (preferredBreak >= available * .6) selected = selected.slice(0, preferredBreak);
-	return {
-		text: `${selected.trimEnd()}${suffix}`.slice(0, maxChars),
-		truncated: true
-	};
-}
-function docsMcpUtf8Bytes(value) {
-	return UTF8_ENCODER.encode(value).byteLength;
-}
-function limitDocsMcpUtf8Bytes(value, maxUtf8Bytes) {
-	if (docsMcpUtf8Bytes(value) <= maxUtf8Bytes) return {
-		text: value,
-		truncated: false
-	};
-	if (maxUtf8Bytes <= 0) return {
-		text: "",
-		truncated: true
-	};
-	const suffix = "…";
-	const suffixBytes = docsMcpUtf8Bytes(suffix);
-	const availableBytes = Math.max(0, maxUtf8Bytes - suffixBytes);
-	let selected = "";
-	let selectedBytes = 0;
-	for (const character of value) {
-		const characterBytes = docsMcpUtf8Bytes(character);
-		if (selectedBytes + characterBytes > availableBytes) break;
-		selected += character;
-		selectedBytes += characterBytes;
-	}
-	const paragraphBreak = selected.lastIndexOf("\n\n");
-	const lineBreak = selected.lastIndexOf("\n");
-	const preferredBreak = paragraphBreak >= selected.length * .6 ? paragraphBreak : lineBreak;
-	if (preferredBreak >= selected.length * .6) selected = selected.slice(0, preferredBreak);
-	if (suffixBytes > maxUtf8Bytes) return {
-		text: ".".repeat(maxUtf8Bytes),
-		truncated: true
-	};
-	return {
-		text: `${selected.trimEnd()}${suffix}`,
-		truncated: true
-	};
-}
-function renderBoundedDocsMcpSectionError(options) {
-	const maxChars = options.maxChars ?? Number.POSITIVE_INFINITY;
-	const shorten = (value, max) => limitDocsMcpText(value, max).text;
-	const availableSections = [];
-	const base = {
-		error: "section_not_found",
-		message: `No section matched "${shorten(options.requestedSection, 80)}" in "${shorten(options.pageUrl, 80)}".`,
-		availableSections,
-		truncated: false
-	};
-	const serialize = () => JSON.stringify(base, null, 2);
-	for (const section of options.availableSections) {
-		availableSections.push({
-			title: shorten(section.title, 80),
-			anchor: shorten(section.anchor, 80)
-		});
-		if (serialize().length > maxChars) {
-			availableSections.pop();
-			base.truncated = true;
-			break;
-		}
-	}
-	if (availableSections.length < options.availableSections.length) base.truncated = true;
-	if (serialize().length <= maxChars) return serialize();
-	const minimalText = JSON.stringify({
-		error: "section_not_found",
-		message: "The requested section was not found.",
-		availableSections: [],
-		truncated: true
-	});
-	if (minimalText.length <= maxChars) return minimalText;
-	return JSON.stringify({ error: "section_not_found" });
-}
-function toStructuredDocsMcpPage(page) {
-	return {
-		slug: page.slug,
-		url: page.url,
-		title: page.title,
-		description: page.description,
-		related: page.related,
-		icon: page.icon,
-		sourcePath: page.sourcePath,
-		lastModified: page.lastModified,
-		locale: page.locale,
-		framework: page.framework,
-		version: page.version,
-		tags: page.tags
-	};
-}
-function getDocsMcpSourceMarkdown(page) {
-	return page.agentRawContent ?? page.agentFallbackRawContent ?? page.agentContent ?? page.agentFallbackContent ?? page.rawContent ?? page.content;
-}
-function resolveDocsMcpScopeField(pageValue, contractValue, filter, overlaps, matchesFilter) {
-	const pageValues = normalizeAgentScopeValues(pageValue);
-	const contractValues = normalizeAgentScopeValues(contractValue);
-	const conflict = pageValues.length > 0 && contractValues.length > 0 && !pageValues.some((topLevel) => contractValues.some((contract) => overlaps(topLevel, contract)));
-	const pageMatches = !filter || pageValues.length === 0 || pageValues.some((candidate) => matchesFilter(filter, candidate));
-	const contractMatches = !filter || contractValues.length === 0 || contractValues.some((candidate) => matchesFilter(filter, candidate));
-	const matchedContract = filter ? contractValues.find((candidate) => matchesFilter(filter, candidate)) : void 0;
-	return {
-		conflict,
-		matches: !conflict && pageMatches && contractMatches,
-		value: pageValues[0] ?? matchedContract ?? (contractValues.length === 1 ? contractValues[0] : void 0)
-	};
-}
-function resolveDocsMcpEffectiveScope(page, filters) {
-	const framework = resolveDocsMcpScopeField(page.framework, page.agent?.appliesTo?.framework, filters.framework, (left, right) => normalizeAgentFramework(left) === normalizeAgentFramework(right), (filter, candidate) => normalizeAgentFramework(filter) === normalizeAgentFramework(candidate));
-	const version = resolveDocsMcpScopeField(page.version, page.agent?.appliesTo?.version, filters.version, agentVersionConstraintsOverlap, agentVersionConstraintMatches);
-	const locale = page.locale?.trim() || void 0;
-	const localeMatches = !filters.locale || !locale || normalizeAgentLocale(locale) === normalizeAgentLocale(filters.locale);
-	return {
-		framework: framework.value,
-		version: version.value,
-		locale,
-		conflict: framework.conflict || version.conflict,
-		matches: framework.matches && version.matches && localeMatches
-	};
-}
-function getDocsMcpResultPageUrl(value) {
-	return value.split("#", 1)[0] ?? value;
-}
-function getDocsMcpResultAnchor(value) {
-	const anchor = value.split("#", 2)[1];
-	if (!anchor) return void 0;
-	try {
-		return decodeURIComponent(anchor);
-	} catch {
-		return anchor;
-	}
-}
-async function buildDocsMcpContext(options) {
-	const scopedPageEntries = options.pages.flatMap((page) => {
-		const scope = resolveDocsMcpEffectiveScope(page, {
-			framework: options.framework,
-			version: options.version,
-			locale: options.locale
-		});
-		return scope.matches && !scope.conflict ? [{
-			page,
-			scope
-		}] : [];
-	});
-	const scopedPages = scopedPageEntries.map(({ page }) => page);
-	const scopeByPage = new Map(scopedPageEntries.map(({ page, scope }) => [page, scope]));
-	const maxResults = typeof options.maxResults === "number" && Number.isFinite(options.maxResults) ? Math.max(1, Math.min(50, Math.floor(options.maxResults))) : 50;
-	const orderedResults = [...await performDocsSearch({
-		pages: toSearchSourcePages(scopedPages),
-		query: options.query,
-		search: {
-			enabled: true,
-			provider: "simple",
-			maxResults: 50,
-			chunking: { strategy: "section" }
-		},
-		audience: "agent",
-		locale: options.locale,
-		siteTitle: options.siteTitle,
-		limit: 50
-	})].sort((left, right) => {
-		const scoreDelta = (right.score ?? 0) - (left.score ?? 0);
-		if (scoreDelta !== 0) return scoreDelta;
-		if (left.url !== right.url) return left.url < right.url ? -1 : 1;
-		if ((left.section ?? "") !== (right.section ?? "")) return (left.section ?? "") < (right.section ?? "") ? -1 : 1;
-		if (left.id === right.id) return 0;
-		return left.id < right.id ? -1 : 1;
-	});
-	const sectionPageUrls = new Set(orderedResults.filter((result) => result.section).map((result) => normalizeUrlPath(getDocsMcpResultPageUrl(result.url))));
-	const seen = /* @__PURE__ */ new Set();
-	const resolvedCandidates = orderedResults.filter((result) => {
-		const pageUrl = normalizeUrlPath(getDocsMcpResultPageUrl(result.url));
-		if (!result.section && sectionPageUrls.has(pageUrl)) return false;
-		const key = `${pageUrl}#${getDocsMcpResultAnchor(result.url) ?? result.section ?? ""}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	}).flatMap((result) => {
-		const page = findDocsPage(scopedPages, getDocsMcpResultPageUrl(result.url), options.entry);
-		if (!page) return [];
-		const scope = scopeByPage.get(page);
-		if (!scope) return [];
-		const document = upsertPageAgentContractMarkdown(getDocsMcpSourceMarkdown(page), page.agent);
-		const resultAnchor = getDocsMcpResultAnchor(result.url);
-		const selectedSection = resultAnchor ? findDocsMarkdownSection(document, resultAnchor) : result.section ? findDocsMarkdownSection(document, result.section) : void 0;
-		if ((resultAnchor || result.section) && !selectedSection) return [];
-		const rawContent = (selectedSection?.content ?? document).trim();
-		if (!rawContent) return [];
-		return [{
-			result,
-			page,
-			scope,
-			selectedSection,
-			rawContent
-		}];
-	}).slice(0, maxResults);
-	const maxUtf8Bytes = options.tokenBudget;
-	const separator = "\n\n---\n\n";
-	const separatorUtf8Bytes = docsMcpUtf8Bytes(separator);
-	const blocks = [];
-	const sources = [];
-	let usedUtf8Bytes = 0;
-	for (const { result, page, scope, selectedSection, rawContent } of resolvedCandidates) {
-		const anchor = selectedSection?.anchor;
-		const sourceUrl = anchor ? `${page.url}#${anchor}` : page.url;
-		const headerLines = [`## ${page.title}`, `Source: ${sourceUrl}`];
-		if (selectedSection?.title) headerLines.push(`Section: ${selectedSection.title}`);
-		if (scope.framework) headerLines.push(`Framework: ${scope.framework}`);
-		if (scope.version) headerLines.push(`Version: ${scope.version}`);
-		if (scope.locale) headerLines.push(`Locale: ${scope.locale}`);
-		const header = headerLines.join("\n");
-		const separatorBytes = blocks.length === 0 ? 0 : separatorUtf8Bytes;
-		const headerBytes = docsMcpUtf8Bytes(`${header}\n\n`);
-		const availableForContent = maxUtf8Bytes - usedUtf8Bytes - separatorBytes - headerBytes;
-		if (availableForContent <= 0) break;
-		const limited = limitDocsMcpUtf8Bytes(rawContent, availableForContent);
-		if (!limited.text) break;
-		const block = `${header}\n\n${limited.text}`;
-		const blockUtf8Bytes = docsMcpUtf8Bytes(block);
-		blocks.push(block);
-		usedUtf8Bytes += separatorBytes + blockUtf8Bytes;
-		sources.push({
-			id: result.id,
-			title: page.title,
-			pageUrl: page.url,
-			url: sourceUrl,
-			section: selectedSection?.title,
-			anchor,
-			sourcePath: page.sourcePath,
-			lastModified: page.lastModified,
-			locale: scope.locale,
-			framework: scope.framework,
-			version: scope.version,
-			tags: page.tags ? [...page.tags] : void 0,
-			score: result.score,
-			content: limited.text,
-			chars: limited.text.length,
-			utf8Bytes: docsMcpUtf8Bytes(limited.text),
-			truncated: limited.truncated
-		});
-		if (limited.truncated) break;
-	}
-	const context = blocks.join(separator);
-	usedUtf8Bytes = docsMcpUtf8Bytes(context);
-	const remainingUtf8Bytes = Math.max(0, maxUtf8Bytes - usedUtf8Bytes);
-	const truncated = sources.some((source) => source.truncated) || sources.length < resolvedCandidates.length;
-	return {
-		query: options.query,
-		filters: {
-			framework: options.framework,
-			version: options.version,
-			locale: options.locale
-		},
-		budget: {
-			requestedTokens: options.tokenBudget,
-			strategy: "utf8-bytes",
-			maxUtf8Bytes,
-			usedUtf8Bytes,
-			conservativeTokenUpperBound: usedUtf8Bytes,
-			remainingUtf8Bytes,
-			truncated
-		},
-		resultCount: sources.length,
-		candidateCount: resolvedCandidates.length,
-		context,
-		sources
-	};
-}
-function findDocsPage(pages, requestedPath, entry) {
-	const normalizedRequest = normalizeRequestedPath(requestedPath, entry);
-	for (const page of pages) if (normalizeUrlPath(page.url) === normalizedRequest) return page;
-	const normalizedSlug = normalizePathSegment(requestedPath.replace(/^\//, ""));
-	for (const page of pages) if (normalizePathSegment(page.slug) === normalizedSlug) return page;
-	return null;
-}
-function normalizeRequestedPath(requestedPath, entry) {
-	const trimmed = requestedPath.trim();
-	if (!trimmed) return "/";
-	if (/^https?:\/\//i.test(trimmed)) try {
-		return normalizeUrlPath(new URL(trimmed).pathname);
-	} catch {
-		return "/";
-	}
-	const normalized = normalizeUrlPath(trimmed.startsWith("/") ? trimmed : `/${trimmed}`);
-	if (!entry) return normalized;
-	const normalizedEntry = `/${normalizePathSegment(entry)}`;
-	if (normalized === normalizedEntry || normalized.startsWith(`${normalizedEntry}/`)) return normalized;
-	const slug = normalizePathSegment(trimmed);
-	return slug ? normalizeUrlPath(`${normalizedEntry}/${slug}`) : normalizedEntry;
-}
-function normalizeUrlPath(value) {
-	const normalized = value.replace(/\/+/g, "/");
-	if (normalized === "/") return normalized;
-	return normalized.replace(/\/+$/, "");
-}
-function renderPageDocument(page) {
-	const explicitAgentContent = page.agentRawContent ?? page.agentContent;
-	if (explicitAgentContent !== void 0) return upsertPageAgentContractMarkdown(explicitAgentContent, page.agent);
-	const relatedLines = renderDocsRelatedMarkdownLines(page.related);
-	const lines = [`# ${page.title}`, `URL: ${page.url}`];
-	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 lines.join("\n");
-}
-function renderNavigationTree(tree) {
-	const lines = [`# ${tree.name}`, ""];
-	function visit(nodes, depth) {
-		const prefix = "  ".repeat(depth);
-		for (const node of nodes) {
-			if (node.type === "page") {
-				lines.push(`${prefix}- ${node.name} (${node.url})`);
-				continue;
-			}
-			lines.push(`${prefix}- ${node.name}`);
-			if (node.index) lines.push(`${prefix}  - Overview (${node.index.url})`);
-			visit(node.children, depth + 1);
-		}
-	}
-	visit(tree.children, 0);
-	return lines.join("\n");
-}
-function slugToKey(slug) {
-	const normalized = normalizePathSegment(slug);
-	return normalized.length > 0 ? normalized.replace(/\//g, "-") : "index";
-}
-function toPageResourceUri(url) {
-	return `docs://${normalizePathSegment(url.replace(/^\//, "")) || "docs"}`;
-}
-
-//#endregion
-export { DEFAULT_DOCS_MCP_CORS_ALLOWED_HEADERS, DEFAULT_DOCS_MCP_CORS_EXPOSED_HEADERS, DEFAULT_DOCS_MCP_CORS_MAX_AGE_SECONDS, DEFAULT_DOCS_MCP_MAX_BODY_BYTES, DOCS_CONFIG_SCHEMA_OPTIONS, buildDocsMcpContext, createDocsMcpHttpHandler, createDocsMcpServer, createFilesystemDocsMcpSource, getDocsConfigSchema, normalizeDocsMcpRoute, resolveDocsMcpConfig, runDocsMcpStdio };