@farming-labs/docs 0.2.62 → 0.2.64

package/dist/search-B6V6qtiI.mjs

@@ -0,0 +1,1826 @@
+import { H as isDocsAgentDiscoveryRequest, J as isDocsSkillRequest, Qt as upsertPageAgentContractMarkdown, U as isDocsAgentsRequest, Vt as PAGE_AGENT_CONTRACT_END_MARKER, Wt as PAGE_AGENT_CONTRACT_START_MARKER, Yt as renderPageAgentContractMarkdown, at as resolveDocsAgentFeedbackConfig, gt as resolveDocsSkillFormat, lt as resolveDocsLlmsTxtRequest, ot as resolveDocsAgentFeedbackRequest, pt as resolveDocsMarkdownRequest, st as resolveDocsAgentsFormat, wt as resolveDocsAudienceMdxContent } from "./agent-DKKptIgy.mjs";
+
+//#region src/telemetry.ts
+const DOCS_PACKAGE_NAME = "@farming-labs/docs";
+const DOCS_PACKAGE_VERSION = "0.2.25";
+const DEFAULT_DOCS_TELEMETRY_ENDPOINT = "https://docs.farming-labs.dev/api/telemetry/events";
+const PROJECT_TELEMETRY_CACHE_TTL_MS = 1440 * 60 * 1e3;
+const PROJECT_TELEMETRY_CACHE_MAX_KEYS = 256;
+function getRuntimeEnv() {
+	if (typeof process === "undefined" || !process.env) return;
+	return process.env;
+}
+function readRuntimeEnv(name) {
+	const value = getRuntimeEnv()?.[name]?.trim();
+	return value ? value : void 0;
+}
+function isTruthyEnv(value) {
+	return /^(1|true|yes|on)$/i.test(value ?? "");
+}
+function isFalsyEnv(value) {
+	return /^(0|false|no|off)$/i.test(value ?? "");
+}
+function isBrowserRuntime() {
+	return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isProductionTelemetryRuntime() {
+	if (isBrowserRuntime()) return false;
+	const env = getRuntimeEnv();
+	if (!env) return true;
+	if (env.NODE_ENV === "test") return false;
+	if (env.VERCEL_ENV === "production") return true;
+	if (env.CONTEXT === "production" && isTruthyEnv(env.NETLIFY)) return true;
+	if (isTruthyEnv(env.CF_PAGES)) return true;
+	if (env.RENDER_SERVICE_ID || env.FLY_APP_NAME || env.RAILWAY_ENVIRONMENT) return true;
+	return env.NODE_ENV === "production";
+}
+function resolveDocsTelemetryConfig(telemetry) {
+	const envToggle = readRuntimeEnv("DOCS_TELEMETRY");
+	const envDisabled = readRuntimeEnv("DOCS_TELEMETRY_DISABLED");
+	if (isFalsyEnv(envToggle) || isTruthyEnv(envDisabled) || telemetry === false) return { enabled: false };
+	const objectConfig = telemetry && typeof telemetry === "object" ? telemetry : void 0;
+	if (objectConfig?.enabled === false) return { enabled: false };
+	return {
+		enabled: telemetry === true || objectConfig?.enabled === true || isTruthyEnv(envToggle) || isProductionTelemetryRuntime(),
+		endpoint: objectConfig?.endpoint?.trim() || readRuntimeEnv("DOCS_TELEMETRY_ENDPOINT") || DEFAULT_DOCS_TELEMETRY_ENDPOINT
+	};
+}
+function readRequestOrigin(request) {
+	if (!request?.url) return void 0;
+	try {
+		return new URL(request.url).origin;
+	} catch {
+		return;
+	}
+}
+/** Normalize an HTTP(S) telemetry site value to its origin. */
+function normalizeDocsTelemetryOrigin(candidate) {
+	if (typeof candidate !== "string") return void 0;
+	const trimmed = candidate.trim();
+	if (!trimmed) return void 0;
+	try {
+		const hasScheme = /^[a-z][a-z\d+.-]*:(?!\d)/i.test(trimmed);
+		const url = new URL(hasScheme ? trimmed : `https://${trimmed}`);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+		return url.origin;
+	} catch {
+		return;
+	}
+}
+/** Return whether a telemetry origin points at a local development server. */
+function isLocalDocsTelemetryOrigin(candidate) {
+	const origin = normalizeDocsTelemetryOrigin(candidate);
+	if (!origin) return false;
+	const hostname = new URL(origin).hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.+$/, "");
+	if ([
+		"localhost",
+		"localhost.localdomain",
+		"localhost6",
+		"localhost6.localdomain6",
+		"ip6-localhost",
+		"ip6-loopback"
+	].includes(hostname) || hostname.endsWith(".localhost")) return true;
+	if (hostname === "::" || hostname === "::1") return true;
+	const ipv4 = hostname.split(".").map((part) => Number(part));
+	if (ipv4.length === 4 && ipv4.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)) return ipv4[0] === 127 || ipv4.every((part) => part === 0);
+	return /^::ffff:7f[0-9a-f]{2}:/.test(hostname) || hostname === "::ffff:0:0";
+}
+function isBlockedDocsTelemetryOrigin(candidate) {
+	if (candidate === void 0) return false;
+	return !normalizeDocsTelemetryOrigin(candidate) || isLocalDocsTelemetryOrigin(candidate);
+}
+function readDeploymentOrigin() {
+	const candidates = [
+		readRuntimeEnv("DOCS_SITE_URL"),
+		readRuntimeEnv("NEXT_PUBLIC_BASE_URL"),
+		readRuntimeEnv("NEXT_PUBLIC_SITE_URL"),
+		readRuntimeEnv("SITE_URL"),
+		readRuntimeEnv("URL"),
+		readRuntimeEnv("CF_PAGES_URL"),
+		readRuntimeEnv("VERCEL_PROJECT_PRODUCTION_URL"),
+		readRuntimeEnv("VERCEL_URL"),
+		readRuntimeEnv("DEPLOY_PRIME_URL")
+	];
+	for (const candidate of candidates) {
+		const origin = normalizeDocsTelemetryOrigin(candidate);
+		if (origin) return origin;
+	}
+}
+function detectDeployment() {
+	const env = getRuntimeEnv();
+	if (!env) return void 0;
+	if (env.VERCEL || env.VERCEL_ENV) return {
+		provider: "vercel",
+		environment: env.VERCEL_ENV,
+		id: env.VERCEL_DEPLOYMENT_ID ?? env.VERCEL_GIT_COMMIT_SHA,
+		region: env.VERCEL_REGION
+	};
+	if (env.NETLIFY) return {
+		provider: "netlify",
+		environment: env.CONTEXT,
+		id: env.DEPLOY_ID ?? env.COMMIT_REF
+	};
+	if (env.CF_PAGES) return {
+		provider: "cloudflare-pages",
+		environment: env.CF_PAGES_BRANCH,
+		id: env.CF_PAGES_COMMIT_SHA
+	};
+	if (env.RENDER_SERVICE_ID) return {
+		provider: "render",
+		environment: env.RENDER_ENV,
+		id: env.RENDER_SERVICE_ID
+	};
+	if (env.FLY_APP_NAME) return {
+		provider: "fly",
+		environment: env.FLY_APP_NAME,
+		id: env.FLY_ALLOC_ID,
+		region: env.FLY_REGION
+	};
+	if (env.RAILWAY_ENVIRONMENT) return {
+		provider: "railway",
+		environment: env.RAILWAY_ENVIRONMENT,
+		id: env.RAILWAY_DEPLOYMENT_ID
+	};
+	return env.NODE_ENV === "production" ? { environment: "production" } : void 0;
+}
+function detectRuntime() {
+	if (typeof process !== "undefined" && process.versions?.node) return {
+		name: "node",
+		version: process.versions.node
+	};
+	if (typeof navigator !== "undefined" && navigator.userAgent) return { name: "web-standard" };
+}
+function isObjectConfigEnabled(value, defaultEnabled) {
+	if (value === false) return false;
+	if (value === true) return true;
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const enabled = value.enabled;
+		return enabled === false ? false : defaultEnabled || enabled === true;
+	}
+	return defaultEnabled;
+}
+function hasObjectConfig(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function getDocsTelemetryFeatures(config) {
+	const pageActions = config.pageActions;
+	const feedback = config.feedback;
+	return {
+		search: isObjectConfigEnabled(config.search, true),
+		ai: isObjectConfigEnabled(config.ai, false),
+		mcp: isObjectConfigEnabled(config.mcp, true),
+		llmsTxt: isObjectConfigEnabled(config.llmsTxt, true),
+		pageActions: hasObjectConfig(pageActions),
+		feedback: feedback === true || hasObjectConfig(feedback) && feedback.enabled !== false,
+		agentFeedback: feedback !== false && !(hasObjectConfig(feedback) && feedback.agent === false) && !(hasObjectConfig(feedback) && hasObjectConfig(feedback.agent) && feedback.agent.enabled === false),
+		sitemap: isObjectConfigEnabled(config.sitemap, true),
+		robots: isObjectConfigEnabled(config.robots, true),
+		apiReference: isObjectConfigEnabled(config.apiReference, false),
+		staticExport: config.staticExport === true,
+		changelog: isObjectConfigEnabled(config.changelog, false),
+		cloud: typeof config.cloud !== "undefined" && isObjectConfigEnabled(config.cloud, true),
+		review: isObjectConfigEnabled(config.review, true),
+		codeBlocksValidate: hasObjectConfig(config.codeBlocks) && Boolean(config.codeBlocks.validate)
+	};
+}
+function createDocsTelemetryEvent(config, input, context = {}) {
+	const telemetryConfig = config.telemetry && typeof config.telemetry === "object" ? config.telemetry : void 0;
+	const siteOriginCandidates = [
+		context.siteOrigin,
+		input.site?.origin,
+		telemetryConfig?.siteOrigin,
+		readRequestOrigin(context.request),
+		readDeploymentOrigin()
+	];
+	if (siteOriginCandidates.some(isBlockedDocsTelemetryOrigin)) return void 0;
+	const siteOrigin = siteOriginCandidates.map(normalizeDocsTelemetryOrigin).find((origin) => Boolean(origin));
+	const deployment = input.deployment ?? detectDeployment();
+	const properties = context.properties || input.properties ? {
+		...input.properties,
+		...context.properties
+	} : void 0;
+	return {
+		...input,
+		timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+		package: {
+			name: DOCS_PACKAGE_NAME,
+			version: DOCS_PACKAGE_VERSION,
+			...input.package
+		},
+		framework: input.framework ?? context.framework,
+		runtime: input.runtime ?? detectRuntime(),
+		site: siteOrigin ? { origin: siteOrigin } : input.site,
+		deployment,
+		features: input.features ?? getDocsTelemetryFeatures(config),
+		properties
+	};
+}
+function projectEventKey(event) {
+	return [
+		event.package.name,
+		event.package.version,
+		event.framework ?? "",
+		event.site?.origin ?? "",
+		event.deployment?.provider ?? "",
+		event.deployment?.environment ?? "",
+		event.deployment?.id ?? ""
+	].join("|");
+}
+function getSentProjectKeys() {
+	const globalValue = globalThis;
+	globalValue.__farmingLabsDocsTelemetryProjectKeys__ ??= /* @__PURE__ */ new Map();
+	return globalValue.__farmingLabsDocsTelemetryProjectKeys__;
+}
+function pruneSentProjectKeys(sent, now) {
+	for (const [key, expiresAt] of sent) if (expiresAt <= now) sent.delete(key);
+	while (sent.size >= PROJECT_TELEMETRY_CACHE_MAX_KEYS) {
+		const oldestKey = sent.keys().next().value;
+		if (!oldestKey) return;
+		sent.delete(oldestKey);
+	}
+}
+async function emitDocsTelemetryEvent(telemetry, event) {
+	const resolved = resolveDocsTelemetryConfig(telemetry);
+	const eventSiteOrigin = event.site?.origin;
+	const normalizedSiteOrigin = normalizeDocsTelemetryOrigin(eventSiteOrigin);
+	if (!resolved.enabled || !resolved.endpoint || typeof fetch !== "function" || eventSiteOrigin !== void 0 && (!normalizedSiteOrigin || isLocalDocsTelemetryOrigin(eventSiteOrigin))) return;
+	const eventToSend = normalizedSiteOrigin ? {
+		...event,
+		site: { origin: normalizedSiteOrigin }
+	} : event;
+	try {
+		const ingestKey = readRuntimeEnv("DOCS_TELEMETRY_INGEST_KEY");
+		const headers = { "content-type": "application/json" };
+		if (ingestKey) headers["x-docs-telemetry-key"] = ingestKey;
+		await fetch(resolved.endpoint, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ event: eventToSend }),
+			keepalive: true
+		});
+	} catch {}
+}
+function emitDocsTelemetryProjectEvent(config, context = {}) {
+	const event = createDocsTelemetryEvent(config, { type: "project_detected" }, context);
+	if (!event) return;
+	const key = projectEventKey(event);
+	const sent = getSentProjectKeys();
+	const now = Date.now();
+	const expiresAt = sent.get(key);
+	if (expiresAt && expiresAt > now) return;
+	if (typeof expiresAt === "number") sent.delete(key);
+	pruneSentProjectKeys(sent, now);
+	sent.set(key, now + PROJECT_TELEMETRY_CACHE_TTL_MS);
+	emitDocsTelemetryEvent(config.telemetry, event);
+}
+function emitDocsTelemetryAgentSurfaceEvent(config, context) {
+	const event = createDocsTelemetryEvent(config, {
+		type: context.surface === "mcp" ? "mcp_request" : "agent_surface_used",
+		properties: { surface: context.surface }
+	}, context);
+	if (!event) return;
+	emitDocsTelemetryEvent(config.telemetry, event);
+}
+function emitDocsTelemetryMcpToolEvent(config, context) {
+	const event = createDocsTelemetryEvent(config, {
+		type: "mcp_tool_used",
+		properties: {
+			tool: context.tool,
+			locale: context.locale,
+			resultCount: context.resultCount
+		}
+	}, context);
+	if (!event) return;
+	emitDocsTelemetryEvent(config.telemetry, event);
+}
+function inferDocsTelemetryAgentSurface(request, options) {
+	const url = new URL(request.url);
+	const method = request.method.toUpperCase();
+	const feedbackRequest = resolveDocsAgentFeedbackRequest(url, resolveDocsAgentFeedbackConfig(options.feedback));
+	if ((method === "GET" || method === "HEAD") && isDocsAgentDiscoveryRequest(url)) return "agent_spec";
+	if ((method === "GET" || method === "HEAD") && feedbackRequest?.kind === "schema") return "agent_feedback_schema";
+	if (method === "POST" && feedbackRequest?.kind === "submit") return "agent_feedback_submit";
+	if (method === "GET" || method === "HEAD") {
+		if (isDocsAgentsRequest(url) || resolveDocsAgentsFormat(url) === "agents") return "agents";
+		if (isDocsSkillRequest(url) || resolveDocsSkillFormat(url) === "skill") return "skill";
+		if (resolveDocsMarkdownRequest(options.entry, url, request)) return "markdown";
+		if (resolveDocsLlmsTxtRequest(url, options.llmsTxt, options.entry)) return "llms";
+	}
+	if (method === "POST") return "ask_ai";
+}
+
+//#endregion
+//#region src/sidebar.ts
+function resolvePageSidebarFolderIndexBehavior(sidebar) {
+	if (!sidebar || typeof sidebar !== "object") return void 0;
+	const value = sidebar.folderIndexBehavior;
+	return value === "link" || value === "toggle" || value === "hidden" ? value : void 0;
+}
+function normalizeSidebarFolderBehaviorPath(path) {
+	if (!path) return void 0;
+	let value = path.trim();
+	if (!value) return void 0;
+	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(value)) try {
+		value = new URL(value).pathname;
+	} catch {
+		return;
+	}
+	else value = value.split("#", 1)[0]?.split("?", 1)[0] ?? value;
+	if (!value.startsWith("/")) value = `/${value}`;
+	return value.replace(/\/$/, "") || "/";
+}
+function resolveSidebarFolderIndexBehavior(sidebar, defaultBehavior = "link") {
+	if (sidebar === void 0 || sidebar === true || sidebar === false) return defaultBehavior;
+	if (sidebar.folderIndexBehavior === "toggle") return "toggle";
+	if (sidebar.folderIndexBehavior === "hidden") return "hidden";
+	if (sidebar.folderIndexBehavior === "link") return "link";
+	return defaultBehavior;
+}
+function resolveSidebarFolderIndexBehaviorForPath(sidebar, folderPath, defaultBehavior = "link") {
+	const fallback = resolveSidebarFolderIndexBehavior(sidebar, defaultBehavior);
+	if (!sidebar || typeof sidebar !== "object") return fallback;
+	const normalizedPath = normalizeSidebarFolderBehaviorPath(folderPath);
+	if (!normalizedPath) return fallback;
+	for (const [rawPath, override] of Object.entries(sidebar.folderIndexBehaviorOverrides ?? {})) if (normalizeSidebarFolderBehaviorPath(rawPath) === normalizedPath) return override === "link" || override === "toggle" || override === "hidden" ? override : fallback;
+	return fallback;
+}
+function applySidebarFolderIndexBehavior(tree, behaviorOrOptions) {
+	const resolveBehavior = typeof behaviorOrOptions === "string" ? () => behaviorOrOptions : (folderPath) => resolveSidebarFolderIndexBehaviorForPath(behaviorOrOptions.sidebar, folderPath, behaviorOrOptions.defaultBehavior);
+	function mapNode(node) {
+		if (!node || typeof node !== "object") return node;
+		const candidate = node;
+		if (candidate.type !== "folder" || !Array.isArray(candidate.children)) return node;
+		const children = candidate.children.map(mapNode);
+		const index = candidate.index ? mapNode(candidate.index) : void 0;
+		const folderPath = (typeof candidate.url === "string" ? candidate.url : void 0) || (candidate.index && typeof candidate.index === "object" && "url" in candidate.index && typeof candidate.index.url === "string" ? candidate.index.url ?? void 0 : void 0);
+		const behavior = (candidate.folderIndexBehavior === "link" || candidate.folderIndexBehavior === "toggle" || candidate.folderIndexBehavior === "hidden" ? candidate.folderIndexBehavior : void 0) ?? resolveBehavior(folderPath);
+		if (behavior === "link") return {
+			...candidate,
+			folderIndexBehavior: void 0,
+			index,
+			children
+		};
+		if (behavior === "hidden") return {
+			...candidate,
+			folderIndexBehavior: void 0,
+			index: void 0,
+			url: void 0,
+			children
+		};
+		return {
+			...candidate,
+			folderIndexBehavior: void 0,
+			index: void 0,
+			url: void 0,
+			children: index ? [index, ...children] : children
+		};
+	}
+	return {
+		...tree,
+		children: tree.children.map(mapNode)
+	};
+}
+
+//#endregion
+//#region src/agent-provenance.ts
+const GENERATED_AGENT_PROVENANCE_MARKER = "@farming-labs/docs:generated";
+const GENERATED_AGENT_PROVENANCE_VERSION = 1;
+function normalizeLineEndings(value) {
+	return value.replace(/\r\n?/g, "\n").replace(/^\uFEFF/, "");
+}
+function normalizeGeneratedAgentContent(value) {
+	return normalizeLineEndings(value).trimEnd();
+}
+function hashGeneratedAgentContent(value) {
+	const normalized = normalizeGeneratedAgentContent(value);
+	const bytes = new TextEncoder().encode(normalized);
+	let hash = 14695981039346656037n;
+	for (const byte of bytes) {
+		hash ^= BigInt(byte);
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
+}
+function parseProvenanceBlock(rawBlock) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const line of rawBlock.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const separatorIndex = trimmed.indexOf("=");
+		if (separatorIndex <= 0) continue;
+		const key = trimmed.slice(0, separatorIndex).trim();
+		const value = trimmed.slice(separatorIndex + 1).trim();
+		if (!key || !value) continue;
+		entries.set(key, value);
+	}
+	const version = Number.parseInt(entries.get("version") ?? "", 10);
+	const sourceKind = entries.get("sourceKind");
+	const sourceHash = entries.get("sourceHash");
+	const settingsHash = entries.get("settingsHash");
+	const outputHash = entries.get("outputHash");
+	const generatedAt = entries.get("generatedAt");
+	if (!Number.isFinite(version) || sourceKind !== "resolved-page" && sourceKind !== "agent-md" || !sourceHash || !settingsHash || !outputHash || !generatedAt) return;
+	return {
+		version,
+		sourceKind,
+		sourceHash,
+		settingsHash,
+		outputHash,
+		generatedAt
+	};
+}
+function parseGeneratedAgentDocument(raw) {
+	const normalized = normalizeLineEndings(raw);
+	const headerPattern = new RegExp(`^<!-- ${GENERATED_AGENT_PROVENANCE_MARKER}\\n([\\s\\S]*?)\\n-->\\n?`);
+	const match = normalized.match(headerPattern);
+	if (!match) return { content: normalized };
+	return {
+		provenance: parseProvenanceBlock(match[1]),
+		content: normalized.slice(match[0].length)
+	};
+}
+function stripGeneratedAgentProvenance(raw) {
+	return parseGeneratedAgentDocument(raw).content;
+}
+function serializeGeneratedAgentDocument(content, provenance) {
+	const normalizedContent = normalizeGeneratedAgentContent(content);
+	return `${[
+		`<!-- ${GENERATED_AGENT_PROVENANCE_MARKER}`,
+		`version=${provenance.version}`,
+		`sourceKind=${provenance.sourceKind}`,
+		`sourceHash=${provenance.sourceHash}`,
+		`settingsHash=${provenance.settingsHash}`,
+		`outputHash=${provenance.outputHash}`,
+		`generatedAt=${provenance.generatedAt}`,
+		"-->",
+		normalizedContent
+	].join("\n")}\n`;
+}
+
+//#endregion
+//#region src/markdown-sections.ts
+const HTML_ENTITIES = {
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	nbsp: " ",
+	quot: "\""
+};
+/**
+* Reduce inline Markdown in a heading to the visible label used by search and anchors.
+* This intentionally covers the common inline constructs without adding a Markdown parser
+* dependency to the runtime package.
+*/
+function cleanDocsMarkdownHeadingLabel(value) {
+	return value.replace(/!\[([^\]]*)\]\([^)]*\)/gu, "$1").replace(/\[([^\]]+)\]\([^)]*\)/gu, "$1").replace(/!\[([^\]]*)\]\[[^\]]*\]/gu, "$1").replace(/\[([^\]]+)\]\[[^\]]*\]/gu, "$1").replace(/<((?:https?:\/\/|mailto:)[^>]+)>/giu, "$1").replace(/<[^>]+>/gu, "").replace(/`+([^`]*?)`+/gu, "$1").replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~])/gu, "$1").replace(/[*_~]/gu, "").replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z]+);/giu, (_match, entity) => {
+		if (entity.startsWith("#x") || entity.startsWith("#X")) {
+			const codePoint = Number.parseInt(entity.slice(2), 16);
+			return Number.isSafeInteger(codePoint) && codePoint >= 0 && codePoint <= 1114111 ? String.fromCodePoint(codePoint) : _match;
+		}
+		if (entity.startsWith("#")) {
+			const codePoint = Number.parseInt(entity.slice(1), 10);
+			return Number.isSafeInteger(codePoint) && codePoint >= 0 && codePoint <= 1114111 ? String.fromCodePoint(codePoint) : _match;
+		}
+		return HTML_ENTITIES[entity.toLowerCase()] ?? _match;
+	}).replace(/\s+/gu, " ").trim();
+}
+/** Keep anchors aligned with the framework's existing ASCII heading-slug behavior. */
+function slugifyDocsMarkdownHeading(value) {
+	return cleanDocsMarkdownHeadingLabel(value).toLowerCase().replace(/[`'"‘’“”]/gu, "").replace(/&/gu, " and ").replace(/[^a-z0-9\s-]/gu, "").replace(/\s+/gu, "-").replace(/-+/gu, "-").replace(/^-|-$/gu, "");
+}
+function readOpeningFence(line) {
+	const match = line.match(/^ {0,3}(`{3,}|~{3,})/u);
+	if (!match) return void 0;
+	return {
+		marker: match[1][0],
+		length: match[1].length
+	};
+}
+function isClosingFence(line, fence) {
+	const marker = fence.marker === "`" ? "`" : "~";
+	const match = line.match(new RegExp(`^ {0,3}(${marker}{${fence.length},})[\\t ]*$`, "u"));
+	return Boolean(match);
+}
+function readAtxHeading(line) {
+	const match = line.match(/^ {0,3}(#{1,6})(?:[\t ]+|$)(.*)$/u);
+	if (!match) return void 0;
+	return {
+		title: cleanDocsMarkdownHeadingLabel(match[2].replace(/[\t ]+#+[\t ]*$/u, "").trim()),
+		level: match[1].length
+	};
+}
+function readSetextLevel(line) {
+	const match = line.match(/^ {0,3}(=+|-+)[\t ]*$/u);
+	if (!match) return void 0;
+	return match[1][0] === "=" ? 1 : 2;
+}
+function normalizeDocsSectionSelector(value) {
+	let selector = value.trim();
+	const hashIndex = selector.lastIndexOf("#");
+	if (hashIndex >= 0) selector = selector.slice(hashIndex + 1);
+	try {
+		selector = decodeURIComponent(selector);
+	} catch {}
+	return cleanDocsMarkdownHeadingLabel(selector.replace(/^#+/u, "")).toLowerCase();
+}
+/**
+* Parse heading sections once for search, Ask AI hydration, and MCP tools.
+* Supports CommonMark ATX indentation, Setext headings, fenced-code exclusion,
+* visible inline labels, and stable duplicate anchors.
+*/
+function parseDocsMarkdownSections(markdown) {
+	const lines = markdown.split("\n");
+	const headings = [];
+	const headingCounts = /* @__PURE__ */ new Map();
+	let openFence;
+	let setextCandidate;
+	const pushHeading = (title, level, start) => {
+		const baseAnchor = slugifyDocsMarkdownHeading(title) || `section-${headings.length}`;
+		const seen = headingCounts.get(baseAnchor) ?? 0;
+		headingCounts.set(baseAnchor, seen + 1);
+		headings.push({
+			title,
+			anchor: seen === 0 ? baseAnchor : `${baseAnchor}-${seen}`,
+			level,
+			start
+		});
+	};
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (openFence) {
+			if (isClosingFence(line, openFence)) openFence = void 0;
+			setextCandidate = void 0;
+			continue;
+		}
+		const openingFence = readOpeningFence(line);
+		if (openingFence) {
+			openFence = openingFence;
+			setextCandidate = void 0;
+			continue;
+		}
+		const setextLevel = readSetextLevel(line);
+		if (setextLevel && setextCandidate?.index === index - 1) {
+			const title = cleanDocsMarkdownHeadingLabel(setextCandidate.value.trim());
+			if (title) pushHeading(title, setextLevel, setextCandidate.index);
+			setextCandidate = void 0;
+			continue;
+		}
+		const atxHeading = readAtxHeading(line);
+		if (atxHeading) {
+			pushHeading(atxHeading.title, atxHeading.level, index);
+			setextCandidate = void 0;
+			continue;
+		}
+		if (!line.trim() || /^ {4}|^\t/u.test(line)) {
+			setextCandidate = void 0;
+			continue;
+		}
+		setextCandidate = {
+			index,
+			value: line
+		};
+	}
+	return headings.map((heading, index) => {
+		const end = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level)?.start ?? lines.length;
+		return {
+			title: heading.title,
+			anchor: heading.anchor,
+			level: heading.level,
+			content: lines.slice(heading.start, end).join("\n").trim()
+		};
+	});
+}
+function findDocsMarkdownSection(markdown, requestedSection) {
+	const selector = normalizeDocsSectionSelector(requestedSection);
+	if (!selector) return void 0;
+	return parseDocsMarkdownSections(markdown).find((section) => normalizeDocsSectionSelector(section.title) === selector || section.anchor === selector);
+}
+
+//#endregion
+//#region src/search.ts
+const DEFAULT_SEARCH_LIMIT = 10;
+const MAX_SEARCH_SNIPPET_CHARS = 160;
+const DEFAULT_MCP_PROTOCOL_VERSION = "2025-11-25";
+const MCP_SESSION_CLEANUP_TIMEOUT_MS = 1e3;
+const syncedIndexes = /* @__PURE__ */ new Set();
+const ALGOLIA_MAX_RECORD_BYTES = 9500;
+const DEFAULT_ASK_AI_CONTEXT_CHARS = 24e3;
+const DEFAULT_ASK_AI_RESULT_CHARS = 6e3;
+const SEARCH_STOP_WORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"can",
+	"do",
+	"does",
+	"for",
+	"from",
+	"how",
+	"i",
+	"in",
+	"is",
+	"it",
+	"of",
+	"on",
+	"or",
+	"the",
+	"this",
+	"to",
+	"use",
+	"what",
+	"when",
+	"where",
+	"which",
+	"with"
+]);
+function stripMarkdownText(content) {
+	return removeMdxModuleLinesOutsideFences(content).replace(/```[^\n]*\n([\s\S]*?)```/g, "$1").replace(/```([\s\S]*?)```/g, "$1").replace(/~~~[^\n]*\n([\s\S]*?)~~~/g, "$1").replace(/~~~([\s\S]*?)~~~/g, "$1").replace(/<[^>]+\/>/g, "").replace(/<\/?[A-Z][^>]*>/g, "").replace(/<\/?[a-z][^>]*>/g, "").replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/^\|?[\s:-]+(\|[\s:-]+)+\|?\s*$/gm, "").replace(/\|/g, " ").replace(/^[-*+]\s+/gm, "").replace(/(\*{1,3}|_{1,3})(.*?)\1/g, "$2").replace(/`{3,}[^\n]*$/gm, "").replace(/`([^`]+)`/g, "$1").replace(/`+/g, "").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}\s*$/gm, "").replace(/\n{3,}/g, "\n\n").replace(/\s{2,}/g, " ").trim();
+}
+function stripHtml(text) {
+	return text.replace(/<[^>]+>/g, "");
+}
+function normalizeMcpSsePayload(body) {
+	const payload = body.split("\n").filter((line) => line.startsWith("data: ")).map((line) => line.slice(6).trim()).filter(Boolean).at(-1);
+	return payload ? JSON.parse(payload) : null;
+}
+function normalizeWhitespace(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function normalizeSearchPhrase(value) {
+	return normalizeWhitespace(value.toLowerCase().replace(/[?!.,;:]+$/g, ""));
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function literalMatchPriority(query, value) {
+	const q = normalizeSearchPhrase(query);
+	const text = normalizeSearchPhrase(value ?? "");
+	if (!q || !text) return 0;
+	if (text === q) return 2;
+	const boundary = "[^\\p{L}\\p{N}]";
+	return new RegExp(`(^|${boundary})${escapeRegExp(q)}(?=$|${boundary})`, "u").test(text) ? 1 : 0;
+}
+function isLiteralLookupQuery(query) {
+	const q = normalizeSearchPhrase(query);
+	const words = tokenizeSearchQuery(q);
+	return words.length > 0 && words.length <= 3 && words.join(" ") === q;
+}
+function tokenizeSearchQuery(query) {
+	return Array.from(new Set(query.toLowerCase().replace(/[^\p{L}\p{N}@/_:.-]+/gu, " ").split(/\s+/).map((word) => word.replace(/^[^\p{L}\p{N}@]+|[^\p{L}\p{N}]+$/gu, "")).filter((word) => word.length > 1 && !SEARCH_STOP_WORDS.has(word))));
+}
+function normalizeUrlPathname(value) {
+	try {
+		return new URL(value, "https://docs.local").pathname.replace(/\/+$/, "") || "/";
+	} catch {
+		return value.split(/[?#]/)[0]?.replace(/\/+$/, "") || "/";
+	}
+}
+function safeDecodeUrlSegment(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function getUrlSearchSegments(value) {
+	let pathname = "";
+	try {
+		pathname = new URL(value, "https://docs.local").pathname;
+	} catch {
+		pathname = value.split(/[?#]/)[0] ?? "";
+	}
+	return Array.from(new Set(pathname.split("/").flatMap((segment) => {
+		const decoded = safeDecodeUrlSegment(segment);
+		return [decoded, decoded.replace(/[-_]+/g, " ")];
+	}).map(normalizeSearchPhrase).filter(Boolean)));
+}
+function resolveAskAIContextUrl(value, baseUrl) {
+	if (!baseUrl) return value;
+	try {
+		return new URL(value, baseUrl).toString();
+	} catch {
+		return value;
+	}
+}
+function getAskAIPageContent(page) {
+	return upsertPageAgentContractMarkdown(getPageAudienceRawContent(page, "agent"), page.agent).replace(PAGE_AGENT_CONTRACT_START_MARKER, "").replace(PAGE_AGENT_CONTRACT_END_MARKER, "").replace(/^\r?\n+/, "");
+}
+function getPageAgentContractSearchText(page) {
+	return stripMarkdownText(renderPageAgentContractMarkdown(page.agent).replace(PAGE_AGENT_CONTRACT_START_MARKER, "").replace(PAGE_AGENT_CONTRACT_END_MARKER, ""));
+}
+function removeMdxModuleLinesOutsideFences(content) {
+	let inFence = false;
+	return content.split("\n").filter((line) => {
+		const trimmed = line.trimStart();
+		if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+			inFence = !inFence;
+			return true;
+		}
+		return inFence || !/^(import|export)\s/.test(trimmed);
+	}).join("\n");
+}
+function cleanAskAIContextMarkdown(content) {
+	return removeMdxModuleLinesOutsideFences(content).replace(/<[^>]+\/>/g, "").replace(/<\/?[A-Z][^>]*>/g, "").replace(/<\/?[a-z][^>]*>/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function packageRootFromSpecifier(specifier) {
+	if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("@/") || specifier.startsWith("~/") || specifier.startsWith("#")) return null;
+	const parts = specifier.split("/").filter(Boolean);
+	if (parts.length === 0) return null;
+	if (parts[0]?.startsWith("@")) return parts.length > 1 ? `${parts[0]}/${parts[1]}` : null;
+	return parts[0];
+}
+function cleanPackageToken(token) {
+	const trimmed = token.trim().replace(/^["'`]+|["'`,;]+$/g, "").replace(/\\$/g, "");
+	if (!trimmed || trimmed.startsWith("-") || /^[A-Z_][A-Z0-9_]*=/.test(trimmed)) return null;
+	if (/^(npm|pnpm|yarn|bun|install|add|i|x|dlx|run|exec)$/.test(trimmed)) return null;
+	return packageRootFromSpecifier(trimmed.startsWith("@") ? trimmed.replace(/^(@[^/]+\/[^@]+)@.+$/, "$1") : trimmed.replace(/^([^@]+)@.+$/, "$1"));
+}
+function inferDocsAskAIPackageHints(content) {
+	const packages = /* @__PURE__ */ new Set();
+	const imports = /* @__PURE__ */ new Set();
+	const installCommands = /* @__PURE__ */ new Set();
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const importSpecifier = trimmed.match(/^(?:import|export)\s+(?:type\s+)?[\s\S]*?\s+from\s+["']([^"']+)["']/)?.[1];
+		const bareImportSpecifier = trimmed.match(/^import\s+["']([^"']+)["']/)?.[1];
+		const requireSpecifier = trimmed.match(/require\(["']([^"']+)["']\)/)?.[1];
+		const specifier = importSpecifier ?? bareImportSpecifier ?? requireSpecifier;
+		const packageName = specifier ? packageRootFromSpecifier(specifier) : null;
+		if (packageName) {
+			packages.add(packageName);
+			if (/^(?:import|export)\s/.test(trimmed)) imports.add(trimmed);
+		}
+		const installMatch = trimmed.match(/^(?:npm\s+(?:install|i)|pnpm\s+add|yarn\s+add|bun\s+add)\s+(.+)$/);
+		if (!installMatch) continue;
+		const commandPackages = installMatch[1].split(/\s+/).map(cleanPackageToken).filter((value) => Boolean(value));
+		if (commandPackages.length > 0) {
+			installCommands.add(trimmed);
+			for (const name of commandPackages) packages.add(name);
+		}
+	}
+	return {
+		packages: Array.from(packages).slice(0, 8),
+		imports: Array.from(imports).slice(0, 12),
+		installCommands: Array.from(installCommands).slice(0, 8)
+	};
+}
+function formatDocsAskAIPackageHints(hints, packageName) {
+	const packages = packageName ? Array.from(new Set([packageName, ...hints.packages])) : hints.packages;
+	if (packages.length === 0 && hints.imports.length === 0 && hints.installCommands.length === 0) return;
+	const lines = ["Package and import hints inferred from the retrieved documentation context:"];
+	if (packages.length > 0) lines.push(`- Package names found in install/import examples: ${packages.join(", ")}`);
+	if (hints.imports.length > 0) lines.push(`- Exact import lines found in context: ${hints.imports.map((line) => `\`${line}\``).join("; ")}`);
+	if (hints.installCommands.length > 0) lines.push(`- Exact install commands found in context: ${hints.installCommands.map((line) => `\`${line}\``).join("; ")}`);
+	lines.push("Use these exact package names, install commands, and import lines when relevant. Do not replace them with placeholders.");
+	return lines.join("\n");
+}
+function clampText(value, maxChars) {
+	if (maxChars <= 0) return "";
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars).trimEnd()}...`;
+}
+function findPageForSearchResult(pages, result, baseUrl, strictExternalOrigins = false) {
+	const rawUrl = result.url.trim();
+	const explicitlySchemed = /^[a-z][a-z\d+.-]*:/iu.test(rawUrl);
+	const explicitlyHosted = explicitlySchemed || /^[\\/]{2}/u.test(rawUrl);
+	if (explicitlySchemed && !/^https?:/iu.test(rawUrl)) return void 0;
+	if (explicitlyHosted && !baseUrl && strictExternalOrigins) return void 0;
+	if (explicitlyHosted && baseUrl) try {
+		if (new URL(result.url, baseUrl).origin !== new URL(baseUrl).origin) return void 0;
+	} catch {
+		return;
+	}
+	const resultPath = normalizeUrlPathname(result.url);
+	return pages.find((page) => normalizeUrlPathname(page.url) === resultPath);
+}
+function inferResultTitle(result, page) {
+	if (page) return page.title;
+	return stripHtml(result.content).trim().split("—")[0]?.trim() || result.url;
+}
+function formatAskAIContextResult(options) {
+	const { result, page, maxChars, baseUrl } = options;
+	const title = inferResultTitle(result, page);
+	const section = result.section;
+	const sectionSelector = getSearchResultAnchor(result.url) ?? section;
+	const contextContent = clampText(cleanAskAIContextMarkdown(page ? sectionSelector ? findDocsMarkdownSection(getAskAIPageContent(page), sectionSelector)?.content ?? "" : getAskAIPageContent(page) : [result.content, result.description].filter(Boolean).join("\n\n")), maxChars);
+	return {
+		...result,
+		url: resolveAskAIContextUrl(result.url, baseUrl),
+		title,
+		contextContent
+	};
+}
+function getSearchResultKey(result) {
+	let hash = "";
+	try {
+		hash = new URL(result.url, "https://docs.local").hash.replace(/^#/, "");
+	} catch {
+		hash = result.url.split("#")[1]?.split(/[?&]/)[0] ?? "";
+	}
+	return `${normalizeUrlPathname(result.url)}#${normalizeWhitespace(hash || result.section || "").toLowerCase()}`;
+}
+function getSearchResultAnchor(value) {
+	let hash = "";
+	try {
+		hash = new URL(value, "https://docs.local").hash.replace(/^#/, "");
+	} catch {
+		hash = value.split("#")[1]?.split(/[?&]/)[0] ?? "";
+	}
+	if (!hash) return void 0;
+	try {
+		return decodeURIComponent(hash);
+	} catch {
+		return hash;
+	}
+}
+function getAskAIResultPageKey(value, baseUrl, strictExternalOrigins = false) {
+	const path = normalizeUrlPathname(value);
+	const rawValue = value.trim();
+	if (!(/^[a-z][a-z\d+.-]*:/iu.test(rawValue) || /^[\\/]{2}/u.test(rawValue)) || !baseUrl && !strictExternalOrigins) return path;
+	try {
+		const fallbackBase = baseUrl ?? "https://docs.local";
+		const parsed = new URL(value, fallbackBase);
+		const configuredBase = baseUrl ? new URL(baseUrl) : void 0;
+		if (configuredBase && parsed.origin === configuredBase.origin) return path;
+		return `${parsed.protocol}//${parsed.host}${path}`;
+	} catch {
+		return `${value.split("#", 1)[0]}::${path}`;
+	}
+}
+function getAskAIResultKey(result, baseUrl, strictExternalOrigins = false) {
+	return `${getAskAIResultPageKey(result.url, baseUrl, strictExternalOrigins)}#${normalizeWhitespace(getSearchResultAnchor(result.url) || result.section || "").toLowerCase()}`;
+}
+function mergeSearchResults(groups, getResultKey = getSearchResultKey) {
+	const seen = /* @__PURE__ */ new Set();
+	const results = [];
+	for (const group of groups) for (const result of group) {
+		const key = getResultKey(result);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		results.push(result);
+	}
+	return results;
+}
+function buildAudienceProjectionSearchResults(documents, query) {
+	return documents.map((document) => {
+		const score = scoreDocument(query, document);
+		return {
+			id: document.id,
+			url: document.url,
+			content: document.section ? `${document.title} — ${document.section}` : document.title,
+			description: cleanSearchResultText(buildSnippet(document, query) ?? document.description),
+			type: document.type,
+			score,
+			section: document.section
+		};
+	});
+}
+function sanitizeExternalAudienceSearchResults(results, localAudienceResults, baseUrl, strictExternalOrigins = false, preserveUnmatched) {
+	const localByKey = new Map(localAudienceResults.map((result) => [getSearchResultKey(result), result]));
+	const localPageResults = /* @__PURE__ */ new Map();
+	for (const result of localAudienceResults) {
+		const pageUrl = normalizeUrlPathname(result.url);
+		if (!localPageResults.get(pageUrl) || result.type === "page") localPageResults.set(pageUrl, result);
+	}
+	return results.flatMap((result) => {
+		const rawUrl = result.url.trim();
+		const explicitlySchemed = /^[a-z][a-z\d+.-]*:/iu.test(rawUrl);
+		const externallyHosted = explicitlySchemed && /^https?:/iu.test(rawUrl) || /^[\\/]{2}/u.test(rawUrl);
+		const unsupportedScheme = explicitlySchemed && !/^https?:/iu.test(rawUrl);
+		let sameOriginOrUnknown = !externallyHosted || !baseUrl && !strictExternalOrigins;
+		if (unsupportedScheme) sameOriginOrUnknown = false;
+		if (externallyHosted && baseUrl) try {
+			sameOriginOrUnknown = new URL(result.url, baseUrl).origin === new URL(baseUrl).origin;
+		} catch {
+			sameOriginOrUnknown = false;
+		}
+		const hasSection = Boolean(getSearchResultAnchor(result.url) || result.section);
+		const local = sameOriginOrUnknown ? localByKey.get(getSearchResultKey(result)) ?? (hasSection ? void 0 : localPageResults.get(normalizeUrlPathname(result.url))) : void 0;
+		if (!local) return preserveUnmatched?.(result) ? [result] : [];
+		return [{
+			...local,
+			id: result.id,
+			score: result.score ?? local.score
+		}];
+	});
+}
+function shouldPreserveUnmatchedExternalResult(options) {
+	const { result, localPagePaths, baseUrl } = options;
+	const path = normalizeUrlPathname(result.url);
+	const rawUrl = result.url.trim();
+	const explicitScheme = rawUrl.match(/^([a-z][a-z\d+.-]*):/iu)?.[1]?.toLowerCase();
+	if (explicitScheme && explicitScheme !== "http" && explicitScheme !== "https") return false;
+	const explicitlyHosted = /^[a-z][a-z\d+.-]*:/iu.test(rawUrl) || /^[\\/]{2}/u.test(rawUrl);
+	const knownLocalPath = localPagePaths.has(path);
+	if (!explicitlyHosted) return !knownLocalPath;
+	if (!baseUrl) return !knownLocalPath;
+	try {
+		if (new URL(result.url, baseUrl).origin !== new URL(baseUrl).origin) return true;
+	} catch {
+		return false;
+	}
+	return !knownLocalPath;
+}
+function getPageAudienceRawContent(page, audience) {
+	return resolveDocsAudienceMdxContent(audience === "agent" ? page.agentRawContent ?? page.agentFallbackRawContent ?? page.agentContent ?? page.agentFallbackContent ?? page.rawContent ?? page.content : page.rawContent ?? page.content, audience);
+}
+function getPageAudienceSearchText(page, audience) {
+	return stripMarkdownText(getPageAudienceRawContent(page, audience));
+}
+function isLocalProviderResult(result, baseUrl, strictExternalOrigins = false) {
+	const rawUrl = result.url.trim();
+	const explicitScheme = rawUrl.match(/^([a-z][a-z\d+.-]*):/iu)?.[1]?.toLowerCase();
+	if (explicitScheme && explicitScheme !== "http" && explicitScheme !== "https") return false;
+	if (!(/^[a-z][a-z\d+.-]*:/iu.test(rawUrl) || /^[\\/]{2}/u.test(rawUrl))) return true;
+	if (!baseUrl) return !strictExternalOrigins;
+	try {
+		return new URL(result.url, baseUrl).origin === new URL(baseUrl).origin;
+	} catch {
+		return false;
+	}
+}
+function hasOppositeAudienceEvidence(options) {
+	const { result, pages, query, audience, baseUrl, strictExternalOrigins } = options;
+	if (!isLocalProviderResult(result, baseUrl, strictExternalOrigins)) return false;
+	const pagePath = normalizeUrlPathname(result.url);
+	const page = pages.find((candidate) => normalizeUrlPathname(candidate.url) === pagePath);
+	if (!page) return false;
+	if (scoreDocument(query, pageToSearchDocument(page, audience)) > 0) return false;
+	const oppositeAudience = audience === "agent" ? "human" : "agent";
+	if (scoreDocument(query, pageToSearchDocument(page, oppositeAudience)) > 0) return true;
+	const evidence = cleanSearchResultText(result.description);
+	if (!evidence) return false;
+	const selectedTokens = new Set(tokenizeSearchQuery(getPageAudienceSearchText(page, audience)));
+	const oppositeTokens = new Set(tokenizeSearchQuery(getPageAudienceSearchText(page, oppositeAudience)));
+	const evidenceTokens = [...new Set(tokenizeSearchQuery(evidence))];
+	let selectedOnlyMatches = 0;
+	let oppositeOnlyMatches = 0;
+	for (const token of evidenceTokens) {
+		const inSelected = selectedTokens.has(token);
+		const inOpposite = oppositeTokens.has(token);
+		if (inSelected && !inOpposite) selectedOnlyMatches += 1;
+		if (inOpposite && !inSelected) oppositeOnlyMatches += 1;
+	}
+	return oppositeOnlyMatches > selectedOnlyMatches;
+}
+function pageToSearchDocument(page, audience = "human") {
+	return {
+		id: makeDocumentId(page.url, "page"),
+		url: page.url,
+		title: page.title,
+		content: normalizeWhitespace([getPageAudienceSearchText(page, audience), getPageAgentContractSearchText(page)].join(" ")),
+		description: page.description,
+		type: "page",
+		locale: page.locale,
+		framework: page.framework,
+		version: page.version,
+		tags: page.tags
+	};
+}
+function buildExactPageSearchResults(query, pages, audience = "human") {
+	const normalizedQuery = normalizeSearchPhrase(query);
+	if (!normalizedQuery) return [];
+	const results = [];
+	for (const page of pages) {
+		const document = pageToSearchDocument(page, audience);
+		const title = normalizeSearchPhrase(page.title);
+		const urlSegments = getUrlSearchSegments(page.url);
+		if (!(title === normalizedQuery || urlSegments.includes(normalizedQuery))) continue;
+		results.push({
+			id: document.id,
+			url: document.url,
+			content: cleanSearchResultText(document.title) ?? document.title,
+			description: cleanSearchResultText(buildSnippet(document, query) ?? document.description),
+			type: "page",
+			score: scoreDocument(query, document) + 2e3
+		});
+	}
+	return results.sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || a.url.localeCompare(b.url));
+}
+function hasDistinctResultSection(result) {
+	if (result.type === "page") return false;
+	const section = normalizeSearchPhrase(stripHtml(result.section ?? ""));
+	if (!section) return true;
+	return section !== normalizeSearchPhrase(normalizeSearchPhrase(stripHtml(result.content)).split(/\s+[—–]\s+/)[0] ?? "");
+}
+function insideLiteralResultPriority(query, result) {
+	if (!hasDistinctResultSection(result) || !isLiteralLookupQuery(query)) return 0;
+	return Math.max(literalMatchPriority(query, stripHtml(result.section ?? "")), literalMatchPriority(query, stripHtml(result.description ?? "")));
+}
+function prioritizeLiteralInsideResults(query, results) {
+	if (!isLiteralLookupQuery(query)) return results;
+	return [...results].sort((a, b) => {
+		const literalDelta = insideLiteralResultPriority(query, b) - insideLiteralResultPriority(query, a);
+		if (literalDelta) return literalDelta;
+		return 0;
+	});
+}
+function rankAskAIContextResult(query, result) {
+	return scoreDocument(query, {
+		id: result.id,
+		url: result.url,
+		title: result.title,
+		content: result.contextContent,
+		description: result.description,
+		type: result.type,
+		section: result.section
+	});
+}
+function buildAskAIContextBlock(result) {
+	const lines = [`## ${result.title}`, `URL: ${result.url}`];
+	if (result.section) lines.push(`Section: ${result.section}`);
+	if (result.description) lines.push(`Search snippet: ${result.description}`);
+	lines.push("", result.contextContent);
+	return lines.join("\n").trim();
+}
+function makeDocumentId(url, suffix) {
+	return `${url}#${suffix}`;
+}
+function splitPageIntoSections(page, audience = "human") {
+	return parseDocsMarkdownSections(getPageAudienceRawContent(page, audience)).flatMap((section, index) => {
+		const content = normalizeWhitespace(stripMarkdownText(section.content));
+		if (!content) return [];
+		return [{
+			id: makeDocumentId(page.url, `section-${index}`),
+			url: `${page.url}#${section.anchor}`,
+			title: page.title,
+			section: section.title,
+			content,
+			description: page.description,
+			type: "heading",
+			locale: page.locale,
+			framework: page.framework,
+			version: page.version,
+			tags: page.tags
+		}];
+	});
+}
+function buildDocsSearchDocuments(pages, chunking = {}, audience = "human") {
+	const strategy = chunking.strategy ?? "section";
+	return pages.flatMap((page) => {
+		const base = pageToSearchDocument(page, audience);
+		if (strategy === "page") return [base];
+		const sections = splitPageIntoSections(page, audience);
+		if (sections.length === 0) return [base];
+		return [...base.content ? [base] : [], ...sections];
+	});
+}
+function scoreDocument(query, document) {
+	const q = normalizeSearchPhrase(query);
+	if (!q) return 0;
+	const words = tokenizeSearchQuery(q);
+	const title = normalizeSearchPhrase(document.title);
+	const section = document.section ? normalizeSearchPhrase(document.section) : "";
+	const hasDistinctSection = Boolean(section && section !== title);
+	const titleSection = section ? normalizeSearchPhrase(`${document.title} ${document.section}`) : "";
+	const description = document.description ? normalizeSearchPhrase(document.description) : "";
+	const content = normalizeSearchPhrase(document.content);
+	const url = normalizeSearchPhrase(document.url);
+	const urlSegments = getUrlSearchSegments(document.url);
+	const titleTokens = tokenizeSearchQuery(title);
+	const sectionTokens = tokenizeSearchQuery(section);
+	let score = 0;
+	const insideLiteralPriority = document.type !== "page" && hasDistinctSection && isLiteralLookupQuery(q) ? Math.max(literalMatchPriority(q, section), literalMatchPriority(q, description), literalMatchPriority(q, content)) : 0;
+	if (insideLiteralPriority > 0) score += insideLiteralPriority * 2250;
+	if (title === q) score += 1120;
+	else if (title.startsWith(q)) score += 70;
+	else if (title.includes(q)) score += 45;
+	if (hasDistinctSection) {
+		if (section === q) score += 1080;
+		else if (section.startsWith(q)) score += 55;
+		else if (section.includes(q)) score += 30;
+		if (titleSection === q) score += 1e3;
+		else if (titleSection.startsWith(q)) score += 50;
+		else if (titleSection.includes(q)) score += 28;
+	}
+	if (urlSegments.includes(q)) score += 950;
+	if (url.includes(q)) score += 12;
+	if (description.includes(q)) score += 18;
+	if (content.includes(q)) score += 12;
+	let matchedWords = 0;
+	for (const word of words) {
+		let matched = false;
+		if (title === word) {
+			score += 28;
+			matched = true;
+		} else if (title.startsWith(word)) {
+			score += 20;
+			matched = true;
+		} else if (title.includes(word)) {
+			score += 12;
+			matched = true;
+		}
+		if (hasDistinctSection) {
+			if (section === word) {
+				score += 22;
+				matched = true;
+			} else if (section.startsWith(word)) {
+				score += 16;
+				matched = true;
+			} else if (section.includes(word)) {
+				score += 10;
+				matched = true;
+			}
+		}
+		if (description.includes(word)) {
+			score += 6;
+			matched = true;
+		}
+		if (content.includes(word)) {
+			score += 4;
+			matched = true;
+		}
+		if (matched) matchedWords += 1;
+	}
+	if (words.length > 1) {
+		if (hasDistinctSection && sectionTokens.length > 0 && words.every((word) => sectionTokens.includes(word))) score += 30;
+		if (document.type === "page" && titleTokens.length > 0 && words.every((word) => titleTokens.includes(word))) score += 24;
+	}
+	if (matchedWords === words.length && words.length > 1) score += 20;
+	if (score > 0 && document.type === "heading" && hasDistinctSection) score += 6;
+	return score;
+}
+function buildSnippet(document, query) {
+	const q = query.trim().toLowerCase();
+	const sources = [normalizeWhitespace(stripMarkdownText(document.content)), normalizeWhitespace(stripMarkdownText(document.description ?? ""))].filter(Boolean);
+	for (const source of sources) {
+		if (!q) return clampSearchSnippet(source);
+		const idx = source.toLowerCase().indexOf(q);
+		if (idx === -1) continue;
+		const start = Math.max(0, idx - 48);
+		const end = Math.min(source.length, idx + q.length + 96);
+		const prefix = start > 0 ? "..." : "";
+		const suffix = end < source.length ? "..." : "";
+		return clampSearchSnippet(`${prefix}${source.slice(start, end).trim()}${suffix}`);
+	}
+	return sources[0] ? clampSearchSnippet(sources[0]) : void 0;
+}
+function clampSearchSnippet(value) {
+	if (value.length <= MAX_SEARCH_SNIPPET_CHARS) return value;
+	return `${value.slice(0, MAX_SEARCH_SNIPPET_CHARS - 3).trimEnd()}...`;
+}
+function cleanSearchResultText(value) {
+	if (!value) return void 0;
+	return normalizeWhitespace(stripHtml(stripMarkdownText(value))) || void 0;
+}
+function trimTextToBytes(value, maxBytes) {
+	if (maxBytes <= 0) return "";
+	const encoder = new TextEncoder();
+	if (encoder.encode(value).length <= maxBytes) return value;
+	let low = 0;
+	let high = value.length;
+	let best = "";
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const next = `${value.slice(0, mid).trimEnd()}...`;
+		if (encoder.encode(next).length <= maxBytes) {
+			best = next;
+			low = mid + 1;
+		} else high = mid - 1;
+	}
+	return best;
+}
+function buildAlgoliaRecord(document) {
+	const record = {
+		objectID: document.id,
+		id: document.id,
+		url: document.url,
+		title: document.title,
+		section: document.section,
+		content: document.content,
+		description: document.description,
+		type: document.type
+	};
+	const encoder = new TextEncoder();
+	const sizeOf = (value) => encoder.encode(JSON.stringify(value)).length;
+	if (sizeOf(record) <= ALGOLIA_MAX_RECORD_BYTES) return record;
+	delete record.description;
+	if (sizeOf(record) <= ALGOLIA_MAX_RECORD_BYTES) return record;
+	const fixedBytes = sizeOf({
+		...record,
+		content: ""
+	});
+	const remainingBytes = Math.max(ALGOLIA_MAX_RECORD_BYTES - fixedBytes - 32, 0);
+	record.content = trimTextToBytes(document.content, remainingBytes);
+	return record;
+}
+function createSimpleSearchAdapter() {
+	return {
+		name: "simple",
+		async search(query, context) {
+			const limit = query.limit ?? DEFAULT_SEARCH_LIMIT;
+			return context.documents.map((document) => ({
+				document,
+				score: scoreDocument(query.query, document)
+			})).filter((item) => item.score > 0).sort((a, b) => {
+				if (b.score !== a.score) return b.score - a.score;
+				return a.document.url.localeCompare(b.document.url);
+			}).slice(0, limit).map(({ document, score }) => ({
+				id: document.id,
+				url: document.url,
+				content: cleanSearchResultText(document.section ? `${document.title} — ${document.section}` : document.title) ?? (document.section ? `${document.title} — ${document.section}` : document.title),
+				description: cleanSearchResultText(buildSnippet(document, query.query) ?? document.description),
+				type: document.type,
+				score,
+				section: document.section
+			}));
+		}
+	};
+}
+function normalizeDocsSearchConfig(search) {
+	if (search === false) return {
+		enabled: false,
+		provider: "simple",
+		maxResults: DEFAULT_SEARCH_LIMIT,
+		chunking: { strategy: "section" }
+	};
+	if (!search || search === true) return {
+		enabled: true,
+		provider: "simple",
+		maxResults: DEFAULT_SEARCH_LIMIT,
+		chunking: { strategy: "section" },
+		raw: typeof search === "object" ? search : void 0
+	};
+	const provider = search.provider ?? "simple";
+	const maxResults = search.maxResults ?? DEFAULT_SEARCH_LIMIT;
+	const chunking = search.chunking ?? { strategy: "section" };
+	return {
+		enabled: search.enabled ?? true,
+		provider,
+		maxResults,
+		chunking,
+		raw: search
+	};
+}
+async function readResponseJson(response) {
+	const text = await response.text();
+	return text ? JSON.parse(text) : null;
+}
+async function readMcpResponsePayload(response) {
+	const text = await response.text();
+	if (!text) return null;
+	if ((response.headers.get("content-type") ?? "").includes("application/json")) return JSON.parse(text);
+	return normalizeMcpSsePayload(text);
+}
+function ensureOk(response, message) {
+	if (response.ok) return;
+	throw new Error(`${message} (${response.status} ${response.statusText})`);
+}
+function ensureJsonRpcOk(payload, message) {
+	if (payload && typeof payload === "object" && "error" in payload && payload.error && typeof payload.error === "object" && "message" in payload.error) throw new Error(`${message}: ${String(payload.error.message)}`);
+}
+function resolveMcpEndpoint(endpoint) {
+	if (/^https?:\/\//i.test(endpoint)) return endpoint;
+	throw new Error("Relative MCP search endpoints must be resolved before creating the MCP adapter.");
+}
+function isDocsSearchResultType(value) {
+	return value === "page" || value === "heading" || value === "text";
+}
+function mapMcpSearchResult(value) {
+	if (!value || typeof value !== "object") return null;
+	const item = value;
+	const section = typeof item.section === "string" ? item.section : void 0;
+	const title = typeof item.title === "string" ? item.title : void 0;
+	const content = typeof item.content === "string" ? item.content : title ? section ? `${title} — ${section}` : title : void 0;
+	const url = typeof item.url === "string" ? item.url : void 0;
+	if (!content || !url) return null;
+	return {
+		id: typeof item.id === "string" ? item.id : typeof item.slug === "string" ? item.slug : url,
+		url,
+		content: cleanSearchResultText(content) ?? content,
+		description: cleanSearchResultText(typeof item.description === "string" ? item.description : typeof item.excerpt === "string" ? item.excerpt : void 0) ?? void 0,
+		type: isDocsSearchResultType(item.type) ? item.type : section ? "heading" : "page",
+		score: typeof item.score === "number" ? item.score : void 0,
+		section
+	};
+}
+async function createOllamaEmbedding(text, config, signal) {
+	const response = await fetch(`${(config.baseUrl ?? "http://127.0.0.1:11434").replace(/\/$/, "")}/api/embed`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			model: config.model,
+			input: text
+		}),
+		signal
+	});
+	ensureOk(response, "Failed to create Ollama embedding");
+	const payload = await readResponseJson(response);
+	if (Array.isArray(payload.embeddings?.[0])) return payload.embeddings[0];
+	if (Array.isArray(payload.embedding)) return payload.embedding;
+	throw new Error("Ollama embedding response did not include an embedding vector.");
+}
+function getTypesenseSearchBase(config) {
+	return config.baseUrl.replace(/\/$/, "");
+}
+async function ensureTypesenseCollection(config, dimensions, signal) {
+	const baseUrl = getTypesenseSearchBase(config);
+	const headers = {
+		"X-TYPESENSE-API-KEY": config.adminApiKey ?? config.apiKey,
+		"Content-Type": "application/json"
+	};
+	const existing = await fetch(`${baseUrl}/collections/${encodeURIComponent(config.collection)}`, {
+		headers,
+		signal
+	});
+	if (existing.ok) return;
+	if (existing.status !== 404) ensureOk(existing, "Failed to inspect Typesense collection");
+	const fields = [
+		{
+			name: "id",
+			type: "string"
+		},
+		{
+			name: "url",
+			type: "string"
+		},
+		{
+			name: "title",
+			type: "string"
+		},
+		{
+			name: "section",
+			type: "string",
+			optional: true
+		},
+		{
+			name: "content",
+			type: "string"
+		},
+		{
+			name: "description",
+			type: "string",
+			optional: true
+		},
+		{
+			name: "type",
+			type: "string"
+		},
+		{
+			name: "locale",
+			type: "string",
+			optional: true
+		},
+		{
+			name: "framework",
+			type: "string",
+			optional: true
+		},
+		{
+			name: "version",
+			type: "string",
+			optional: true
+		},
+		{
+			name: "tags",
+			type: "string[]",
+			optional: true
+		}
+	];
+	if (config.embeddings && dimensions) fields.push({
+		name: "embedding",
+		type: "float[]",
+		num_dim: dimensions,
+		optional: true
+	});
+	ensureOk(await fetch(`${baseUrl}/collections`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			name: config.collection,
+			fields
+		}),
+		signal
+	}), "Failed to create Typesense collection");
+}
+function createTypesenseSearchAdapter(config) {
+	return {
+		name: "typesense",
+		async index(context) {
+			const adminApiKey = config.adminApiKey ?? config.apiKey;
+			const docsForImport = await Promise.all(context.documents.map(async (document) => {
+				const next = {
+					id: document.id,
+					url: document.url,
+					title: document.title,
+					section: document.section,
+					content: document.content,
+					description: document.description,
+					type: document.type,
+					locale: document.locale,
+					framework: document.framework,
+					version: document.version,
+					tags: document.tags
+				};
+				if (config.mode === "hybrid" && config.embeddings) next.embedding = await createOllamaEmbedding(`${document.title}\n${document.section ?? ""}\n${document.content}`.trim(), config.embeddings, context.signal);
+				return next;
+			}));
+			if (docsForImport.length === 0) return;
+			await ensureTypesenseCollection(config, Array.isArray(docsForImport[0]?.embedding) ? docsForImport[0].embedding.length : void 0, context.signal);
+			ensureOk(await fetch(`${getTypesenseSearchBase(config)}/collections/${encodeURIComponent(config.collection)}/documents/import?action=upsert`, {
+				method: "POST",
+				headers: {
+					"X-TYPESENSE-API-KEY": adminApiKey,
+					"Content-Type": "text/plain"
+				},
+				body: docsForImport.map((document) => JSON.stringify(document)).join("\n"),
+				signal: context.signal
+			}), "Failed to sync documents to Typesense");
+		},
+		async search(query, context) {
+			const params = new URLSearchParams({
+				q: query.query,
+				query_by: (config.queryBy ?? [
+					"title",
+					"section",
+					"content",
+					"description"
+				]).join(","),
+				per_page: String(query.limit ?? config.maxResults ?? DEFAULT_SEARCH_LIMIT),
+				prioritize_exact_match: "true",
+				num_typos: "2",
+				highlight_fields: "content,title,section,description"
+			});
+			if (config.mode === "hybrid" && config.embeddings) {
+				const vector = await createOllamaEmbedding(query.query, config.embeddings, context.signal);
+				params.set("vector_query", `embedding:([${vector.join(",")}],k:${Math.max((query.limit ?? 10) * 4, 20)})`);
+			}
+			const response = await fetch(`${getTypesenseSearchBase(config)}/collections/${encodeURIComponent(config.collection)}/documents/search?${params.toString()}`, {
+				headers: { "X-TYPESENSE-API-KEY": config.apiKey },
+				signal: context.signal
+			});
+			ensureOk(response, "Typesense search failed");
+			return ((await readResponseJson(response)).hits ?? []).map((hit) => {
+				const document = hit.document ?? {};
+				const section = typeof document.section === "string" ? document.section : void 0;
+				const content = typeof document.title === "string" ? section ? `${document.title} — ${section}` : document.title : typeof document.content === "string" ? document.content : "Untitled result";
+				const description = hit.highlights?.find((item) => item.field === "content")?.snippet ?? hit.highlights?.find((item) => item.field === "description")?.snippet ?? (typeof document.description === "string" ? document.description : void 0);
+				return {
+					id: typeof document.id === "string" ? document.id : String(document.url ?? content),
+					url: typeof document.url === "string" ? document.url : "/docs",
+					content: cleanSearchResultText(content) ?? content,
+					description: cleanSearchResultText(description),
+					type: typeof document.type === "string" && [
+						"page",
+						"heading",
+						"text"
+					].includes(document.type) ? document.type : section ? "heading" : "page",
+					score: hit.text_match,
+					section
+				};
+			});
+		}
+	};
+}
+function resolveSearchRequestConfig(search, requestUrl) {
+	if (!search || search === true || typeof search !== "object" || search.provider !== "mcp") return search;
+	if (!requestUrl) return search;
+	const resolvedEndpoint = new URL(search.endpoint, requestUrl);
+	const usesDefaultSearchTool = (search.toolName ?? "search_docs") === "search_docs";
+	const isSameOrigin = resolvedEndpoint.origin === new URL(requestUrl).origin;
+	return {
+		...search,
+		endpoint: resolvedEndpoint.toString(),
+		forwardAudience: search.forwardAudience ?? (usesDefaultSearchTool && isSameOrigin)
+	};
+}
+/**
+* Resolve the public search audience without allowing malformed values to opt into agent content.
+* Human search remains the default for omitted, legacy, and unknown query values.
+*/
+function resolveDocsSearchAudience(value) {
+	return value === "agent" ? "agent" : "human";
+}
+function resolveAskAISearchRequestConfig(options) {
+	if (!options.useMcp) return resolveSearchRequestConfig(options.search, options.requestUrl);
+	if (typeof options.useMcp === "object") return resolveSearchRequestConfig({
+		...options.useMcp,
+		provider: "mcp"
+	}, options.requestUrl);
+	if (options.mcpEnabled === false || options.mcpSearchEnabled === false || !options.mcpEndpoint) return resolveSearchRequestConfig(options.search, options.requestUrl);
+	return resolveSearchRequestConfig({
+		provider: "mcp",
+		endpoint: options.mcpEndpoint
+	}, options.requestUrl);
+}
+function createMcpSearchAdapter(config) {
+	return {
+		name: "mcp",
+		async search(query, context) {
+			const endpoint = resolveMcpEndpoint(config.endpoint);
+			const protocolVersion = config.protocolVersion ?? DEFAULT_MCP_PROTOCOL_VERSION;
+			const toolName = config.toolName ?? "search_docs";
+			const forwardAudience = config.forwardAudience === true;
+			const audience = resolveDocsSearchAudience(query.audience);
+			const baseHeaders = config.headers ?? {};
+			if (audience === "human" && !forwardAudience) throw new Error("MCP human-projection search requires forwardAudience: true on an audience-aware tool.");
+			const initializeResponse = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					...baseHeaders,
+					"Content-Type": "application/json",
+					accept: "application/json, text/event-stream",
+					"mcp-protocol-version": protocolVersion
+				},
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 1,
+					method: "initialize",
+					params: {
+						protocolVersion,
+						capabilities: {},
+						clientInfo: {
+							name: "@farming-labs/docs-search",
+							version: "0.1.2"
+						}
+					}
+				}),
+				signal: context.signal
+			});
+			const initializePayload = await readMcpResponsePayload(initializeResponse);
+			ensureOk(initializeResponse, "MCP search initialization failed");
+			ensureJsonRpcOk(initializePayload, "MCP search initialization failed");
+			const sessionId = initializeResponse.headers.get("mcp-session-id") ?? void 0;
+			try {
+				const searchResponse = await fetch(endpoint, {
+					method: "POST",
+					headers: {
+						...baseHeaders,
+						"Content-Type": "application/json",
+						accept: "application/json, text/event-stream",
+						"mcp-protocol-version": protocolVersion,
+						...sessionId ? { "mcp-session-id": sessionId } : {}
+					},
+					body: JSON.stringify({
+						jsonrpc: "2.0",
+						id: 2,
+						method: "tools/call",
+						params: {
+							name: toolName,
+							arguments: {
+								query: query.query,
+								limit: query.limit ?? config.maxResults ?? DEFAULT_SEARCH_LIMIT,
+								locale: query.locale,
+								...forwardAudience ? { audience } : {}
+							}
+						}
+					}),
+					signal: context.signal
+				});
+				const payload = await readMcpResponsePayload(searchResponse);
+				ensureOk(searchResponse, "MCP search request failed");
+				ensureJsonRpcOk(payload, "MCP search request failed");
+				const resultText = payload && typeof payload === "object" && "result" in payload && payload.result && typeof payload.result === "object" && "content" in payload.result && Array.isArray(payload.result.content) && typeof payload.result.content[0]?.text === "string" ? payload.result.content[0].text : null;
+				if (!resultText) return [];
+				const parsed = JSON.parse(resultText);
+				return (Array.isArray(parsed) ? parsed : Array.isArray(parsed.results) ? parsed.results : Array.isArray(parsed.pages) ? parsed.pages : []).map(mapMcpSearchResult).filter((result) => Boolean(result));
+			} finally {
+				if (sessionId) {
+					const cleanupController = new AbortController();
+					const cleanupTimeout = setTimeout(() => cleanupController.abort(), MCP_SESSION_CLEANUP_TIMEOUT_MS);
+					try {
+						await fetch(endpoint, {
+							method: "DELETE",
+							headers: {
+								...baseHeaders,
+								"mcp-protocol-version": protocolVersion,
+								"mcp-session-id": sessionId
+							},
+							signal: cleanupController.signal
+						});
+					} catch {} finally {
+						clearTimeout(cleanupTimeout);
+					}
+				}
+			}
+		}
+	};
+}
+function getAlgoliaBase(config) {
+	return `https://${config.appId}-dsn.algolia.net`;
+}
+function createAlgoliaSearchAdapter(config) {
+	return {
+		name: "algolia",
+		async index(context) {
+			if (!config.adminApiKey) return;
+			ensureOk(await fetch(`${getAlgoliaBase(config)}/1/indexes/${encodeURIComponent(config.indexName)}/batch`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-Algolia-Application-Id": config.appId,
+					"X-Algolia-API-Key": config.adminApiKey
+				},
+				body: JSON.stringify({ requests: context.documents.map((document) => ({
+					action: "addObject",
+					body: buildAlgoliaRecord(document)
+				})) }),
+				signal: context.signal
+			}), "Failed to sync documents to Algolia");
+		},
+		async search(query, context) {
+			const response = await fetch(`${getAlgoliaBase(config)}/1/indexes/${encodeURIComponent(config.indexName)}/query`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-Algolia-Application-Id": config.appId,
+					"X-Algolia-API-Key": config.searchApiKey
+				},
+				body: JSON.stringify({
+					query: query.query,
+					hitsPerPage: query.limit ?? config.maxResults ?? DEFAULT_SEARCH_LIMIT,
+					attributesToSnippet: ["content:20"]
+				}),
+				signal: context.signal
+			});
+			ensureOk(response, "Algolia search failed");
+			return ((await readResponseJson(response)).hits ?? []).map((hit) => {
+				const title = typeof hit.title === "string" ? hit.title : "Untitled result";
+				const section = typeof hit.section === "string" ? hit.section : void 0;
+				return {
+					id: hit.objectID ?? String(hit.url ?? title),
+					url: typeof hit.url === "string" ? hit.url : "/docs",
+					content: cleanSearchResultText(section ? `${title} — ${section}` : title) ?? title,
+					description: cleanSearchResultText(hit._snippetResult?.content?.value ?? hit._snippetResult?.description?.value ?? (typeof hit.description === "string" ? hit.description : void 0)),
+					type: typeof hit.type === "string" && [
+						"page",
+						"heading",
+						"text"
+					].includes(hit.type) ? hit.type : section ? "heading" : "page",
+					score: hit._rankingInfo?.nbTypos != null ? 100 - hit._rankingInfo.nbTypos : void 0,
+					section
+				};
+			});
+		}
+	};
+}
+async function resolveSearchAdapter(search, context) {
+	const raw = search.raw;
+	if (search.provider === "custom" && raw?.provider === "custom") return typeof raw.adapter === "function" ? await raw.adapter(context) : raw.adapter;
+	if (search.provider === "typesense" && raw?.provider === "typesense") return createTypesenseSearchAdapter(raw);
+	if (search.provider === "mcp" && raw?.provider === "mcp") return createMcpSearchAdapter(raw);
+	if (search.provider === "algolia" && raw?.provider === "algolia") return createAlgoliaSearchAdapter(raw);
+	return createSimpleSearchAdapter();
+}
+function shouldSyncOnSearch(search) {
+	const raw = search.raw;
+	if (search.provider === "algolia" && raw?.provider === "algolia") return (raw.syncOnSearch ?? Boolean(raw.adminApiKey)) && Boolean(raw.adminApiKey);
+	if (search.provider === "typesense" && raw?.provider === "typesense") return (raw.syncOnSearch ?? Boolean(raw.adminApiKey)) && Boolean(raw.adminApiKey);
+	return false;
+}
+function getSyncKey(search, context) {
+	const raw = search.raw;
+	if (search.provider === "algolia" && raw?.provider === "algolia") return `algolia:${raw.appId}:${raw.indexName}:${context.locale ?? "__default__"}`;
+	if (search.provider === "typesense" && raw?.provider === "typesense") return `typesense:${raw.baseUrl}:${raw.collection}:${context.locale ?? "__default__"}`;
+	if (search.provider === "mcp" && raw?.provider === "mcp") return `mcp:${raw.endpoint}:${context.locale ?? "__default__"}`;
+	return `${search.provider}:${context.locale ?? "__default__"}`;
+}
+async function maybeSyncSearchIndex(adapter, search, context) {
+	if (!shouldSyncOnSearch(search) || typeof adapter.index !== "function") return;
+	const syncKey = getSyncKey(search, context);
+	if (syncedIndexes.has(syncKey)) return;
+	await adapter.index(context);
+	syncedIndexes.add(syncKey);
+}
+async function performDocsSearch(options) {
+	const search = normalizeDocsSearchConfig(options.search);
+	if (!search.enabled) return [];
+	const audience = resolveDocsSearchAudience(options.audience);
+	const documents = buildDocsSearchDocuments(options.pages, search.chunking, audience);
+	const context = {
+		pages: options.pages,
+		documents,
+		audience,
+		locale: options.locale,
+		pathname: options.pathname,
+		siteTitle: options.siteTitle,
+		signal: options.signal
+	};
+	const query = {
+		query: options.query,
+		limit: options.limit ?? search.maxResults,
+		locale: options.locale,
+		pathname: options.pathname,
+		audience
+	};
+	try {
+		const adapter = await resolveSearchAdapter(search, context);
+		await maybeSyncSearchIndex(adapter, search, audience === "agent" ? {
+			...context,
+			documents: buildDocsSearchDocuments(options.pages, search.chunking, "human"),
+			audience: "human"
+		} : context);
+		const results = await adapter.search(query, context);
+		if (search.provider === "simple") return results;
+		const localAudienceProjectionResults = buildAudienceProjectionSearchResults(documents, options.query);
+		const localPagePaths = new Set(options.pages.map((page) => normalizeUrlPathname(page.url)));
+		const preserveUnmatched = audience === "human" || search.provider === "mcp" ? (result) => shouldPreserveUnmatchedExternalResult({
+			result,
+			localPagePaths,
+			baseUrl: options.baseUrl
+		}) : void 0;
+		const safeAdapterResults = sanitizeExternalAudienceSearchResults(results.filter((result) => !hasOppositeAudienceEvidence({
+			result,
+			pages: options.pages,
+			query: options.query,
+			audience,
+			baseUrl: options.baseUrl,
+			strictExternalOrigins: options.strictExternalOrigins
+		})), localAudienceProjectionResults, options.baseUrl, options.strictExternalOrigins, preserveUnmatched);
+		if (options.supplementExternalResults === false) return safeAdapterResults.slice(0, query.limit ?? search.maxResults ?? DEFAULT_SEARCH_LIMIT);
+		const simpleAudienceResults = audience === "agent" || results.length === 0 || safeAdapterResults.length < results.length ? await createSimpleSearchAdapter().search(query, context) : [];
+		const combinedResults = mergeSearchResults([
+			buildExactPageSearchResults(options.query, options.pages, audience),
+			safeAdapterResults,
+			simpleAudienceResults
+		], audience === "agent" ? (result) => getAskAIResultKey(result, options.baseUrl, options.strictExternalOrigins) : void 0);
+		return prioritizeLiteralInsideResults(options.query, combinedResults).slice(0, query.limit ?? search.maxResults ?? DEFAULT_SEARCH_LIMIT);
+	} catch (error) {
+		if (options.failureMode === "throw") throw error;
+		return createSimpleSearchAdapter().search(query, context);
+	}
+}
+async function buildDocsAskAIContext(options) {
+	const limit = options.limit ?? 5;
+	const searchLimit = Math.max(limit * 2, limit);
+	const initialSearch = options.search === false ? true : options.search;
+	const primarySearch = normalizeDocsSearchConfig(initialSearch).enabled ? initialSearch : true;
+	const searchResults = await performDocsSearch({
+		pages: options.pages,
+		query: options.query,
+		search: primarySearch,
+		audience: "agent",
+		locale: options.locale,
+		pathname: options.pathname,
+		siteTitle: options.siteTitle,
+		baseUrl: options.baseUrl,
+		limit: searchLimit,
+		failureMode: options.searchFailureMode,
+		strictExternalOrigins: options.strictExternalOrigins,
+		signal: options.signal
+	});
+	const seen = /* @__PURE__ */ new Set();
+	const maxResultChars = options.maxResultChars ?? DEFAULT_ASK_AI_RESULT_CHARS;
+	const rankedResults = searchResults.map((result, index) => {
+		const formatted = formatAskAIContextResult({
+			result,
+			page: findPageForSearchResult(options.pages, result, options.baseUrl, options.strictExternalOrigins),
+			maxChars: maxResultChars,
+			baseUrl: options.baseUrl
+		});
+		return {
+			result,
+			formatted,
+			index,
+			rank: rankAskAIContextResult(options.query, formatted)
+		};
+	}).sort((a, b) => b.rank - a.rank || a.index - b.index);
+	const formattedResults = rankedResults.map((item) => item.formatted);
+	const sectionResultPaths = new Set(formattedResults.filter((result) => result.section).map((result) => getAskAIResultPageKey(result.url, options.baseUrl, options.strictExternalOrigins)));
+	const results = formattedResults.filter((result) => result.section || !sectionResultPaths.has(getAskAIResultPageKey(result.url, options.baseUrl, options.strictExternalOrigins))).filter((result) => {
+		const key = getAskAIResultKey(result, options.baseUrl, options.strictExternalOrigins);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return result.contextContent.length > 0;
+	}).slice(0, limit);
+	const maxContextChars = options.maxContextChars ?? DEFAULT_ASK_AI_CONTEXT_CHARS;
+	const blocks = [];
+	let usedChars = 0;
+	for (const result of results) {
+		const block = buildAskAIContextBlock(result);
+		const separatorChars = blocks.length === 0 ? 0 : 7;
+		if (usedChars + separatorChars + block.length > maxContextChars) {
+			const remaining = maxContextChars - usedChars - separatorChars;
+			if (remaining > 400) blocks.push(clampText(block, remaining));
+			break;
+		}
+		blocks.push(block);
+		usedChars += separatorChars + block.length;
+	}
+	const context = blocks.join("\n\n---\n\n");
+	return {
+		context,
+		blocks: blocks.map((text, index) => ({
+			text,
+			result: results[index]
+		})),
+		results: results.slice(0, blocks.length),
+		searchResults: rankedResults.map((item) => item.result),
+		packageHints: inferDocsAskAIPackageHints(context)
+	};
+}
+function createCustomSearchAdapter(adapter) {
+	return {
+		provider: "custom",
+		adapter
+	};
+}
+
+//#endregion
+export { emitDocsTelemetryProjectEvent as A, applySidebarFolderIndexBehavior as C, emitDocsTelemetryAgentSurfaceEvent as D, resolveSidebarFolderIndexBehaviorForPath as E, resolveDocsTelemetryConfig as F, inferDocsTelemetryAgentSurface as M, isLocalDocsTelemetryOrigin as N, emitDocsTelemetryEvent as O, normalizeDocsTelemetryOrigin as P, stripGeneratedAgentProvenance as S, resolveSidebarFolderIndexBehavior as T, GENERATED_AGENT_PROVENANCE_VERSION as _, createMcpSearchAdapter as a, parseGeneratedAgentDocument as b, formatDocsAskAIPackageHints as c, resolveAskAISearchRequestConfig as d, resolveDocsSearchAudience as f, GENERATED_AGENT_PROVENANCE_MARKER as g, parseDocsMarkdownSections as h, createCustomSearchAdapter as i, getDocsTelemetryFeatures as j, emitDocsTelemetryMcpToolEvent as k, inferDocsAskAIPackageHints as l, findDocsMarkdownSection as m, buildDocsSearchDocuments as n, createSimpleSearchAdapter as o, resolveSearchRequestConfig as p, createAlgoliaSearchAdapter as r, createTypesenseSearchAdapter as s, buildDocsAskAIContext as t, performDocsSearch as u, hashGeneratedAgentContent as v, resolvePageSidebarFolderIndexBehavior as w, serializeGeneratedAgentDocument as x, normalizeGeneratedAgentContent as y };