@farming-labs/docs 0.2.62 → 0.2.63

package/dist/reading-time-CYZ5VvKU.mjs

@@ -0,0 +1,742 @@
+import { Dt as DEFAULT_SITEMAP_MD_ROUTE, c as DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE, f as DEFAULT_DOCS_CONFIG_ROUTE, h as DEFAULT_LLMS_FULL_TXT_ROUTE, i as DEFAULT_AGENT_FEEDBACK_ROUTE, kt as DEFAULT_SITEMAP_XML_ROUTE, m as DEFAULT_DOCS_DIAGNOSTICS_ROUTE, nn as DEFAULT_MCP_WELL_KNOWN_ROUTE, t as DEFAULT_AGENTS_MD_ROUTE, v as DEFAULT_LLMS_TXT_ROUTE, x as DEFAULT_SKILL_MD_ROUTE } from "./agent-DKKptIgy.mjs";
+import { c as DEFAULT_AGENT_SKILLS_INDEX_ROUTE, g as DEFAULT_API_CATALOG_ROUTE, n as API_CATALOG_MEDIA_TYPE, r as API_CATALOG_PROFILE_URI, t as AGENT_SKILLS_DISCOVERY_SCHEMA_URI, u as DEFAULT_AGENT_SKILLS_ROUTE_PREFIX } from "./standards-discovery-jkykaXq1.mjs";
+import { n as DEFAULT_ROBOTS_TXT_ROUTE } from "./robots-BIpC4j4P.mjs";
+import matter from "gray-matter";
+
+//#region src/define-docs.ts
+/**
+* Define docs configuration. Validates and returns the config.
+*/
+function defineDocs(config) {
+	return {
+		entry: config.entry ?? "docs",
+		docsPath: config.docsPath,
+		contentDir: config.contentDir,
+		i18n: config.i18n,
+		theme: config.theme,
+		nav: config.nav,
+		github: config.github,
+		themeToggle: config.themeToggle,
+		breadcrumb: config.breadcrumb,
+		sidebar: config.sidebar,
+		components: config.components,
+		analytics: config.analytics,
+		telemetry: config.telemetry,
+		cloud: config.cloud,
+		observability: config.observability,
+		onCopyClick: config.onCopyClick,
+		codeBlocks: config.codeBlocks,
+		feedback: config.feedback,
+		search: config.search,
+		mcp: config.mcp,
+		icons: config.icons,
+		pageActions: config.pageActions,
+		lastUpdated: config.lastUpdated,
+		readingTime: config.readingTime,
+		llmsTxt: config.llmsTxt,
+		sitemap: config.sitemap,
+		robots: config.robots,
+		ai: config.ai,
+		ordering: config.ordering,
+		metadata: config.metadata,
+		og: config.og,
+		changelog: config.changelog,
+		apiReference: config.apiReference,
+		agent: config.agent,
+		review: config.review
+	};
+}
+
+//#endregion
+//#region src/changelog.ts
+function normalizePathSegment(value, fallback) {
+	return (value ?? fallback).trim().replace(/^\/+|\/+$/g, "") || fallback;
+}
+function normalizeContentDir(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return "changelog";
+	return trimmed.replace(/\/+$/, "") || "changelog";
+}
+function resolveChangelogConfig(value) {
+	if (value === false || value === void 0) return {
+		enabled: false,
+		path: "changelog",
+		contentDir: "changelog",
+		title: "Changelog",
+		description: void 0,
+		search: true
+	};
+	if (value === true) return {
+		enabled: true,
+		path: "changelog",
+		contentDir: "changelog",
+		title: "Changelog",
+		description: void 0,
+		search: true
+	};
+	return {
+		enabled: value.enabled !== false,
+		path: normalizePathSegment(value.path, "changelog"),
+		contentDir: normalizeContentDir(value.contentDir),
+		title: value.title?.trim() || "Changelog",
+		description: value.description?.trim() || void 0,
+		search: value.search !== false,
+		actionsComponent: value.actionsComponent
+	};
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Deep merge utility for theme overrides.
+* Merges objects recursively; later values override earlier ones.
+*/
+function deepMerge(target, ...sources) {
+	if (!sources.length) return target;
+	const source = sources.shift();
+	if (!source) return target;
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sourceVal = source[key];
+		const targetVal = result[key];
+		if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal && typeof targetVal === "object" && !Array.isArray(targetVal)) result[key] = deepMerge(targetVal, sourceVal);
+		else if (sourceVal !== void 0) result[key] = sourceVal;
+	}
+	if (sources.length) return deepMerge(result, ...sources);
+	return result;
+}
+
+//#endregion
+//#region src/create-theme.ts
+/**
+* Create a theme preset factory.
+*
+* Returns a function that accepts optional overrides and deep-merges them
+* with the base theme defaults. This is the same pattern used by the
+* built-in `fumadocs()`, `darksharp()`, and `pixelBorder()` presets.
+*
+* @param baseTheme - The default theme configuration
+* @returns A factory function `(overrides?) => DocsTheme`
+*
+* @example
+* ```ts
+* import { createTheme } from "@farming-labs/docs";
+*
+* export const myTheme = createTheme({
+*   name: "my-theme",
+*   ui: {
+*     colors: { primary: "#6366f1" },
+*     layout: { contentWidth: 800 },
+*   },
+* });
+* ```
+*/
+function createTheme(baseTheme) {
+	return function themeFactory(overrides = {}) {
+		const merged = deepMerge(baseTheme, overrides);
+		if (overrides.ui?.colors) merged._userColorOverrides = { ...overrides.ui.colors };
+		return merged;
+	};
+}
+/**
+* Extend an existing theme preset with additional defaults.
+*
+* Useful when you want to build on top of an existing theme (e.g. fumadocs)
+* rather than starting from scratch.
+*
+* @example
+* ```ts
+* import { extendTheme } from "@farming-labs/docs";
+* import { fumadocs } from "@farming-labs/theme/default";
+*
+* // Start with fumadocs defaults, override some values
+* export const myTheme = extendTheme(fumadocs(), {
+*   name: "my-custom-fumadocs",
+*   ui: { colors: { primary: "#22c55e" } },
+* });
+* ```
+*/
+function extendTheme(baseTheme, extensions) {
+	return deepMerge(baseTheme, extensions);
+}
+
+//#endregion
+//#region src/http-link.ts
+/** Split an HTTP list without treating delimiters inside quotes or URI references as separators. */
+function splitHttpList(value, delimiter) {
+	const parts = [];
+	let start = 0;
+	let quoted = false;
+	let escaped = false;
+	let angleDepth = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (quoted && character === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (character === "\"") {
+			quoted = !quoted;
+			continue;
+		}
+		if (!quoted && character === "<") angleDepth += 1;
+		if (!quoted && character === ">" && angleDepth > 0) angleDepth -= 1;
+		if (!quoted && angleDepth === 0 && character === delimiter) {
+			parts.push(value.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	parts.push(value.slice(start).trim());
+	return parts.filter(Boolean);
+}
+function unquoteHttpValue(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("\"") || !trimmed.endsWith("\"")) return trimmed;
+	return trimmed.slice(1, -1).replace(/\\(.)/g, "$1");
+}
+/** Parse Link header values while preserving the target/relation association. */
+function parseHttpLinkHeader(header) {
+	if (!header) return [];
+	const links = [];
+	for (const value of splitHttpList(header, ",")) {
+		const target = value.match(/^\s*<([^>]*)>/);
+		if (!target) continue;
+		const relations = [];
+		for (const rawParameter of splitHttpList(value.slice(target[0].length), ";")) {
+			const separator = rawParameter.indexOf("=");
+			if (separator < 0 || rawParameter.slice(0, separator).trim().toLowerCase() !== "rel") continue;
+			relations.push(...unquoteHttpValue(rawParameter.slice(separator + 1)).toLowerCase().split(/\s+/));
+		}
+		links.push({
+			href: target[1],
+			relations: relations.filter(Boolean)
+		});
+	}
+	return links;
+}
+function httpLinkMatchesExpectation(links, expectation, responseUrl) {
+	let expectedUrl;
+	try {
+		expectedUrl = new URL(expectation.href, responseUrl).toString();
+	} catch {
+		return false;
+	}
+	return links.some((link) => {
+		try {
+			return new URL(link.href, responseUrl).toString() === expectedUrl && link.relations.includes(expectation.rel.toLowerCase());
+		} catch {
+			return false;
+		}
+	});
+}
+function httpLinkHeaderHasTargetRelation(header, href, rel, responseUrl) {
+	return httpLinkMatchesExpectation(parseHttpLinkHeader(header), {
+		href,
+		rel
+	}, responseUrl);
+}
+
+//#endregion
+//#region src/agent-conformance.ts
+const DOCS_AGENT_CONTRACT_VERSION = "1.1";
+function normalizeOrigin(value) {
+	return value.replace(/\/+$/, "");
+}
+function normalizeEntry(value) {
+	return value.replace(/^\/+|\/+$/g, "") || "docs";
+}
+/**
+* The framework-neutral public surface every first-party adapter must implement.
+* Adapter tests consume this list so new routes and invariants are added once.
+*/
+function createDocsAgentContractCases(options = {}) {
+	const origin = normalizeOrigin(options.origin ?? "http://localhost");
+	const entry = normalizeEntry(options.entry ?? "docs");
+	const locale = options.locale === void 0 ? "fr" : options.locale;
+	const url = (route) => `${origin}${route.startsWith("/") ? route : `/${route}`}`;
+	const markdown = ["text/markdown"];
+	const json = ["application/json"];
+	const cases = [
+		{
+			surface: "discovery",
+			request: { url: url(DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: json,
+				linkRelations: [{
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}, {
+					href: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+					rel: "service-meta"
+				}]
+			}
+		},
+		{
+			surface: "api-catalog",
+			request: { url: url(DEFAULT_API_CATALOG_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: [`${API_CATALOG_MEDIA_TYPE}; profile="${API_CATALOG_PROFILE_URI}"`],
+				bodyIncludes: [
+					"linkset",
+					DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE,
+					DEFAULT_AGENT_SKILLS_INDEX_ROUTE
+				],
+				linkRelations: [{
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "api-catalog-head",
+			request: {
+				url: url(DEFAULT_API_CATALOG_ROUTE),
+				init: { method: "HEAD" }
+			},
+			expect: {
+				statuses: [200],
+				contentTypes: [`${API_CATALOG_MEDIA_TYPE}; profile="${API_CATALOG_PROFILE_URI}"`],
+				bodyEmpty: true,
+				linkRelations: [{
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "agent-skills-index",
+			request: { url: url(DEFAULT_AGENT_SKILLS_INDEX_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: json,
+				bodyIncludes: [
+					"https://schemas.agentskills.io/discovery/0.2.0/schema.json",
+					`${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/docs/SKILL.md`,
+					"sha256:"
+				],
+				linkRelations: [{
+					href: `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/docs/SKILL.md`,
+					rel: "item"
+				}, {
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "agent-skills-index-head",
+			request: {
+				url: url(DEFAULT_AGENT_SKILLS_INDEX_ROUTE),
+				init: { method: "HEAD" }
+			},
+			expect: {
+				statuses: [200],
+				contentTypes: json,
+				bodyEmpty: true,
+				linkRelations: [{
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "agent-skill",
+			request: { url: url(`${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/docs/SKILL.md`) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["name: docs"],
+				linkRelations: [{
+					href: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+					rel: "collection"
+				}, {
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "agent-skill-head",
+			request: {
+				url: url(`${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/docs/SKILL.md`),
+				init: { method: "HEAD" }
+			},
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyEmpty: true,
+				linkRelations: [{
+					href: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+					rel: "collection"
+				}, {
+					href: DEFAULT_API_CATALOG_ROUTE,
+					rel: "api-catalog"
+				}]
+			}
+		},
+		{
+			surface: "config",
+			request: { url: url(DEFAULT_DOCS_CONFIG_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: json,
+				bodyIncludes: ["docs-config-map.v1"]
+			}
+		},
+		{
+			surface: "diagnostics",
+			request: { url: url(DEFAULT_DOCS_DIAGNOSTICS_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: json,
+				bodyIncludes: ["docs-diagnostics.v1"]
+			}
+		},
+		{
+			surface: "feedback-schema",
+			request: { url: url(`${DEFAULT_AGENT_FEEDBACK_ROUTE}/schema`) },
+			expect: {
+				statuses: [200],
+				contentTypes: ["application/schema+json"]
+			}
+		},
+		{
+			surface: "markdown",
+			request: { url: url(`/${entry}.md`) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["Introduction"]
+			}
+		},
+		{
+			surface: "markdown-accept",
+			request: {
+				url: url(`/${entry}`),
+				init: { headers: { Accept: "text/markdown" } }
+			},
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["Introduction"]
+			}
+		},
+		{
+			surface: "markdown-missing",
+			request: { url: url(`/${entry}/missing.md`) },
+			expect: {
+				statuses: [200, 404],
+				contentTypes: markdown,
+				bodyIncludes: ["not found"]
+			}
+		},
+		{
+			surface: "llms",
+			request: { url: url(DEFAULT_LLMS_TXT_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: ["text/plain"],
+				bodyIncludes: ["Introduction"]
+			}
+		},
+		{
+			surface: "llms-full",
+			request: { url: url(DEFAULT_LLMS_FULL_TXT_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: ["text/plain"],
+				bodyIncludes: ["Introduction"]
+			}
+		},
+		{
+			surface: "agents",
+			request: { url: url(DEFAULT_AGENTS_MD_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["AGENTS.md"]
+			}
+		},
+		{
+			surface: "skill",
+			request: { url: url(DEFAULT_SKILL_MD_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["name:"]
+			}
+		},
+		{
+			surface: "sitemap-xml",
+			request: { url: url(DEFAULT_SITEMAP_XML_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: ["application/xml", "text/xml"],
+				bodyIncludes: ["<urlset"]
+			}
+		},
+		{
+			surface: "sitemap-markdown",
+			request: { url: url(DEFAULT_SITEMAP_MD_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["Introduction"]
+			}
+		},
+		{
+			surface: "robots",
+			request: { url: url(DEFAULT_ROBOTS_TXT_ROUTE) },
+			expect: {
+				statuses: [200],
+				contentTypes: ["text/plain"],
+				bodyIncludes: ["User-agent:"]
+			}
+		},
+		{
+			surface: "mcp",
+			request: {
+				url: url(DEFAULT_MCP_WELL_KNOWN_ROUTE),
+				init: {
+					method: "POST",
+					headers: {
+						Accept: "application/json, text/event-stream",
+						"Content-Type": "application/json",
+						"MCP-Protocol-Version": "2025-11-25"
+					},
+					body: JSON.stringify({
+						jsonrpc: "2.0",
+						id: 1,
+						method: "initialize",
+						params: {
+							protocolVersion: "2025-11-25",
+							capabilities: {},
+							clientInfo: {
+								name: "agent-conformance",
+								version: DOCS_AGENT_CONTRACT_VERSION
+							}
+						}
+					})
+				}
+			},
+			expect: {
+				statuses: [200],
+				contentTypes: ["application/json", "text/event-stream"],
+				bodyIncludes: ["serverInfo", "protocolVersion"]
+			}
+		}
+	];
+	if (locale) {
+		const markdownMissingIndex = cases.findIndex((contractCase) => contractCase.surface === "markdown-missing");
+		cases.splice(markdownMissingIndex, 0, {
+			surface: "markdown-locale",
+			request: { url: url(`/${entry}.md?lang=${encodeURIComponent(locale)}`) },
+			expect: {
+				statuses: [200],
+				contentTypes: markdown,
+				bodyIncludes: ["Bonjour"]
+			}
+		});
+	}
+	return cases;
+}
+function parseParameterizedValue(value) {
+	const [rawValue, ...rawParameters] = splitHttpList(value, ";");
+	const normalizedValue = rawValue?.trim().toLowerCase();
+	if (!normalizedValue) return null;
+	const parameters = /* @__PURE__ */ new Map();
+	for (const rawParameter of rawParameters) {
+		const separator = rawParameter.indexOf("=");
+		if (separator < 0) continue;
+		const name = rawParameter.slice(0, separator).trim().toLowerCase();
+		if (!name) continue;
+		parameters.set(name, unquoteHttpValue(rawParameter.slice(separator + 1)));
+	}
+	return {
+		value: normalizedValue,
+		parameters
+	};
+}
+function matchesContentType(actual, expected) {
+	const parsedActual = parseParameterizedValue(actual);
+	if (!parsedActual) return false;
+	return expected.some((value) => {
+		const parsedExpected = parseParameterizedValue(value);
+		if (!parsedExpected || parsedExpected.value !== parsedActual.value) return false;
+		return [...parsedExpected.parameters].every(([name, expectedValue]) => parsedActual.parameters.get(name) === expectedValue);
+	});
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+async function sha256Content(content) {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", content);
+	return [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+async function validateAgentSkillsIndex(content, indexUrl, handle) {
+	const issues = [];
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch {
+		return ["Agent Skills index did not contain valid JSON"];
+	}
+	const root = asRecord(parsed);
+	if (root?.$schema !== AGENT_SKILLS_DISCOVERY_SCHEMA_URI) issues.push(`Agent Skills index did not declare ${AGENT_SKILLS_DISCOVERY_SCHEMA_URI}`);
+	if (!Array.isArray(root?.skills) || root.skills.length === 0) {
+		issues.push("Agent Skills index did not declare any skills");
+		return issues;
+	}
+	const seenNames = /* @__PURE__ */ new Set();
+	const origin = new URL(indexUrl).origin;
+	for (const rawSkill of root.skills) {
+		const skill = asRecord(rawSkill);
+		const name = skill?.name;
+		const description = skill?.description;
+		const artifactRoute = skill?.url;
+		const digest = skill?.digest;
+		if (!isNonEmptyString(name) || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name) || name.length > 64 || skill?.type !== "skill-md" && skill?.type !== "archive" || !isNonEmptyString(description) || description.length > 1024 || !isNonEmptyString(artifactRoute) || typeof digest !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(digest)) {
+			issues.push("Agent Skills index contained an invalid skill entry");
+			continue;
+		}
+		if (seenNames.has(name)) {
+			issues.push(`Agent Skills index declared duplicate skill ${JSON.stringify(name)}`);
+			continue;
+		}
+		seenNames.add(name);
+		let artifactUrl;
+		try {
+			artifactUrl = new URL(artifactRoute, indexUrl);
+		} catch {
+			issues.push(`Agent Skills artifact URL for ${JSON.stringify(name)} was invalid`);
+			continue;
+		}
+		const expectedPath = skill.type === "archive" ? `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/${name}.tar.gz` : `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/${name}/SKILL.md`;
+		if (artifactUrl.origin !== origin || !artifactUrl.pathname.endsWith(expectedPath)) {
+			issues.push(`Agent Skills artifact URL for ${JSON.stringify(name)} did not resolve to same-origin ${expectedPath}`);
+			continue;
+		}
+		try {
+			const response = await handle(new Request(artifactUrl), "agent-skill");
+			const artifact = new Uint8Array(await response.arrayBuffer());
+			if (response.status !== 200) issues.push(`Agent Skills artifact ${JSON.stringify(artifactRoute)} returned status ${response.status}`);
+			const contentType = response.headers.get("content-type") ?? "";
+			if (!matchesContentType(contentType, [skill.type === "archive" ? "application/gzip" : "text/markdown"])) issues.push(`Agent Skills artifact ${JSON.stringify(artifactRoute)} returned content-type ${contentType || "<missing>"}`);
+			const actualDigest = `sha256:${await sha256Content(artifact)}`;
+			if (actualDigest !== digest) issues.push(`Agent Skills artifact ${JSON.stringify(artifactRoute)} digest ${actualDigest} did not match ${digest}`);
+		} catch (error) {
+			issues.push(`Agent Skills artifact ${JSON.stringify(artifactRoute)} failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return issues;
+}
+async function runDocsAgentConformance(options) {
+	const cases = createDocsAgentContractCases(options);
+	const results = [];
+	for (const contractCase of cases) {
+		const issues = [];
+		try {
+			const response = await options.handle(new Request(contractCase.request.url, contractCase.request.init), contractCase.surface);
+			const contentType = response.headers.get("content-type") ?? "";
+			const body = await response.text();
+			if (!contractCase.expect.statuses.includes(response.status)) issues.push(`expected status ${contractCase.expect.statuses.join(" or ")}, received ${response.status}`);
+			if (!matchesContentType(contentType, contractCase.expect.contentTypes)) issues.push(`expected content-type ${contractCase.expect.contentTypes.join(" or ")}, received ${contentType || "<missing>"}`);
+			for (const requiredText of contractCase.expect.bodyIncludes ?? []) if (!body.toLowerCase().includes(requiredText.toLowerCase())) issues.push(`response body did not include ${JSON.stringify(requiredText)}`);
+			if (contractCase.expect.bodyEmpty && body !== "") issues.push(`expected an empty response body, received ${body.length} characters`);
+			if (contractCase.surface === "agent-skills-index") issues.push(...await validateAgentSkillsIndex(body, contractCase.request.url, options.handle));
+			for (const [header, requiredValues] of Object.entries(contractCase.expect.headerIncludes ?? {})) {
+				const actual = response.headers.get(header) ?? "";
+				for (const requiredValue of requiredValues) if (!actual.toLowerCase().includes(requiredValue.toLowerCase())) issues.push(`response header ${JSON.stringify(header)} did not include ${JSON.stringify(requiredValue)}`);
+			}
+			const parsedLinks = parseHttpLinkHeader(response.headers.get("link"));
+			for (const expectation of contractCase.expect.linkRelations ?? []) if (!httpLinkMatchesExpectation(parsedLinks, expectation, contractCase.request.url)) issues.push(`response Link header did not include ${JSON.stringify(expectation.href)} with rel=${JSON.stringify(expectation.rel)} in the same link-value`);
+			results.push({
+				surface: contractCase.surface,
+				passed: issues.length === 0,
+				status: response.status,
+				contentType,
+				issues
+			});
+		} catch (error) {
+			issues.push(error instanceof Error ? error.message : String(error));
+			results.push({
+				surface: contractCase.surface,
+				passed: false,
+				issues
+			});
+		}
+	}
+	return {
+		adapter: options.adapter,
+		contractVersion: DOCS_AGENT_CONTRACT_VERSION,
+		passed: results.every((result) => result.passed),
+		cases: results
+	};
+}
+
+//#endregion
+//#region src/reading-time.ts
+function hasExplicitReadingTime(frontmatter) {
+	return Object.prototype.hasOwnProperty.call(frontmatter ?? {}, "readingTime");
+}
+function normalizeWordsPerMinute(wordsPerMinute) {
+	if (typeof wordsPerMinute !== "number" || !Number.isFinite(wordsPerMinute)) return 220;
+	return Math.max(1, Math.floor(wordsPerMinute));
+}
+function stripNonReadingContent(content, options) {
+	const includeCode = options?.includeCode === true;
+	return (includeCode ? content.replace(/^(`{3,}|~{3,})[^\n]*$/gm, " ").replace(/`([^`\n]+)`/g, " $1 ") : content.replace(/(`{3,})[^\n]*\n[\s\S]*?\1/g, " ").replace(/(~{3,})[^\n]*\n[\s\S]*?\1/g, " ").replace(/`[^`\n]+`/g, " ")).replace(/!\[[^\]]*\]\([^)]+\)/g, " ").replace(/\[([^\]]+)\]\([^)]+\)/g, " $1 ").replace(/<[^>]+>/g, " ").replace(includeCode ? /[{}]/g : /\{[^{}]*\}/g, " ").replace(/https?:\/\/\S+/g, " ").replace(/[#>*_~|]/g, " ");
+}
+function estimateReadingTimeMinutes(content, wordsPerMinute, options) {
+	const wordCount = stripNonReadingContent(content, options).match(/\b[\p{L}\p{N}][\p{L}\p{N}'’-]*\b/gu)?.length ?? 0;
+	return Math.max(1, Math.ceil(wordCount / normalizeWordsPerMinute(wordsPerMinute)));
+}
+function resolveReadingTimeOptions(readingTime) {
+	if (readingTime === true) return {
+		enabled: true,
+		format: "long",
+		includeCode: false
+	};
+	if (readingTime === false || readingTime === void 0 || readingTime === null) return {
+		enabled: false,
+		format: "long",
+		includeCode: false
+	};
+	if (typeof readingTime !== "object") return {
+		enabled: false,
+		format: "long",
+		includeCode: false
+	};
+	return {
+		enabled: readingTime.enabled !== false,
+		wordsPerMinute: typeof readingTime.wordsPerMinute === "number" && Number.isFinite(readingTime.wordsPerMinute) ? readingTime.wordsPerMinute : void 0,
+		format: readingTime.format === "short" ? "short" : "long",
+		includeCode: readingTime.includeCode === true
+	};
+}
+function resolveReadingTimeFromContent(frontmatter, content, wordsPerMinute, options) {
+	const pageData = frontmatter ?? {};
+	if (pageData.readingTime === false) return null;
+	if (typeof pageData.readingTime === "number" && Number.isFinite(pageData.readingTime)) return Math.max(1, Math.ceil(pageData.readingTime));
+	return estimateReadingTimeMinutes(content, wordsPerMinute, options);
+}
+function resolvePageReadingTime(frontmatter, content, options) {
+	if (!(options?.enabledByDefault ?? false) && !hasExplicitReadingTime(frontmatter)) return;
+	return resolveReadingTimeFromContent(frontmatter, content, options?.wordsPerMinute, { includeCode: options?.includeCode });
+}
+function resolveReadingTimeFromSource(source, wordsPerMinute, options) {
+	const { data, content } = matter(source);
+	return resolveReadingTimeFromContent(data, content, wordsPerMinute, options);
+}
+
+//#endregion
+export { resolveReadingTimeOptions as a, runDocsAgentConformance as c, extendTheme as d, deepMerge as f, resolveReadingTimeFromSource as i, httpLinkHeaderHasTargetRelation as l, defineDocs as m, resolvePageReadingTime as n, DOCS_AGENT_CONTRACT_VERSION as o, resolveChangelogConfig as p, resolveReadingTimeFromContent as r, createDocsAgentContractCases as s, estimateReadingTimeMinutes as t, createTheme as u };