@farming-labs/docs 0.2.115 → 0.2.117

package/dist/api-reference-0XdEWya8.mjs

@@ -0,0 +1,3033 @@
+import { B as detectDocsMarkdownAgentRequest, G as hasDocsMarkdownSignatureAgent, R as createDocsMarkdownResponse, Tt as toDocsMarkdownUrl, k as acceptsDocsMarkdown, ot as renderDocsMarkdownDocument } from "./agent-CEZCaYto.mjs";
+import { n as buildNormalizedOpenApiModel } from "./openapi-operations-DFpaqOqA.mjs";
+import { parse } from "yaml";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { getHtmlDocument } from "@scalar/core/libs/html-rendering";
+import { paths, query } from "jsonpath-rfc9535";
+import { createHash } from "node:crypto";
+
+//#region src/openapi-contract.ts
+const OPENAPI_HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+var OpenApiContractValidationError = class extends Error {
+	diagnostics;
+	constructor(result) {
+		const first = result.diagnostics[0];
+		const remaining = result.diagnostics.length - 1;
+		super(first ? `OpenAPI contract validation failed at ${first.path}: ${first.message}${remaining > 0 ? ` (${remaining} more ${remaining === 1 ? "error" : "errors"})` : ""}` : "OpenAPI contract validation failed.");
+		this.name = "OpenApiContractValidationError";
+		this.diagnostics = result.diagnostics;
+	}
+};
+function validateOpenApiContract(document) {
+	const state = {
+		diagnostics: [],
+		operationIds: /* @__PURE__ */ new Map(),
+		operationCount: 0,
+		activePathItems: /* @__PURE__ */ new WeakSet()
+	};
+	const hasOpenApi = Object.hasOwn(document, "openapi");
+	const hasSwagger = Object.hasOwn(document, "swagger");
+	let dialect;
+	let version;
+	if (hasOpenApi && hasSwagger) addDiagnostic(state, "conflicting-version-fields", "/", "Use either the `openapi` field or the `swagger` field, not both.");
+	else if (hasOpenApi) {
+		dialect = "openapi";
+		version = validateOpenApiVersion(document.openapi, state);
+	} else if (hasSwagger) {
+		dialect = "swagger";
+		version = validateSwaggerVersion(document.swagger, state);
+	} else addDiagnostic(state, "missing-version", "/", "The document must declare an `openapi` or `swagger` specification version.");
+	inspectPathItemMap(document.paths, "/paths", "paths", state);
+	if (document.webhooks !== void 0) inspectPathItemMap(document.webhooks, "/webhooks", "webhooks", state);
+	return {
+		valid: state.diagnostics.length === 0,
+		dialect,
+		version,
+		operationCount: state.operationCount,
+		diagnostics: state.diagnostics
+	};
+}
+function assertValidOpenApiContract(document) {
+	const result = validateOpenApiContract(document);
+	if (!result.valid) throw new OpenApiContractValidationError(result);
+}
+function validateOpenApiVersion(value, state) {
+	if (typeof value !== "string" || !/^\d+\.\d+\.\d+$/.test(value)) {
+		addDiagnostic(state, "invalid-version", "/openapi", "`openapi` must be a stable major.minor.patch version string.");
+		return;
+	}
+	if (!/^3\.(?:0|1|2)\.\d+$/.test(value)) addDiagnostic(state, "unsupported-version", "/openapi", `OpenAPI ${value} is not supported. Supported families are 3.0.x, 3.1.x, and 3.2.x.`);
+	return value;
+}
+function validateSwaggerVersion(value, state) {
+	if (typeof value !== "string") {
+		addDiagnostic(state, "invalid-version", "/swagger", "`swagger` must be the string `2.0`.");
+		return;
+	}
+	if (value !== "2.0") addDiagnostic(state, "unsupported-version", "/swagger", `Swagger ${value} is not supported. The supported Swagger version is 2.0.`);
+	return value;
+}
+function inspectPathItemMap(value, pointer, kind, state) {
+	if (value === void 0) return;
+	if (!isRecord$1(value)) {
+		addDiagnostic(state, kind === "paths" ? "invalid-paths" : kind === "webhooks" ? "invalid-webhooks" : "invalid-callbacks", pointer, `\`${kind}\` must be an object.`);
+		return;
+	}
+	for (const [key, pathItem] of Object.entries(value)) {
+		if (key.startsWith("x-")) continue;
+		const pathPointer = `${pointer}/${escapeJsonPointer$1(key)}`;
+		if (!isRecord$1(pathItem)) {
+			addDiagnostic(state, "invalid-path-item", pathPointer, "Path items must be objects or Reference Objects.");
+			continue;
+		}
+		inspectPathItem(pathItem, pathPointer, state);
+	}
+}
+function inspectPathItem(pathItem, pointer, state) {
+	if (state.activePathItems.has(pathItem)) return;
+	state.activePathItems.add(pathItem);
+	try {
+		for (const method of OPENAPI_HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (operation === void 0) continue;
+			const operationPointer = `${pointer}/${method}`;
+			if (!isRecord$1(operation)) {
+				addDiagnostic(state, "invalid-operation", operationPointer, `The ${method.toUpperCase()} operation must be an object.`);
+				continue;
+			}
+			state.operationCount += 1;
+			inspectOperationId(operation.operationId, `${operationPointer}/operationId`, state);
+			inspectCallbacks(operation.callbacks, `${operationPointer}/callbacks`, state);
+		}
+	} finally {
+		state.activePathItems.delete(pathItem);
+	}
+}
+function inspectOperationId(value, pointer, state) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.trim().length === 0) {
+		addDiagnostic(state, "invalid-operation-id", pointer, "`operationId` must be a non-empty string when provided.");
+		return;
+	}
+	const firstPath = state.operationIds.get(value);
+	if (firstPath) {
+		addDiagnostic(state, "duplicate-operation-id", pointer, `The operationId \`${value}\` is already used at ${firstPath}.`, firstPath);
+		return;
+	}
+	state.operationIds.set(value, pointer);
+}
+function inspectCallbacks(value, pointer, state) {
+	if (value === void 0) return;
+	if (!isRecord$1(value)) {
+		addDiagnostic(state, "invalid-callbacks", pointer, "`callbacks` must be an object.");
+		return;
+	}
+	for (const [callbackName, callback] of Object.entries(value)) {
+		if (callbackName.startsWith("x-")) continue;
+		const callbackPointer = `${pointer}/${escapeJsonPointer$1(callbackName)}`;
+		if (!isRecord$1(callback)) {
+			addDiagnostic(state, "invalid-callbacks", callbackPointer, "Callback entries must be Callback Objects or Reference Objects.");
+			continue;
+		}
+		if (typeof callback.$ref === "string") continue;
+		inspectPathItemMap(callback, callbackPointer, "callbacks", state);
+	}
+}
+function addDiagnostic(state, code, path, message, relatedPath) {
+	state.diagnostics.push({
+		severity: "error",
+		code,
+		path,
+		message,
+		relatedPath
+	});
+}
+function escapeJsonPointer$1(value) {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function isRecord$1(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/openapi-overlays.ts
+var OpenApiOverlayError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OpenApiOverlayError";
+	}
+};
+function isJsonObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonPrimitive(value) {
+	return value === null || typeof value !== "object";
+}
+function assertAllowedFields(value, allowed, location) {
+	const allowedSet = new Set(allowed);
+	const unexpected = Object.keys(value).find((key) => !allowedSet.has(key) && !key.startsWith("x-"));
+	if (unexpected) throw new OpenApiOverlayError(`${location} contains an unsupported \`${unexpected}\` field.`);
+}
+function requireNonEmptyString(value, location) {
+	if (typeof value !== "string" || !value.trim()) throw new OpenApiOverlayError(`${location} must be a non-empty string.`);
+	return value.trim();
+}
+function assertValidOpenApiOverlayDocument(value, source = "OpenAPI Overlay document") {
+	if (!isJsonObject(value)) throw new OpenApiOverlayError(`${source} must contain an object.`);
+	const overlayVersion = requireNonEmptyString(value.overlay, `${source} \`overlay\``);
+	const match = /^1\.(0|1)\.\d+$/.exec(overlayVersion);
+	if (!match) throw new OpenApiOverlayError(`${source} uses unsupported Overlay version \`${overlayVersion}\`. Supported versions are 1.0.x and 1.1.x.`);
+	const featureVersion = match[1] === "0" ? "1.0" : "1.1";
+	assertAllowedFields(value, [
+		"overlay",
+		"info",
+		"extends",
+		"actions"
+	], source);
+	if (!isJsonObject(value.info)) throw new OpenApiOverlayError(`${source} \`info\` must be an object.`);
+	assertAllowedFields(value.info, featureVersion === "1.1" ? [
+		"title",
+		"version",
+		"description"
+	] : ["title", "version"], `${source} \`info\``);
+	requireNonEmptyString(value.info.title, `${source} \`info.title\``);
+	requireNonEmptyString(value.info.version, `${source} \`info.version\``);
+	if (value.extends !== void 0 && typeof value.extends !== "string") throw new OpenApiOverlayError(`${source} \`extends\` must be a URI-reference string.`);
+	if (!Array.isArray(value.actions) || value.actions.length === 0) throw new OpenApiOverlayError(`${source} \`actions\` must contain at least one action.`);
+	const serializedActions = /* @__PURE__ */ new Set();
+	value.actions.forEach((action, index) => {
+		const location = `${source} action ${index + 1}`;
+		if (!isJsonObject(action)) throw new OpenApiOverlayError(`${location} must be an object.`);
+		assertAllowedFields(action, featureVersion === "1.1" ? [
+			"target",
+			"description",
+			"update",
+			"copy",
+			"remove"
+		] : [
+			"target",
+			"description",
+			"update",
+			"remove"
+		], location);
+		if (!requireNonEmptyString(action.target, `${location} \`target\``).startsWith("$")) throw new OpenApiOverlayError(`${location} \`target\` must start with \`$\`.`);
+		if (action.description !== void 0 && typeof action.description !== "string") throw new OpenApiOverlayError(`${location} \`description\` must be a string.`);
+		if (action.remove !== void 0 && typeof action.remove !== "boolean") throw new OpenApiOverlayError(`${location} \`remove\` must be a boolean.`);
+		if (action.copy !== void 0) {
+			if (!requireNonEmptyString(action.copy, `${location} \`copy\``).startsWith("$")) throw new OpenApiOverlayError(`${location} \`copy\` must start with \`$\`.`);
+		}
+		const serialized = JSON.stringify(action);
+		if (serializedActions.has(serialized)) throw new OpenApiOverlayError(`${location} duplicates an earlier action.`);
+		serializedActions.add(serialized);
+	});
+}
+function validateOverlay(value, source) {
+	assertValidOpenApiOverlayDocument(value, source);
+	return {
+		version: String(value.overlay).startsWith("1.0.") ? "1.0" : "1.1",
+		actions: value.actions
+	};
+}
+function decodeNormalizedPathKey(value) {
+	return value.replace(/\\(?:['\\bfnrt]|u[\da-fA-F]{4})/g, (match) => {
+		const escape = match.slice(1);
+		if (escape.startsWith("u")) return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+		return {
+			"'": "'",
+			"\\": "\\",
+			b: "\b",
+			f: "\f",
+			n: "\n",
+			r: "\r",
+			t: "	"
+		}[escape];
+	});
+}
+function parseNormalizedJsonPath(path) {
+	if (path === "$") return [];
+	const segments = [];
+	const segmentPattern = /\[(?:(\d+)|'((?:\\.|[^'])*)')\]/gy;
+	segmentPattern.lastIndex = 1;
+	while (segmentPattern.lastIndex < path.length) {
+		const match = segmentPattern.exec(path);
+		if (!match) throw new OpenApiOverlayError(`JSONPath returned an unsupported normalized path: ${path}`);
+		segments.push(match[1] === void 0 ? decodeNormalizedPathKey(match[2] ?? "") : Number(match[1]));
+	}
+	return segments;
+}
+function getAtPath(root, path) {
+	let value = root;
+	for (const segment of path) {
+		if (Array.isArray(value) && typeof segment === "number") {
+			value = value[segment];
+			continue;
+		}
+		if (isJsonObject(value) && typeof segment === "string") {
+			value = value[segment];
+			continue;
+		}
+		throw new OpenApiOverlayError("An Overlay action selected a node that no longer exists.");
+	}
+	return value;
+}
+function setAtPath(root, path, value) {
+	if (path.length === 0) return value;
+	const parent = getAtPath(root, path.slice(0, -1));
+	const key = path[path.length - 1];
+	if (Array.isArray(parent) && typeof key === "number") parent[key] = value;
+	else if (isJsonObject(parent) && typeof key === "string") parent[key] = value;
+	else throw new OpenApiOverlayError("An Overlay action selected an invalid parent node.");
+	return root;
+}
+function removeAtPath(root, path) {
+	if (path.length === 0) throw new OpenApiOverlayError("An Overlay action cannot remove the document root.");
+	const parent = getAtPath(root, path.slice(0, -1));
+	const key = path[path.length - 1];
+	if (Array.isArray(parent) && typeof key === "number") parent.splice(key, 1);
+	else if (isJsonObject(parent) && typeof key === "string") delete parent[key];
+	else throw new OpenApiOverlayError("An Overlay remove action selected an invalid parent node.");
+}
+function mergeObjectValues(target, update, location) {
+	const result = structuredClone(target);
+	for (const [key, updateValue] of Object.entries(update)) {
+		if (!(key in result)) {
+			result[key] = structuredClone(updateValue);
+			continue;
+		}
+		const targetValue = result[key];
+		if (isJsonObject(targetValue) && isJsonObject(updateValue)) result[key] = mergeObjectValues(targetValue, updateValue, `${location}.${key}`);
+		else if (Array.isArray(targetValue) && Array.isArray(updateValue)) result[key] = [...targetValue, ...structuredClone(updateValue)];
+		else if (isJsonPrimitive(targetValue) && isJsonPrimitive(updateValue)) result[key] = updateValue;
+		else throw new OpenApiOverlayError(`${location} cannot merge incompatible values for \`${key}\`.`);
+	}
+	return result;
+}
+function applyUpdate(target, update, version, location) {
+	if (isJsonObject(target)) {
+		if (!isJsonObject(update)) throw new OpenApiOverlayError(`${location} must use an object update for an object target.`);
+		return mergeObjectValues(target, update, location);
+	}
+	if (Array.isArray(target)) return Array.isArray(update) ? [...target, ...structuredClone(update)] : [...target, structuredClone(update)];
+	if (version === "1.0") throw new OpenApiOverlayError(`${location} selects a primitive, which Overlay 1.0 cannot update.`);
+	if (!isJsonPrimitive(update)) throw new OpenApiOverlayError(`${location} must use a primitive update for a primitive target.`);
+	return update;
+}
+function queryPaths(document, expression, location) {
+	try {
+		return paths(document, expression);
+	} catch (error) {
+		throw new OpenApiOverlayError(`${location} contains invalid RFC 9535 JSONPath: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function queryCopyValue(document, expression, location) {
+	let values;
+	try {
+		values = query(document, expression);
+	} catch (error) {
+		throw new OpenApiOverlayError(`${location} contains invalid RFC 9535 JSONPath: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (values.length !== 1) throw new OpenApiOverlayError(`${location} must select exactly one node, but selected ${values.length}.`);
+	return structuredClone(values[0]);
+}
+function compareRemovalPaths(a, b) {
+	if (a.length !== b.length) return b.length - a.length;
+	const aLast = a[a.length - 1];
+	const bLast = b[b.length - 1];
+	return typeof aLast === "number" && typeof bLast === "number" ? bLast - aLast : 0;
+}
+function getJsonValueKind(value) {
+	if (Array.isArray(value)) return "array";
+	return isJsonObject(value) ? "object" : "primitive";
+}
+function applyOpenApiOverlayDocuments(document, overlays) {
+	let result = structuredClone(document);
+	for (const overlaySource of overlays) {
+		const overlay = validateOverlay(overlaySource.document, overlaySource.source);
+		for (const [actionIndex, action] of overlay.actions.entries()) {
+			const location = `${overlaySource.source} action ${actionIndex + 1}`;
+			const normalizedPaths = queryPaths(result, action.target, `${location} \`target\``);
+			if (normalizedPaths.length === 0) throw new OpenApiOverlayError(`${location} target \`${action.target}\` did not match any nodes.`);
+			const selectedPaths = normalizedPaths.map(parseNormalizedJsonPath);
+			if (action.remove === true) {
+				for (const path of selectedPaths.sort(compareRemovalPaths)) removeAtPath(result, path);
+				continue;
+			}
+			const hasUpdate = Object.prototype.hasOwnProperty.call(action, "update");
+			const hasCopy = typeof action.copy === "string";
+			if (!hasUpdate && !hasCopy) continue;
+			if (new Set(selectedPaths.map((path) => getJsonValueKind(getAtPath(result, path)))).size > 1) throw new OpenApiOverlayError(`${location} must select only objects, only arrays, or only primitives for an update or copy action.`);
+			const updateValue = hasUpdate ? action.update : queryCopyValue(result, action.copy, `${location} \`copy\``);
+			for (const path of selectedPaths) {
+				const updated = applyUpdate(getAtPath(result, path), updateValue, overlay.version, location);
+				result = setAtPath(result, path, updated);
+			}
+		}
+	}
+	if (!isJsonObject(result)) throw new OpenApiOverlayError("OpenAPI Overlay actions must leave an object document root.");
+	return result;
+}
+
+//#endregion
+//#region src/native-api-reference.ts
+const METHOD_TONES = {
+	GET: "success",
+	POST: "info",
+	PUT: "warning",
+	PATCH: "warning",
+	DELETE: "danger",
+	OPTIONS: "neutral",
+	HEAD: "neutral",
+	TRACE: "neutral"
+};
+function renderNativeApiReferenceHtml(options) {
+	const { model } = options;
+	const tokens = resolveTokens(options.theme);
+	const description = options.description?.trim();
+	const versions = options.versions ?? [];
+	const groupedOperations = groupOperations(model.operations);
+	const operationMarkup = model.operations.length > 0 ? model.operations.map((operation) => renderOperation(operation, options)).join("\n") : renderEmptyContract();
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="generator" content="@farming-labs/docs" />
+  <meta name="color-scheme" content="light dark" />
+  <title>${escapeHtml(options.pageTitle)}</title>
+  <style>${buildStyles(tokens)}</style>
+</head>
+<body>
+  <a class="fl-skip-link" href="#fl-api-content">Skip to API operations</a>
+  <div class="fl-api-shell">
+    <header class="fl-api-topbar">
+      <a class="fl-api-brand" href="${escapeAttribute(options.basePath)}" aria-label="API reference home">
+        <span class="fl-api-brand-mark" aria-hidden="true">FL</span>
+        <span>API Reference</span>
+      </a>
+      <div class="fl-api-topbar-actions">
+        ${renderVersionSelect(versions, options.activeVersion)}
+        <a class="fl-api-action" href="${escapeAttribute(options.openApiUrl)}" download>OpenAPI</a>
+        <button class="fl-api-icon-button" type="button" data-theme-toggle aria-label="Switch color theme" title="Switch color theme">
+          ${themeIcon()}
+        </button>
+      </div>
+    </header>
+    <div class="fl-api-layout">
+      <aside class="fl-api-sidebar" aria-label="API operations">
+        <div class="fl-api-sidebar-heading">
+          <span class="fl-api-eyebrow">${escapeHtml(model.specificationVersion)}</span>
+          <span>${model.operationCount} ${model.operationCount === 1 ? "operation" : "operations"}</span>
+        </div>
+        <label class="fl-api-search-label" for="fl-api-search">Search operations</label>
+        <div class="fl-api-search-wrap">
+          ${searchIcon()}
+          <input id="fl-api-search" class="fl-api-search" type="search" placeholder="Method, path, tag…" autocomplete="off" />
+          <kbd>/</kbd>
+        </div>
+        <p class="fl-api-search-status" data-search-status aria-live="polite"></p>
+        <nav class="fl-api-operation-nav">
+          ${renderNavigation(groupedOperations)}
+        </nav>
+      </aside>
+      <main id="fl-api-content" class="fl-api-content">
+        <section class="fl-api-hero" aria-labelledby="fl-api-title">
+          <div class="fl-api-hero-copy">
+            <p class="fl-api-eyebrow">${escapeHtml(model.version)} · ${escapeHtml(model.specificationVersion)}</p>
+            <h1 id="fl-api-title">${escapeHtml(options.title ?? model.title)}</h1>
+            ${description ? `<div class="fl-api-description">${renderText(description)}</div>` : ""}
+          </div>
+          <dl class="fl-api-summary">
+            <div><dt>Operations</dt><dd>${model.operationCount}</dd></div>
+            <div><dt>Tags</dt><dd>${model.tags.length}</dd></div>
+            <div><dt>Servers</dt><dd>${model.servers.length}</dd></div>
+          </dl>
+          ${renderServers(model.servers)}
+        </section>
+        <section class="fl-api-operations" aria-label="Operations">
+          ${operationMarkup}
+          <div class="fl-api-no-results" data-no-results hidden>
+            <strong>No operations match this search.</strong>
+            <span>Try a method, route segment, operation ID, or tag.</span>
+          </div>
+        </section>
+      </main>
+    </div>
+  </div>
+  <div class="fl-api-live-region" aria-live="polite" aria-atomic="true" data-copy-status></div>
+  <script>${buildClientScript()}<\/script>
+</body>
+</html>`;
+}
+function renderVersionSelect(versions, activeVersion) {
+	if (versions.length === 0) return "";
+	return `<label class="fl-api-version-control">
+    <span>Version</span>
+    <select data-version-select aria-label="API version">
+      ${versions.map((version) => `<option value="${escapeAttribute(version.href)}"${version.active || version.id === activeVersion ? " selected" : ""}>${escapeHtml(version.label)}</option>`).join("")}
+    </select>
+  </label>`;
+}
+function renderNavigation(groups) {
+	if (groups.length === 0) return "<p class=\"fl-api-sidebar-empty\">No operations in this contract.</p>";
+	return groups.map((group) => `<section class="fl-api-nav-group" data-nav-group>
+        <h2>${escapeHtml(group.tag)}</h2>
+        <ul>
+          ${group.operations.map((operation) => `<li data-nav-operation data-search="${escapeAttribute(operationSearchText(operation))}">
+                <a href="#operation-${escapeAttribute(operation.slug)}">
+                  <span class="fl-api-method fl-api-method--${methodTone(operation.method)}">${escapeHtml(operation.method)}</span>
+                  <span>${escapeHtml(operation.title)}</span>
+                </a>
+              </li>`).join("")}
+        </ul>
+      </section>`).join("\n");
+}
+function renderOperation(operation, options) {
+	const markdownUrl = `${options.basePath}/operations/${encodeURIComponent(operation.slug)}.md`;
+	const curl = buildCurlExample(operation, options.model.servers);
+	const consoleMarkup = renderApiConsole(operation, options.model.servers);
+	const searchText = operationSearchText(operation);
+	const description = operation.description?.trim();
+	return `<article id="operation-${escapeAttribute(operation.slug)}" class="fl-api-operation" data-operation data-search="${escapeAttribute(searchText)}">
+    <header class="fl-api-operation-header">
+      <div class="fl-api-operation-meta">
+        <span class="fl-api-method fl-api-method--${methodTone(operation.method)}">${escapeHtml(operation.method)}</span>
+        <code>${escapeHtml(operation.path)}</code>
+        ${operation.deprecated ? "<span class=\"fl-api-chip fl-api-chip--danger\">Deprecated</span>" : ""}
+      </div>
+      <h2>${escapeHtml(operation.title)}</h2>
+      ${operation.summary && operation.summary !== operation.title ? `<p class="fl-api-summary-copy">${escapeHtml(operation.summary)}</p>` : ""}
+      ${description ? `<div class="fl-api-description">${renderText(description)}</div>` : ""}
+      <div class="fl-api-operation-links">
+        <a href="${escapeAttribute(markdownUrl)}">Markdown</a>
+        <a href="#operation-${escapeAttribute(operation.slug)}" aria-label="Link to ${escapeAttribute(operation.title)}">Permalink</a>
+        <code>${escapeHtml(operation.operationId)}</code>
+      </div>
+    </header>
+    <div class="fl-api-operation-grid">
+      <div class="fl-api-operation-details">
+        ${renderParameters(operation.parameters)}
+        ${renderRequestBody(operation.requestBody?.content ?? [], operation.requestBody?.required === true, operation.requestBody?.description)}
+        ${renderResponses(operation.responses)}
+        ${renderSecurity(operation)}
+      </div>
+      <aside class="fl-api-code-panel" aria-label="Request example and interactive console" data-console-root>
+        <div class="fl-api-code-header">
+          <div class="fl-api-code-tabs" role="tablist" aria-label="Request tools">
+            <button id="example-tab-${escapeAttribute(operation.slug)}" type="button" role="tab" aria-selected="true" aria-controls="example-panel-${escapeAttribute(operation.slug)}" tabindex="0" data-console-tab="example">cURL</button>
+            <button id="console-tab-${escapeAttribute(operation.slug)}" type="button" role="tab" aria-selected="false" aria-controls="console-panel-${escapeAttribute(operation.slug)}" tabindex="-1" data-console-tab="console">Try it</button>
+          </div>
+          <button type="button" class="fl-api-copy" data-copy="${escapeAttribute(curl)}" data-example-copy aria-label="Copy cURL request">Copy</button>
+        </div>
+        <div id="example-panel-${escapeAttribute(operation.slug)}" role="tabpanel" aria-labelledby="example-tab-${escapeAttribute(operation.slug)}" data-console-panel="example">
+          <pre><code>${escapeHtml(curl)}</code></pre>
+        </div>
+        <div id="console-panel-${escapeAttribute(operation.slug)}" role="tabpanel" aria-labelledby="console-tab-${escapeAttribute(operation.slug)}" data-console-panel="console" hidden>
+          ${consoleMarkup}
+        </div>
+      </aside>
+    </div>
+  </article>`;
+}
+function renderApiConsole(operation, modelServers) {
+	const server = operation.servers[0] ?? modelServers[0] ?? "";
+	const requestBody = operation.requestBody;
+	const requestMedia = requestBody?.content[0];
+	const bodyExample = requestMedia ? mediaTypeExample(requestMedia) : void 0;
+	const mutating = ![
+		"GET",
+		"HEAD",
+		"OPTIONS"
+	].includes(operation.method);
+	return `<form class="fl-api-console" data-api-console data-method="${escapeAttribute(operation.method)}" data-path="${escapeAttribute(operation.path)}" novalidate>
+    <div class="fl-api-console-intro">
+      <div>
+        <span class="fl-api-console-kicker">Browser request</span>
+        <strong>${escapeHtml(operation.method)} ${escapeHtml(operation.path)}</strong>
+      </div>
+      <span class="fl-api-console-state" data-console-state data-state="idle">Ready</span>
+    </div>
+    <label class="fl-api-field">
+      <span>Server URL or path <em>required</em></span>
+      <input name="server" type="text" value="${escapeAttribute(server)}" placeholder="https://api.example.com" required spellcheck="false" autocomplete="url" />
+    </label>
+    ${renderConsoleParameters(operation.parameters)}
+    ${renderConsoleAuthentication(operation)}
+    ${requestBody ? renderConsoleRequestBody(requestBody.content, requestBody.required, bodyExample) : ""}
+    <label class="fl-api-field fl-api-field--inline">
+      <span>Browser credentials</span>
+      <select name="credentials" aria-label="Browser credentials mode">
+        <option value="same-origin">Same origin</option>
+        <option value="include">Include cookies</option>
+        <option value="omit">Omit cookies</option>
+      </select>
+    </label>
+    ${mutating ? `<label class="fl-api-console-confirm"><input type="checkbox" data-console-confirm /><span>I understand this request may change data.</span></label>` : ""}
+    <div class="fl-api-console-actions">
+      <button class="fl-api-console-send" type="submit" data-console-send${mutating ? " disabled" : ""}>Send request</button>
+      <button class="fl-api-console-cancel" type="button" data-console-cancel hidden>Cancel</button>
+      <span data-console-message role="status" aria-live="polite"></span>
+    </div>
+    <div class="fl-api-console-error" data-console-error role="alert" hidden></div>
+    <section class="fl-api-console-response" data-console-response aria-label="API response" tabindex="-1" hidden>
+      <div class="fl-api-console-response-header">
+        <div>
+          <span class="fl-api-console-status" data-response-status></span>
+          <span data-response-duration></span>
+        </div>
+        <button type="button" class="fl-api-copy" data-response-copy aria-label="Copy response body">Copy</button>
+      </div>
+      <div class="fl-api-console-response-meta">
+        <code data-response-url></code>
+        <span data-response-type></span>
+      </div>
+      <details class="fl-api-console-response-headers">
+        <summary>Response headers${chevronIcon()}</summary>
+        <pre><code data-response-headers></code></pre>
+      </details>
+      <pre class="fl-api-console-response-body"><code data-response-body></code></pre>
+    </section>
+    <p class="fl-api-console-note">Requests run in this browser. Cross-origin APIs must allow this docs origin through CORS. Credentials stay in memory and are never saved by Farming Labs.</p>
+  </form>`;
+}
+function renderConsoleParameters(parameters) {
+	const editable = parameters.filter((parameter) => parameter.in !== "cookie");
+	const cookies = parameters.filter((parameter) => parameter.in === "cookie");
+	if (editable.length === 0 && cookies.length === 0) return "";
+	return `<fieldset class="fl-api-console-group">
+    <legend>Parameters</legend>
+    ${editable.map(renderConsoleParameter).join("")}
+    ${cookies.length > 0 ? `<p class="fl-api-console-hint">Cookie parameters (${cookies.map((parameter) => `<code>${escapeHtml(parameter.name)}</code>`).join(", ")}) are browser-managed. Choose <strong>Include cookies</strong> below when the API uses them.</p>` : ""}
+  </fieldset>`;
+}
+function renderConsoleParameter(parameter) {
+	const type = schemaType(asRecord(parameter.schema));
+	const value = parameterExample(parameter);
+	const common = `name="parameter" data-param-name="${escapeAttribute(parameter.name)}" data-param-location="${escapeAttribute(parameter.in)}" data-param-array="${type === "array" ? "true" : "false"}"${parameter.required ? " required" : ""}`;
+	const control = type === "boolean" ? `<select ${common}><option value="">Select…</option><option value="true"${value === true ? " selected" : ""}>true</option><option value="false"${value === false ? " selected" : ""}>false</option></select>` : `<input ${common} type="${type === "number" || type === "integer" ? "number" : "text"}"${value !== void 0 ? ` value="${escapeAttribute(formatInputValue(value))}"` : ""} placeholder="${escapeAttribute(parameterPlaceholder(parameter, type))}" spellcheck="false" autocomplete="off" />`;
+	return `<label class="fl-api-field">
+    <span><code>${escapeHtml(parameter.name)}</code> <small>${escapeHtml(parameter.in)}</small>${parameter.required ? " <em>required</em>" : ""}</span>
+    ${control}
+    ${parameter.description ? `<small class="fl-api-field-help">${escapeHtml(parameter.description)}</small>` : ""}
+  </label>`;
+}
+function renderConsoleAuthentication(operation) {
+	const schemes = Object.entries(operation.securitySchemes);
+	if (operation.security.length === 0 || schemes.length === 0) return "";
+	return `<fieldset class="fl-api-console-group">
+    <legend>Authentication</legend>
+    ${schemes.map(([name, scheme]) => renderConsoleSecurityScheme(name, scheme)).join("")}
+    <p class="fl-api-console-hint">Authentication values are used only for this request and are not persisted.</p>
+  </fieldset>`;
+}
+function renderConsoleSecurityScheme(name, value) {
+	const scheme = asRecord(value) ?? {};
+	const type = typeof scheme.type === "string" ? scheme.type.toLocaleLowerCase() : "";
+	const httpScheme = typeof scheme.scheme === "string" ? scheme.scheme.toLocaleLowerCase() : "";
+	const location = typeof scheme.in === "string" ? scheme.in : "header";
+	const parameterName = typeof scheme.name === "string" ? scheme.name : name;
+	if (type === "http" && httpScheme === "basic") return `<div class="fl-api-auth-pair" data-auth-basic>
+      <label class="fl-api-field"><span>${escapeHtml(name)} username</span><input type="text" data-auth-username autocomplete="username" /></label>
+      <label class="fl-api-field"><span>${escapeHtml(name)} password</span><input type="password" data-auth-password autocomplete="current-password" /></label>
+    </div>`;
+	if (type === "apikey") {
+		if (location === "cookie") return `<p class="fl-api-console-hint"><strong>${escapeHtml(name)}</strong> uses the browser-managed <code>${escapeHtml(parameterName)}</code> cookie. Choose <strong>Include cookies</strong> below.</p>`;
+		return `<label class="fl-api-field">
+      <span>${escapeHtml(name)} <small>${escapeHtml(location)} · ${escapeHtml(parameterName)}</small></span>
+      <input type="password" data-auth-api-key data-auth-location="${escapeAttribute(location)}" data-auth-name="${escapeAttribute(parameterName)}" autocomplete="off" />
+    </label>`;
+	}
+	const tokenPrefix = type === "http" && httpScheme && httpScheme !== "bearer" ? httpScheme : "Bearer";
+	return `<label class="fl-api-field">
+    <span>${escapeHtml(name)} token</span>
+    <input type="password" data-auth-token data-auth-prefix="${escapeAttribute(tokenPrefix)}" autocomplete="off" placeholder="Paste access token" />
+  </label>`;
+}
+function renderConsoleRequestBody(content, required, bodyExample) {
+	const mediaTypes = content.length > 0 ? content : [{
+		mediaType: "application/json",
+		examples: []
+	}];
+	return `<fieldset class="fl-api-console-group">
+    <legend>Request body${required ? " · required" : ""}</legend>
+    <label class="fl-api-field fl-api-field--inline">
+      <span>Content type</span>
+      <select name="content-type">
+        ${mediaTypes.map((media) => `<option value="${escapeAttribute(media.mediaType)}">${escapeHtml(media.mediaType)}</option>`).join("")}
+      </select>
+    </label>
+    <label class="fl-api-field">
+      <span>Body${required ? " <em>required</em>" : ""}</span>
+      <textarea name="request-body" rows="8"${required ? " required" : ""} spellcheck="false" placeholder="Request body">${bodyExample === void 0 ? "" : escapeHtml(formatRequestBody(bodyExample, mediaTypes[0]?.mediaType))}</textarea>
+    </label>
+  </fieldset>`;
+}
+function renderParameters(parameters) {
+	if (parameters.length === 0) return "";
+	return `<section class="fl-api-section">
+    <h3>Parameters <span>${parameters.length}</span></h3>
+    <div class="fl-api-table-wrap">
+      <table>
+        <thead><tr><th scope="col">Name</th><th scope="col">Location</th><th scope="col">Type</th><th scope="col">Description</th></tr></thead>
+        <tbody>
+          ${parameters.map(renderParameter).join("")}
+        </tbody>
+      </table>
+    </div>
+  </section>`;
+}
+function renderParameter(parameter) {
+	return `<tr>
+    <td><code>${escapeHtml(parameter.name)}</code>${parameter.required ? "<span class=\"fl-api-required\">required</span>" : ""}</td>
+    <td><span class="fl-api-chip">${escapeHtml(parameter.in)}</span></td>
+    <td><code>${escapeHtml(schemaLabel(parameter.schema))}</code></td>
+    <td>${parameter.description ? renderText(parameter.description) : "<span class=\"fl-api-muted\">—</span>"}</td>
+  </tr>`;
+}
+function renderRequestBody(content, required, description) {
+	if (content.length === 0 && !description) return "";
+	return `<section class="fl-api-section">
+    <h3>Request body ${required ? "<span class=\"fl-api-required\">required</span>" : ""}</h3>
+    ${description ? `<div class="fl-api-description">${renderText(description)}</div>` : ""}
+    ${content.map((media) => renderMediaType(media, "Request schema")).join("")}
+  </section>`;
+}
+function renderResponses(responses) {
+	if (responses.length === 0) return `<section class="fl-api-section"><h3>Responses</h3><p class="fl-api-muted">No responses are documented.</p></section>`;
+	return `<section class="fl-api-section">
+    <h3>Responses <span>${responses.length}</span></h3>
+    <div class="fl-api-response-list">
+      ${responses.map(renderResponse).join("")}
+    </div>
+  </section>`;
+}
+function renderResponse(response) {
+	return `<details class="fl-api-response"${response.status.startsWith("2") ? " open" : ""}>
+    <summary>
+      <code>${escapeHtml(response.status)}</code>
+      <span>${escapeHtml(response.description ?? "Response")}</span>
+      ${chevronIcon()}
+    </summary>
+    <div class="fl-api-response-content">
+      ${response.content.length > 0 ? response.content.map((media) => renderMediaType(media, "Response schema")).join("") : "<p class=\"fl-api-muted\">No response body.</p>"}
+    </div>
+  </details>`;
+}
+function renderMediaType(media, label) {
+	const schema = media.schema === void 0 ? void 0 : safeJson(media.schema);
+	const example = media.examples.find((entry) => entry.value !== void 0);
+	return `<div class="fl-api-media">
+    <div class="fl-api-media-heading"><span class="fl-api-chip">${escapeHtml(media.mediaType)}</span></div>
+    ${schema ? renderCodeDisclosure(label, schema) : ""}
+    ${example?.value !== void 0 ? renderCodeDisclosure(example.summary ?? "Example", safeJson(example.value)) : ""}
+  </div>`;
+}
+function renderCodeDisclosure(label, value) {
+	return `<details class="fl-api-schema">
+    <summary>${escapeHtml(label)}${chevronIcon()}</summary>
+    <div class="fl-api-schema-code">
+      <button type="button" class="fl-api-copy" data-copy="${escapeAttribute(value)}" aria-label="Copy ${escapeAttribute(label)}">Copy</button>
+      <pre><code>${escapeHtml(value)}</code></pre>
+    </div>
+  </details>`;
+}
+function renderSecurity(operation) {
+	if (operation.security.length === 0) return "";
+	return `<section class="fl-api-section">
+    <h3>Authentication</h3>
+    <div class="fl-api-chip-row">${Array.from(new Set(operation.security.flatMap((requirement) => Object.keys(requirement)))).map((name) => `<span class="fl-api-chip">${lockIcon()}${escapeHtml(name)}</span>`).join("")}</div>
+  </section>`;
+}
+function renderServers(servers) {
+	if (servers.length === 0) return "";
+	return `<div class="fl-api-servers">
+    <span>Server</span>
+    <code>${escapeHtml(servers[0] ?? "")}</code>
+    <button type="button" class="fl-api-copy" data-copy="${escapeAttribute(servers[0] ?? "")}" aria-label="Copy server URL">Copy</button>
+  </div>`;
+}
+function renderEmptyContract() {
+	return `<div class="fl-api-empty">
+    <strong>No operations found.</strong>
+    <span>Add paths and operations to the OpenAPI contract, then refresh this reference.</span>
+  </div>`;
+}
+function groupOperations(operations) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const operation of operations) {
+		const tag = operation.tags[0] ?? "General";
+		const group = groups.get(tag) ?? [];
+		group.push(operation);
+		groups.set(tag, group);
+	}
+	return Array.from(groups.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([tag, grouped]) => ({
+		tag,
+		operations: grouped.sort((left, right) => left.title.localeCompare(right.title))
+	}));
+}
+function buildCurlExample(operation, modelServers) {
+	const target = shellQuote(`${(operation.servers[0] ?? modelServers[0] ?? "https://api.example.com").replace(/\/$/, "")}${operation.path}`);
+	const parts = [`curl --request ${operation.method}`, `  --url ${target}`];
+	const contentType = operation.requestBody?.content[0]?.mediaType;
+	if (contentType) parts.push(`  --header ${shellQuote(`Content-Type: ${contentType}`)}`);
+	const example = operation.requestBody?.content.flatMap((entry) => entry.examples).find((entry) => entry.value !== void 0)?.value;
+	if (operation.requestBody) parts.push(`  --data ${shellQuote(example === void 0 ? "{}" : safeJson(example))}`);
+	return parts.join(" \\\n");
+}
+function mediaTypeExample(media) {
+	const example = media.examples.find((entry) => entry.value !== void 0)?.value;
+	return example === void 0 ? schemaExample(media.schema) : example;
+}
+function parameterExample(parameter) {
+	const example = parameter.examples.find((entry) => entry.value !== void 0)?.value;
+	if (example !== void 0) return example;
+	const schema = asRecord(parameter.schema);
+	if (!schema) return void 0;
+	if (Object.hasOwn(schema, "example")) return schema.example;
+	if (Object.hasOwn(schema, "default")) return schema.default;
+	if (Object.hasOwn(schema, "const")) return schema.const;
+	return Array.isArray(schema.enum) ? schema.enum[0] : void 0;
+}
+function schemaExample(schema, depth = 0) {
+	if (depth > 5) return void 0;
+	const record = asRecord(schema);
+	if (!record) return void 0;
+	if (Object.hasOwn(record, "example")) return record.example;
+	if (Object.hasOwn(record, "default")) return record.default;
+	if (Object.hasOwn(record, "const")) return record.const;
+	if (Array.isArray(record.enum) && record.enum.length > 0) return record.enum[0];
+	const composed = [
+		record.oneOf,
+		record.anyOf,
+		record.allOf
+	].find((value) => Array.isArray(value) && value.length > 0);
+	if (Array.isArray(composed)) return schemaExample(composed[0], depth + 1);
+	const type = schemaType(record);
+	if (type === "array") {
+		const item = schemaExample(record.items, depth + 1);
+		return item === void 0 ? [] : [item];
+	}
+	if (type === "object" || asRecord(record.properties)) {
+		const properties = asRecord(record.properties) ?? {};
+		return Object.fromEntries(Object.entries(properties).map(([name, value]) => [name, schemaExample(value, depth + 1) ?? placeholderSchemaValue(value)]));
+	}
+	return placeholderSchemaValue(record);
+}
+function placeholderSchemaValue(schema) {
+	const type = schemaType(asRecord(schema));
+	if (type === "string") return "string";
+	if (type === "number" || type === "integer") return 0;
+	if (type === "boolean") return false;
+	if (type === "array") return [];
+	if (type === "object") return {};
+}
+function schemaType(schema) {
+	if (!schema) return "string";
+	if (typeof schema.type === "string") return schema.type;
+	if (Array.isArray(schema.type)) return schema.type.find((entry) => typeof entry === "string" && entry !== "null") ?? "string";
+	if (schema.items !== void 0) return "array";
+	if (schema.properties !== void 0 || schema.additionalProperties !== void 0) return "object";
+	return "string";
+}
+function parameterPlaceholder(parameter, type) {
+	if (type === "array") return "Comma-separated values";
+	if (parameter.in === "path") return parameter.name;
+	return `Optional ${type}`;
+}
+function formatInputValue(value) {
+	if (Array.isArray(value)) return value.map((entry) => String(entry)).join(", ");
+	if (value && typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+function formatRequestBody(value, mediaType) {
+	if (typeof value === "string" && !isJsonMediaType(mediaType)) return value;
+	return safeJson(value);
+}
+function isJsonMediaType(mediaType) {
+	const normalized = mediaType?.toLocaleLowerCase() ?? "";
+	return normalized.includes("json") || normalized.includes("+json");
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function operationSearchText(operation) {
+	return [
+		operation.method,
+		operation.path,
+		operation.title,
+		operation.summary,
+		operation.description,
+		operation.operationId,
+		...operation.tags
+	].filter(Boolean).join(" ").toLocaleLowerCase();
+}
+function schemaLabel(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return "any";
+	const record = schema;
+	if (typeof record.type === "string") {
+		if (record.type === "array") return `${schemaLabel(record.items)}[]`;
+		return record.type;
+	}
+	if (Array.isArray(record.type)) return record.type.join(" | ");
+	if (Array.isArray(record.enum)) return "enum";
+	return "object";
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value, null, 2) ?? "null";
+	} catch {
+		return "[unserializable value]";
+	}
+}
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function renderText(value) {
+	return value.split(/\n{2,}/).map((paragraph) => `<p>${escapeHtml(paragraph).replaceAll("\n", "<br />")}</p>`).join("");
+}
+function methodTone(method) {
+	return METHOD_TONES[method] ?? "neutral";
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function escapeAttribute(value) {
+	return escapeHtml(value).replaceAll("`", "&#96;");
+}
+function resolveTokens(theme) {
+	const colors = theme?.ui?.colors;
+	const typography = theme?.ui?.typography?.font?.style;
+	const background = colors?.background ?? "#ffffff";
+	const foreground = colors?.foreground ?? (looksDark(background, theme?.name) ? "#f5f5f4" : "#18181b");
+	const primary = colors?.primary ?? "#4f46e5";
+	return {
+		primary,
+		primaryForeground: colors?.primaryForeground ?? (looksDark(primary) ? "#ffffff" : "#111113"),
+		background,
+		card: colors?.card ?? background,
+		foreground,
+		muted: colors?.muted ?? (looksDark(background, theme?.name) ? "#a1a1aa" : "#62626d"),
+		border: colors?.border ?? (looksDark(background, theme?.name) ? "#2d2d33" : "#dedee3"),
+		radius: theme?.ui?.radius ?? "8px",
+		sans: typography?.sans ?? "\"Geist\", \"Inter\", ui-sans-serif, system-ui, sans-serif",
+		mono: typography?.mono ?? "\"Geist Mono\", \"SFMono-Regular\", Menlo, monospace",
+		customPalette: Boolean(colors)
+	};
+}
+function looksDark(color, name) {
+	if (name?.toLocaleLowerCase().includes("dark")) return true;
+	const match = /^#([\da-f]{6})$/i.exec(color.trim());
+	if (!match?.[1]) return false;
+	const red = Number.parseInt(match[1].slice(0, 2), 16);
+	const green = Number.parseInt(match[1].slice(2, 4), 16);
+	const blue = Number.parseInt(match[1].slice(4, 6), 16);
+	return (red * 299 + green * 587 + blue * 114) / 1e3 < 128;
+}
+function buildStyles(tokens) {
+	const automaticDark = tokens.customPalette ? "" : `@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) { --fl-bg: #0b0b0d; --fl-card: #111114; --fl-fg: #f4f4f5; --fl-muted: #a1a1aa; --fl-border: #2b2b31; --fl-soft: #18181d; }
+}`;
+	return `
+:root { color-scheme: light; --fl-primary: ${tokens.primary}; --fl-primary-fg: ${tokens.primaryForeground}; --fl-bg: ${tokens.background}; --fl-card: ${tokens.card}; --fl-fg: ${tokens.foreground}; --fl-muted: ${tokens.muted}; --fl-border: ${tokens.border}; --fl-soft: color-mix(in srgb, var(--fl-card) 92%, var(--fl-fg) 8%); --fl-radius: ${tokens.radius}; --fl-sans: ${tokens.sans}; --fl-mono: ${tokens.mono}; }
+:root[data-theme="light"] { color-scheme: light; }
+:root[data-theme="dark"] { color-scheme: dark; --fl-bg: #0b0b0d; --fl-card: #111114; --fl-fg: #f4f4f5; --fl-muted: #a1a1aa; --fl-border: #2b2b31; --fl-soft: #18181d; }
+${automaticDark}
+* { box-sizing: border-box; }
+html { scroll-behavior: smooth; scroll-padding-top: 88px; }
+body { margin: 0; background: var(--fl-bg); color: var(--fl-fg); font: 15px/1.6 var(--fl-sans); }
+button, input, select { font: inherit; }
+button, a, input, select { -webkit-tap-highlight-color: transparent; }
+a { color: inherit; }
+code, pre, kbd { font-family: var(--fl-mono); }
+.fl-skip-link { position: fixed; z-index: 100; top: 8px; left: 8px; transform: translateY(-150%); background: var(--fl-fg); color: var(--fl-bg); padding: 8px 12px; }
+.fl-skip-link:focus { transform: translateY(0); }
+.fl-api-shell { min-height: 100vh; }
+.fl-api-topbar { position: sticky; z-index: 20; top: 0; min-height: 58px; display: flex; align-items: center; justify-content: space-between; gap: 16px; padding: 8px 20px; border-bottom: 1px solid var(--fl-border); background: color-mix(in srgb, var(--fl-bg) 94%, transparent); backdrop-filter: blur(12px); }
+.fl-api-brand { display: inline-flex; align-items: center; gap: 10px; text-decoration: none; font-weight: 650; }
+.fl-api-brand-mark { display: grid; place-items: center; width: 28px; height: 28px; border: 1px solid var(--fl-fg); font: 700 10px/1 var(--fl-mono); letter-spacing: -.04em; }
+.fl-api-topbar-actions, .fl-api-version-control { display: flex; align-items: center; gap: 8px; }
+.fl-api-version-control > span { color: var(--fl-muted); font: 11px/1 var(--fl-mono); text-transform: uppercase; letter-spacing: .08em; }
+.fl-api-version-control select, .fl-api-action, .fl-api-icon-button { min-height: 34px; border: 1px solid var(--fl-border); border-radius: calc(var(--fl-radius) * .65); background: var(--fl-card); color: var(--fl-fg); }
+.fl-api-version-control select { padding: 0 28px 0 10px; }
+.fl-api-action { display: inline-flex; align-items: center; padding: 0 11px; text-decoration: none; font: 12px/1 var(--fl-mono); }
+.fl-api-icon-button { width: 34px; display: grid; place-items: center; cursor: pointer; }
+.fl-api-icon-button svg, .fl-api-search-wrap svg, .fl-api-chip svg { width: 15px; height: 15px; }
+.fl-api-layout { display: grid; grid-template-columns: minmax(240px, 292px) minmax(0, 1fr); }
+.fl-api-sidebar { position: sticky; top: 59px; height: calc(100vh - 59px); overflow: auto; padding: 20px 16px 32px; border-right: 1px solid var(--fl-border); }
+.fl-api-sidebar-heading { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 18px; color: var(--fl-muted); font-size: 12px; }
+.fl-api-eyebrow { color: var(--fl-muted); font: 11px/1.3 var(--fl-mono); letter-spacing: .08em; text-transform: uppercase; }
+.fl-api-search-label { display: block; margin-bottom: 7px; color: var(--fl-muted); font-size: 12px; }
+.fl-api-search-wrap { display: grid; grid-template-columns: 18px 1fr auto; align-items: center; gap: 7px; height: 38px; padding: 0 10px; border: 1px solid var(--fl-border); border-radius: var(--fl-radius); background: var(--fl-card); }
+.fl-api-search { width: 100%; border: 0; outline: 0; background: transparent; color: var(--fl-fg); }
+.fl-api-search::placeholder { color: var(--fl-muted); }
+.fl-api-search-wrap:focus-within { border-color: var(--fl-primary); box-shadow: 0 0 0 3px color-mix(in srgb, var(--fl-primary) 18%, transparent); }
+.fl-api-search-wrap kbd { padding: 2px 5px; border: 1px solid var(--fl-border); color: var(--fl-muted); font-size: 10px; }
+.fl-api-search-status { min-height: 18px; margin: 7px 0 0; color: var(--fl-muted); font-size: 11px; }
+.fl-api-nav-group { margin-top: 22px; }
+.fl-api-nav-group[hidden] { display: none; }
+.fl-api-nav-group h2 { margin: 0 8px 8px; color: var(--fl-muted); font: 600 11px/1.3 var(--fl-mono); letter-spacing: .08em; text-transform: uppercase; }
+.fl-api-nav-group ul { display: grid; gap: 2px; margin: 0; padding: 0; list-style: none; }
+.fl-api-nav-group a { display: grid; grid-template-columns: 46px minmax(0, 1fr); align-items: center; gap: 8px; min-height: 36px; padding: 6px 8px; border-left: 2px solid transparent; text-decoration: none; font-size: 13px; }
+.fl-api-nav-group a:hover, .fl-api-nav-group a:focus-visible { border-left-color: var(--fl-primary); background: var(--fl-soft); outline: none; }
+.fl-api-nav-group a span:last-child { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.fl-api-method { display: inline-flex; align-items: center; justify-content: center; min-width: 46px; height: 22px; padding: 0 6px; border: 1px solid currentColor; border-radius: calc(var(--fl-radius) * .5); font: 700 10px/1 var(--fl-mono); letter-spacing: .04em; }
+.fl-api-method--success { color: #16803d; }.fl-api-method--info { color: #2563eb; }.fl-api-method--warning { color: #b45309; }.fl-api-method--danger { color: #dc2626; }.fl-api-method--neutral { color: var(--fl-muted); }
+.fl-api-content { min-width: 0; }
+.fl-api-hero { padding: clamp(32px, 6vw, 76px) clamp(22px, 6vw, 82px) 44px; border-bottom: 1px solid var(--fl-border); }
+.fl-api-hero-copy { max-width: 780px; }
+.fl-api-hero h1 { max-width: 18ch; margin: 10px 0 12px; font-size: clamp(34px, 5vw, 64px); line-height: 1.02; letter-spacing: -.045em; }
+.fl-api-description { max-width: 76ch; color: var(--fl-muted); }
+.fl-api-description p { margin: 0 0 8px; }
+.fl-api-summary { display: flex; flex-wrap: wrap; gap: 1px; margin: 30px 0 0; }
+.fl-api-summary div { min-width: 120px; padding: 12px 16px; border: 1px solid var(--fl-border); background: var(--fl-card); }
+.fl-api-summary dt { color: var(--fl-muted); font: 10px/1.3 var(--fl-mono); text-transform: uppercase; letter-spacing: .08em; }
+.fl-api-summary dd { margin: 4px 0 0; font: 650 20px/1.2 var(--fl-mono); }
+.fl-api-servers { display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; max-width: 780px; margin-top: 18px; border: 1px solid var(--fl-border); background: var(--fl-soft); }
+.fl-api-servers > span { padding: 9px 12px; border-right: 1px solid var(--fl-border); color: var(--fl-muted); font: 10px/1 var(--fl-mono); text-transform: uppercase; }
+.fl-api-servers code { overflow: auto; padding: 9px 12px; font-size: 12px; white-space: nowrap; }
+.fl-api-copy { min-width: 54px; align-self: stretch; padding: 7px 10px; border: 0; border-left: 1px solid var(--fl-border); background: transparent; color: var(--fl-muted); cursor: pointer; font: 11px/1 var(--fl-mono); }
+.fl-api-copy:hover, .fl-api-copy:focus-visible { background: var(--fl-card); color: var(--fl-fg); outline: 2px solid var(--fl-primary); outline-offset: -2px; }
+.fl-api-operations { padding: 0 clamp(22px, 5vw, 72px) 80px; }
+.fl-api-operation { padding: clamp(36px, 6vw, 72px) 0; border-bottom: 1px solid var(--fl-border); scroll-margin-top: 76px; }
+.fl-api-operation[hidden] { display: none; }
+.fl-api-operation-header { max-width: 900px; }
+.fl-api-operation-meta { display: flex; align-items: center; flex-wrap: wrap; gap: 9px; }
+.fl-api-operation-meta > code { overflow-wrap: anywhere; color: var(--fl-fg); font-size: 13px; }
+.fl-api-operation h2 { margin: 15px 0 7px; font-size: clamp(25px, 3vw, 38px); line-height: 1.15; letter-spacing: -.025em; }
+.fl-api-summary-copy { margin: 0 0 8px; font-weight: 520; }
+.fl-api-operation-links { display: flex; align-items: center; flex-wrap: wrap; gap: 12px; margin-top: 18px; font: 11px/1.4 var(--fl-mono); }
+.fl-api-operation-links a { text-decoration: underline; text-decoration-style: dotted; text-underline-offset: 3px; }
+.fl-api-operation-links code { color: var(--fl-muted); }
+.fl-api-operation-grid { display: grid; grid-template-columns: minmax(0, 1.12fr) minmax(300px, .88fr); gap: clamp(24px, 5vw, 60px); margin-top: 30px; align-items: start; }
+.fl-api-operation-details { min-width: 0; }
+.fl-api-section { padding: 24px 0; border-top: 1px solid var(--fl-border); }
+.fl-api-section h3 { display: flex; align-items: center; gap: 8px; margin: 0 0 14px; font-size: 15px; }
+.fl-api-section h3 > span { color: var(--fl-muted); font: 11px/1 var(--fl-mono); }
+.fl-api-table-wrap { overflow-x: auto; border: 1px solid var(--fl-border); }
+table { width: 100%; min-width: 620px; border-collapse: collapse; font-size: 13px; }
+th, td { padding: 11px 12px; border-bottom: 1px solid var(--fl-border); text-align: left; vertical-align: top; }
+th { background: var(--fl-soft); color: var(--fl-muted); font: 10px/1.3 var(--fl-mono); text-transform: uppercase; letter-spacing: .06em; }
+tbody tr:last-child td { border-bottom: 0; }
+td code { font-size: 12px; }
+.fl-api-required { display: inline-block; margin-left: 7px; color: #dc2626; font: 9px/1 var(--fl-mono); text-transform: uppercase; }
+.fl-api-chip-row { display: flex; flex-wrap: wrap; gap: 7px; }
+.fl-api-chip { display: inline-flex; align-items: center; gap: 5px; padding: 4px 7px; border: 1px solid var(--fl-border); border-radius: calc(var(--fl-radius) * .5); background: var(--fl-soft); color: var(--fl-muted); font: 10px/1 var(--fl-mono); }
+.fl-api-chip--danger { color: #dc2626; }
+.fl-api-code-panel { position: sticky; top: 84px; overflow: hidden; border: 1px solid var(--fl-border); border-radius: var(--fl-radius); background: #0c0c0f; color: #f4f4f5; }
+.fl-api-code-header { min-height: 38px; display: flex; align-items: center; justify-content: space-between; border-bottom: 1px solid #29292f; color: #a1a1aa; font: 10px/1 var(--fl-mono); text-transform: uppercase; letter-spacing: .08em; }
+.fl-api-code-tabs { align-self: stretch; display: flex; align-items: stretch; }
+.fl-api-code-tabs button { position: relative; min-width: 70px; padding: 0 12px; border: 0; border-right: 1px solid #29292f; background: transparent; color: #a1a1aa; cursor: pointer; font: inherit; letter-spacing: inherit; text-transform: inherit; }
+.fl-api-code-tabs button[aria-selected="true"] { background: #151519; color: #f4f4f5; }
+.fl-api-code-tabs button[aria-selected="true"]::after { content: ""; position: absolute; right: 10px; bottom: -1px; left: 10px; height: 2px; background: var(--fl-primary); }
+.fl-api-code-tabs button:hover, .fl-api-code-tabs button:focus-visible { color: #f4f4f5; outline: 2px solid var(--fl-primary); outline-offset: -2px; }
+.fl-api-code-panel .fl-api-copy { color: #a1a1aa; border-left-color: #29292f; }
+.fl-api-code-panel pre, .fl-api-schema pre { margin: 0; overflow: auto; padding: 16px; font-size: 12px; line-height: 1.7; }
+.fl-api-console { display: grid; gap: 16px; max-height: min(76vh, 780px); overflow-y: auto; padding: 16px; background: #0c0c0f; color: #f4f4f5; }
+.fl-api-console-intro, .fl-api-console-response-header, .fl-api-console-actions { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+.fl-api-console-intro > div { min-width: 0; display: grid; gap: 5px; }
+.fl-api-console-intro strong { overflow-wrap: anywhere; font: 600 12px/1.45 var(--fl-mono); }
+.fl-api-console-kicker, .fl-api-console-group legend { color: #a1a1aa; font: 10px/1.3 var(--fl-mono); text-transform: uppercase; letter-spacing: .08em; }
+.fl-api-console-state { flex: 0 0 auto; padding: 4px 7px; border: 1px solid #3f3f46; color: #a1a1aa; font: 10px/1 var(--fl-mono); }
+.fl-api-console-state[data-state="sending"] { border-color: #6366f1; color: #a5b4fc; }
+.fl-api-console-state[data-state="success"] { border-color: #22c55e; color: #86efac; }
+.fl-api-console-state[data-state="error"] { border-color: #ef4444; color: #fca5a5; }
+.fl-api-console-group { display: grid; gap: 12px; min-width: 0; margin: 0; padding: 14px; border: 1px solid #29292f; }
+.fl-api-console-group legend { padding: 0 6px; }
+.fl-api-field { display: grid; gap: 6px; min-width: 0; color: #d4d4d8; font: 11px/1.35 var(--fl-mono); }
+.fl-api-field > span { display: flex; flex-wrap: wrap; align-items: baseline; gap: 5px; }
+.fl-api-field > span small { color: #71717a; font-size: 9px; text-transform: uppercase; }
+.fl-api-field em { color: #fca5a5; font-size: 9px; font-style: normal; text-transform: uppercase; }
+.fl-api-field input, .fl-api-field select, .fl-api-field textarea { width: 100%; min-width: 0; border: 1px solid #3f3f46; border-radius: calc(var(--fl-radius) * .55); background: #151519; color: #f4f4f5; font: 12px/1.45 var(--fl-mono); }
+.fl-api-field input, .fl-api-field select { height: 36px; padding: 0 10px; }
+.fl-api-field textarea { resize: vertical; min-height: 112px; padding: 10px; tab-size: 2; }
+.fl-api-field input::placeholder, .fl-api-field textarea::placeholder { color: #71717a; }
+.fl-api-field input:focus, .fl-api-field select:focus, .fl-api-field textarea:focus { border-color: #818cf8; outline: 2px solid color-mix(in srgb, #6366f1 45%, transparent); outline-offset: 0; }
+.fl-api-field--inline { grid-template-columns: minmax(120px, .7fr) minmax(0, 1fr); align-items: center; }
+.fl-api-field-help, .fl-api-console-hint, .fl-api-console-note { color: #a1a1aa; font-size: 10px; line-height: 1.5; }
+.fl-api-console-hint, .fl-api-console-note { margin: 0; }
+.fl-api-console-hint code { color: #d4d4d8; }
+.fl-api-auth-pair { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+.fl-api-console-confirm { display: flex; align-items: flex-start; gap: 8px; color: #fcd34d; font: 10px/1.45 var(--fl-mono); }
+.fl-api-console-confirm input { margin: 1px 0 0; accent-color: #6366f1; }
+.fl-api-console-actions { justify-content: flex-start; min-height: 36px; }
+.fl-api-console-actions button { min-height: 34px; padding: 0 12px; border: 1px solid #3f3f46; border-radius: calc(var(--fl-radius) * .55); cursor: pointer; font: 600 11px/1 var(--fl-mono); }
+.fl-api-console-send { background: var(--fl-primary); color: var(--fl-primary-fg); border-color: var(--fl-primary) !important; }
+.fl-api-console-send:hover:not(:disabled), .fl-api-console-send:focus-visible { filter: brightness(1.08); outline: 2px solid #a5b4fc; outline-offset: 2px; }
+.fl-api-console-send:disabled { cursor: not-allowed; opacity: .45; }
+.fl-api-console-cancel { background: transparent; color: #d4d4d8; }
+.fl-api-console-actions > span { color: #a1a1aa; font: 10px/1.4 var(--fl-mono); }
+.fl-api-console-error { padding: 10px 12px; border: 1px solid #7f1d1d; background: #2a1013; color: #fecaca; font: 11px/1.5 var(--fl-mono); }
+.fl-api-console-response { min-width: 0; border: 1px solid #3f3f46; outline: none; }
+.fl-api-console-response:focus-visible { border-color: #818cf8; box-shadow: 0 0 0 2px #6366f1; }
+.fl-api-console-response-header { min-height: 38px; border-bottom: 1px solid #29292f; }
+.fl-api-console-response-header > div { display: flex; align-items: center; gap: 8px; padding-left: 11px; color: #a1a1aa; font: 10px/1 var(--fl-mono); }
+.fl-api-console-status { color: #86efac; font-weight: 700; }
+.fl-api-console-status[data-ok="false"] { color: #fca5a5; }
+.fl-api-console-response-meta { display: grid; gap: 4px; padding: 9px 11px; border-bottom: 1px solid #29292f; color: #a1a1aa; font: 9px/1.4 var(--fl-mono); }
+.fl-api-console-response-meta code { overflow: hidden; color: #d4d4d8; text-overflow: ellipsis; white-space: nowrap; }
+.fl-api-console-response-headers { border-bottom: 1px solid #29292f; }
+.fl-api-console-response-headers summary { display: flex; align-items: center; justify-content: space-between; padding: 9px 11px; color: #a1a1aa; cursor: pointer; font: 10px/1.3 var(--fl-mono); list-style: none; }
+.fl-api-console-response-headers summary::-webkit-details-marker { display: none; }
+.fl-api-console-response-headers summary svg { width: 14px; transition: transform .15s ease; }
+.fl-api-console-response-headers[open] summary svg { transform: rotate(180deg); }
+.fl-api-console-response-headers pre { max-height: 180px; padding: 11px; border-top: 1px solid #29292f; color: #d4d4d8; }
+.fl-api-console-response-body { max-height: 340px; min-height: 72px; color: #f4f4f5; white-space: pre-wrap; overflow-wrap: anywhere; }
+.fl-api-console-note { padding-top: 2px; border-top: 1px solid #29292f; }
+.fl-api-response-list { display: grid; border: 1px solid var(--fl-border); }
+.fl-api-response + .fl-api-response { border-top: 1px solid var(--fl-border); }
+.fl-api-response > summary, .fl-api-schema > summary { display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: 10px; padding: 11px 12px; cursor: pointer; list-style: none; }
+.fl-api-response > summary::-webkit-details-marker, .fl-api-schema > summary::-webkit-details-marker { display: none; }
+.fl-api-response > summary:hover, .fl-api-schema > summary:hover { background: var(--fl-soft); }
+.fl-api-response > summary svg, .fl-api-schema > summary svg { width: 14px; transition: transform .15s ease; }
+.fl-api-response[open] > summary svg, .fl-api-schema[open] > summary svg { transform: rotate(180deg); }
+.fl-api-response-content { padding: 0 12px 12px; }
+.fl-api-media + .fl-api-media { margin-top: 12px; }
+.fl-api-media-heading { margin: 10px 0 8px; }
+.fl-api-schema { overflow: hidden; margin-top: 8px; border: 1px solid var(--fl-border); border-radius: calc(var(--fl-radius) * .7); }
+.fl-api-schema > summary { grid-template-columns: minmax(0, 1fr) auto; font: 11px/1.4 var(--fl-mono); }
+.fl-api-schema-code { position: relative; border-top: 1px solid var(--fl-border); background: #0c0c0f; color: #f4f4f5; }
+.fl-api-schema-code .fl-api-copy { position: absolute; z-index: 1; top: 0; right: 0; height: 34px; color: #a1a1aa; border: 1px solid #29292f; border-top: 0; border-right: 0; background: #0c0c0f; }
+.fl-api-muted { color: var(--fl-muted); }
+.fl-api-empty, .fl-api-no-results { display: grid; gap: 6px; padding: 32px; border: 1px dashed var(--fl-border); color: var(--fl-muted); }
+.fl-api-empty strong, .fl-api-no-results strong { color: var(--fl-fg); }
+.fl-api-no-results { margin-top: 48px; }
+.fl-api-sidebar-empty { color: var(--fl-muted); font-size: 13px; }
+.fl-api-live-region { position: fixed; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); }
+:focus-visible { outline: 2px solid var(--fl-primary); outline-offset: 2px; }
+@media (max-width: 980px) { .fl-api-layout { grid-template-columns: 230px minmax(0, 1fr); } .fl-api-operation-grid { grid-template-columns: 1fr; } .fl-api-code-panel { position: relative; top: 0; } }
+@media (max-width: 720px) { .fl-api-topbar { padding-inline: 12px; } .fl-api-brand > span:last-child, .fl-api-version-control > span, .fl-api-action { display: none; } .fl-api-layout { display: block; } .fl-api-sidebar { position: relative; top: 0; width: 100%; height: auto; max-height: 52vh; border-right: 0; border-bottom: 1px solid var(--fl-border); } .fl-api-hero { padding: 32px 18px; } .fl-api-operations { padding-inline: 18px; } .fl-api-operation-grid { gap: 22px; } .fl-api-servers { grid-template-columns: auto minmax(0, 1fr); } .fl-api-servers .fl-api-copy { display: none; } .fl-api-field--inline, .fl-api-auth-pair { grid-template-columns: 1fr; } .fl-api-console { max-height: none; } }
+@media (prefers-reduced-motion: reduce) { html { scroll-behavior: auto; } *, *::before, *::after { transition-duration: .01ms !important; animation-duration: .01ms !important; } }
+`;
+}
+function buildClientScript() {
+	return `(() => {
+  const root = document.documentElement;
+  const search = document.querySelector('[data-search-status]');
+  const input = document.getElementById('fl-api-search');
+  const operations = Array.from(document.querySelectorAll('[data-operation]'));
+  const navItems = Array.from(document.querySelectorAll('[data-nav-operation]'));
+  const groups = Array.from(document.querySelectorAll('[data-nav-group]'));
+  const noResults = document.querySelector('[data-no-results]');
+  const copyStatus = document.querySelector('[data-copy-status]');
+  const applySearch = () => {
+    const query = (input?.value || '').trim().toLocaleLowerCase();
+    let visible = 0;
+    for (const operation of operations) {
+      const match = !query || (operation.dataset.search || '').includes(query);
+      operation.hidden = !match;
+      if (match) visible += 1;
+    }
+    for (const item of navItems) item.hidden = Boolean(query) && !(item.dataset.search || '').includes(query);
+    for (const group of groups) group.hidden = !group.querySelector('[data-nav-operation]:not([hidden])');
+    if (noResults) noResults.hidden = visible !== 0;
+    if (search) search.textContent = query ? visible + ' of ' + operations.length + ' operations' : '';
+  };
+  input?.addEventListener('input', applySearch);
+  document.addEventListener('keydown', (event) => {
+    if (event.key === '/' && document.activeElement?.tagName !== 'INPUT' && document.activeElement?.tagName !== 'SELECT') {
+      event.preventDefault(); input?.focus();
+    }
+  });
+  document.querySelector('[data-version-select]')?.addEventListener('change', (event) => {
+    const target = event.currentTarget;
+    if (target instanceof HTMLSelectElement && target.value) window.location.assign(target.value);
+  });
+  document.querySelector('[data-theme-toggle]')?.addEventListener('click', () => {
+    const current = root.dataset.theme || (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light');
+    const next = current === 'dark' ? 'light' : 'dark';
+    root.dataset.theme = next;
+    try { localStorage.setItem('farming-labs-api-theme', next); } catch {}
+  });
+  try { const saved = localStorage.getItem('farming-labs-api-theme'); if (saved === 'dark' || saved === 'light') root.dataset.theme = saved; } catch {}
+  const activateConsoleTab = (consoleRoot, tab) => {
+    const tabs = Array.from(consoleRoot.querySelectorAll('[data-console-tab]'));
+    const panels = Array.from(consoleRoot.querySelectorAll('[data-console-panel]'));
+    for (const candidate of tabs) {
+      const active = candidate.dataset.consoleTab === tab;
+      candidate.setAttribute('aria-selected', String(active));
+      candidate.tabIndex = active ? 0 : -1;
+    }
+    for (const panel of panels) panel.hidden = panel.dataset.consolePanel !== tab;
+    const exampleCopy = consoleRoot.querySelector('[data-example-copy]');
+    if (exampleCopy instanceof HTMLElement) exampleCopy.hidden = tab !== 'example';
+  };
+  for (const consoleRoot of document.querySelectorAll('[data-console-root]')) {
+    const tabs = Array.from(consoleRoot.querySelectorAll('[data-console-tab]'));
+    for (const tab of tabs) {
+      tab.addEventListener('click', () => activateConsoleTab(consoleRoot, tab.dataset.consoleTab || 'example'));
+      tab.addEventListener('keydown', (event) => {
+        if (!['ArrowLeft', 'ArrowRight', 'Home', 'End'].includes(event.key)) return;
+        event.preventDefault();
+        const current = tabs.indexOf(tab);
+        const next = event.key === 'Home' ? 0 : event.key === 'End' ? tabs.length - 1 : (current + (event.key === 'ArrowRight' ? 1 : -1) + tabs.length) % tabs.length;
+        const nextTab = tabs[next];
+        if (nextTab instanceof HTMLElement) {
+          activateConsoleTab(consoleRoot, nextTab.dataset.consoleTab || 'example');
+          nextTab.focus();
+        }
+      });
+    }
+  }
+  const setConsoleState = (form, state, label) => {
+    const badge = form.querySelector('[data-console-state]');
+    if (badge instanceof HTMLElement) { badge.dataset.state = state; badge.textContent = label; }
+  };
+  const encodeBasicCredentials = (value) => {
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary);
+  };
+  const appendQueryValue = (searchParams, name, value, array) => {
+    const values = array ? value.split(',').map((entry) => entry.trim()).filter(Boolean) : [value];
+    for (const entry of values) searchParams.append(name, entry);
+  };
+  const formatResponseBody = (value, contentType) => {
+    if (!value) return '(empty response)';
+    if (!contentType.includes('json') && !contentType.includes('+json')) return value;
+    try { return JSON.stringify(JSON.parse(value), null, 2); } catch { return value; }
+  };
+  for (const form of document.querySelectorAll('[data-api-console]')) {
+    if (!(form instanceof HTMLFormElement)) continue;
+    let controller;
+    const send = form.querySelector('[data-console-send]');
+    const cancel = form.querySelector('[data-console-cancel]');
+    const confirm = form.querySelector('[data-console-confirm]');
+    const message = form.querySelector('[data-console-message]');
+    const error = form.querySelector('[data-console-error]');
+    const responsePanel = form.querySelector('[data-console-response]');
+    if (confirm instanceof HTMLInputElement && send instanceof HTMLButtonElement) {
+      confirm.addEventListener('change', () => { send.disabled = !confirm.checked; });
+    }
+    cancel?.addEventListener('click', () => controller?.abort());
+    form.addEventListener('submit', async (event) => {
+      event.preventDefault();
+      if (!form.reportValidity() || !(send instanceof HTMLButtonElement)) return;
+      if (error instanceof HTMLElement) { error.hidden = true; error.textContent = ''; }
+      if (responsePanel instanceof HTMLElement) responsePanel.hidden = true;
+      const originalLabel = send.textContent || 'Send request';
+      send.disabled = true;
+      send.textContent = 'Sending…';
+      if (cancel instanceof HTMLElement) cancel.hidden = false;
+      if (message instanceof HTMLElement) message.textContent = 'Request in progress';
+      setConsoleState(form, 'sending', 'Sending');
+      controller = new AbortController();
+      const started = performance.now();
+      try {
+        const serverInput = form.elements.namedItem('server');
+        if (!(serverInput instanceof HTMLInputElement)) throw new Error('Server URL is required.');
+        const server = new URL(serverInput.value, window.location.origin);
+        if (server.protocol !== 'http:' && server.protocol !== 'https:') throw new Error('Server URL must use HTTP or HTTPS.');
+        let operationPath = form.dataset.path || '/';
+        const headers = new Headers();
+        const query = [];
+        for (const input of form.querySelectorAll('[data-param-name]')) {
+          if (!(input instanceof HTMLInputElement || input instanceof HTMLSelectElement)) continue;
+          const value = input.value.trim();
+          if (!value) continue;
+          const name = input.dataset.paramName || '';
+          const location = input.dataset.paramLocation;
+          if (location === 'path') operationPath = operationPath.split('{' + name + '}').join(encodeURIComponent(value));
+          else if (location === 'query') query.push([name, value, input.dataset.paramArray === 'true']);
+          else if (location === 'header') headers.set(name, value);
+        }
+        server.hash = '';
+        server.search = '';
+        server.pathname = server.pathname.replace(/\\/+$/, '') + '/' + operationPath.replace(/^\\/+/, '');
+        const url = server;
+        for (const [name, value, array] of query) appendQueryValue(url.searchParams, name, value, array);
+        for (const auth of form.querySelectorAll('[data-auth-token]')) {
+          if (auth instanceof HTMLInputElement && auth.value) headers.set('authorization', (auth.dataset.authPrefix || 'Bearer') + ' ' + auth.value);
+        }
+        for (const auth of form.querySelectorAll('[data-auth-api-key]')) {
+          if (!(auth instanceof HTMLInputElement) || !auth.value) continue;
+          const name = auth.dataset.authName || '';
+          if (auth.dataset.authLocation === 'query') url.searchParams.append(name, auth.value);
+          else headers.set(name, auth.value);
+        }
+        const basic = form.querySelector('[data-auth-basic]');
+        const username = basic?.querySelector('[data-auth-username]');
+        const password = basic?.querySelector('[data-auth-password]');
+        if (username instanceof HTMLInputElement && password instanceof HTMLInputElement && (username.value || password.value)) {
+          headers.set('authorization', 'Basic ' + encodeBasicCredentials(username.value + ':' + password.value));
+        }
+        const bodyInput = form.elements.namedItem('request-body');
+        const contentTypeInput = form.elements.namedItem('content-type');
+        let body;
+        if (bodyInput instanceof HTMLTextAreaElement && bodyInput.value.trim()) {
+          body = bodyInput.value;
+          const contentType = contentTypeInput instanceof HTMLSelectElement ? contentTypeInput.value : 'application/json';
+          if (contentType.toLocaleLowerCase().includes('json') || contentType.toLocaleLowerCase().includes('+json')) body = JSON.stringify(JSON.parse(body));
+          headers.set('content-type', contentType);
+        }
+        const credentialsInput = form.elements.namedItem('credentials');
+        const credentials = credentialsInput instanceof HTMLSelectElement ? credentialsInput.value : 'same-origin';
+        const response = await fetch(url, {
+          method: form.dataset.method || 'GET',
+          headers,
+          body,
+          credentials,
+          signal: controller.signal,
+        });
+        const rawBody = await response.text();
+        const contentType = response.headers.get('content-type') || 'unknown content type';
+        const formattedBody = formatResponseBody(rawBody, contentType.toLocaleLowerCase());
+        const duration = Math.round(performance.now() - started);
+        const status = form.querySelector('[data-response-status]');
+        const durationTarget = form.querySelector('[data-response-duration]');
+        const urlTarget = form.querySelector('[data-response-url]');
+        const typeTarget = form.querySelector('[data-response-type]');
+        const headersTarget = form.querySelector('[data-response-headers]');
+        const bodyTarget = form.querySelector('[data-response-body]');
+        const copy = form.querySelector('[data-response-copy]');
+        if (status instanceof HTMLElement) { status.textContent = response.status + ' ' + response.statusText; status.dataset.ok = String(response.ok); }
+        if (durationTarget instanceof HTMLElement) durationTarget.textContent = duration + ' ms';
+        if (urlTarget instanceof HTMLElement) { urlTarget.textContent = url.href; urlTarget.title = url.href; }
+        if (typeTarget instanceof HTMLElement) typeTarget.textContent = contentType;
+        if (headersTarget instanceof HTMLElement) headersTarget.textContent = Array.from(response.headers.entries()).map(([name, value]) => name + ': ' + value).join('\\n') || '(no exposed response headers)';
+        if (bodyTarget instanceof HTMLElement) bodyTarget.textContent = formattedBody;
+        if (copy instanceof HTMLButtonElement) copy.dataset.copy = formattedBody;
+        if (responsePanel instanceof HTMLElement) { responsePanel.hidden = false; responsePanel.focus({ preventScroll: true }); }
+        setConsoleState(form, response.ok ? 'success' : 'error', response.ok ? 'Complete' : 'HTTP error');
+        if (message instanceof HTMLElement) message.textContent = response.ok ? 'Request completed' : 'Request completed with an error status';
+      } catch (requestError) {
+        const aborted = requestError instanceof DOMException && requestError.name === 'AbortError';
+        const detail = aborted ? 'Request cancelled.' : requestError instanceof Error ? requestError.message : 'The request could not be sent.';
+        setConsoleState(form, aborted ? 'idle' : 'error', aborted ? 'Cancelled' : 'Failed');
+        if (message instanceof HTMLElement) message.textContent = aborted ? 'Request cancelled' : 'Request failed';
+        if (error instanceof HTMLElement) { error.hidden = false; error.textContent = detail; }
+      } finally {
+        controller = undefined;
+        send.textContent = originalLabel;
+        send.disabled = confirm instanceof HTMLInputElement ? !confirm.checked : false;
+        if (cancel instanceof HTMLElement) cancel.hidden = true;
+      }
+    });
+  }
+  document.addEventListener('click', async (event) => {
+    const button = event.target instanceof Element ? event.target.closest('[data-copy]') : null;
+    if (!(button instanceof HTMLButtonElement)) return;
+    const value = button.dataset.copy || '';
+    const original = button.textContent || 'Copy';
+    try {
+      await navigator.clipboard.writeText(value);
+      button.textContent = 'Copied';
+      if (copyStatus) copyStatus.textContent = 'Copied to clipboard';
+      setTimeout(() => { button.textContent = original; if (copyStatus) copyStatus.textContent = ''; }, 1600);
+    } catch {
+      button.textContent = 'Failed';
+      if (copyStatus) copyStatus.textContent = 'Could not copy to clipboard';
+      setTimeout(() => { button.textContent = original; if (copyStatus) copyStatus.textContent = ''; }, 1600);
+    }
+  });
+})();`;
+}
+function searchIcon() {
+	return "<svg viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" aria-hidden=\"true\"><circle cx=\"11\" cy=\"11\" r=\"7\"/><path d=\"m20 20-3.4-3.4\"/></svg>";
+}
+function themeIcon() {
+	return "<svg viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" aria-hidden=\"true\"><path d=\"M12 3a9 9 0 1 0 9 9c0-.6-.1-1.2-.2-1.8A7 7 0 0 1 12 3Z\"/></svg>";
+}
+function lockIcon() {
+	return "<svg viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" aria-hidden=\"true\"><rect x=\"5\" y=\"10\" width=\"14\" height=\"10\" rx=\"2\"/><path d=\"M8 10V7a4 4 0 0 1 8 0v3\"/></svg>";
+}
+function chevronIcon() {
+	return "<svg viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" aria-hidden=\"true\"><path d=\"m6 9 6 6 6-6\"/></svg>";
+}
+
+//#endregion
+//#region src/openapi-references.ts
+const OPENAPI_BUNDLED_REFERENCES_EXTENSION = "x-farming-labs-references";
+const OPENAPI_REFERENCE_MAX_DOCUMENTS = 32;
+function resolveOpenApiReferencesSync(document, options) {
+	const sourceUri = normalizeDocumentUri(options.sourceUri);
+	const entry = createDocumentState({
+		uri: sourceUri,
+		document
+	}, true);
+	const documents = /* @__PURE__ */ new Map();
+	registerDocument(documents, entry, sourceUri);
+	const bundle = {};
+	const maxDocuments = normalizeMaxDocuments(options.maxDocuments);
+	const getDocument = (requestedUri, fromUri) => {
+		const normalizedRequest = normalizeDocumentUri(requestedUri);
+		const cached = documents.get(normalizedRequest);
+		if (cached) return cached;
+		if (!options.loadDocument) throw new Error(`OpenAPI reference requires an external document: ${normalizedRequest}`);
+		if (countDocuments(documents) >= maxDocuments) throw new Error(`OpenAPI references exceed the ${maxDocuments}-document limit.`);
+		const state = createDocumentState(options.loadDocument(new URL(normalizedRequest), new URL(fromUri)), false);
+		registerDocument(documents, state, normalizedRequest);
+		return state;
+	};
+	const processDocument = (state) => {
+		if (state.processed || state.processing) return state.output;
+		state.processing = true;
+		state.output = structuredClone(state.document);
+		if (!state.entry) {
+			state.bundleKey = createBundleKey(state.retrievalUri);
+			bundle[state.bundleKey] = state.output;
+		}
+		rewriteReferencesSync(state.output, state, getDocument, processDocument);
+		state.processing = false;
+		state.processed = true;
+		return state.output;
+	};
+	const output = processDocument(entry);
+	if (!isRecord(output)) throw new Error("The OpenAPI entry document must be an object.");
+	if (Object.keys(bundle).length > 0) {
+		if (Object.hasOwn(output, OPENAPI_BUNDLED_REFERENCES_EXTENSION)) throw new Error(`The OpenAPI document uses the reserved \`${OPENAPI_BUNDLED_REFERENCES_EXTENSION}\` extension.`);
+		output[OPENAPI_BUNDLED_REFERENCES_EXTENSION] = bundle;
+	}
+	return output;
+}
+async function resolveOpenApiReferences(document, options) {
+	const sourceUri = normalizeDocumentUri(options.sourceUri);
+	const entry = createDocumentState({
+		uri: sourceUri,
+		document
+	}, true);
+	const documents = /* @__PURE__ */ new Map();
+	registerDocument(documents, entry, sourceUri);
+	const bundle = {};
+	const maxDocuments = normalizeMaxDocuments(options.maxDocuments);
+	const getDocument = async (requestedUri, fromUri) => {
+		const normalizedRequest = normalizeDocumentUri(requestedUri);
+		const cached = documents.get(normalizedRequest);
+		if (cached) return cached;
+		if (!options.loadDocument) throw new Error(`OpenAPI reference requires an external document: ${normalizedRequest}`);
+		if (countDocuments(documents) >= maxDocuments) throw new Error(`OpenAPI references exceed the ${maxDocuments}-document limit.`);
+		const state = createDocumentState(await options.loadDocument(new URL(normalizedRequest), new URL(fromUri)), false);
+		registerDocument(documents, state, normalizedRequest);
+		return state;
+	};
+	const processDocument = async (state) => {
+		if (state.processed || state.processing) return state.output;
+		state.processing = true;
+		state.output = structuredClone(state.document);
+		if (!state.entry) {
+			state.bundleKey = createBundleKey(state.retrievalUri);
+			bundle[state.bundleKey] = state.output;
+		}
+		await rewriteReferences(state.output, state, getDocument, processDocument);
+		state.processing = false;
+		state.processed = true;
+		return state.output;
+	};
+	const output = await processDocument(entry);
+	if (!isRecord(output)) throw new Error("The OpenAPI entry document must be an object.");
+	if (Object.keys(bundle).length > 0) {
+		if (Object.hasOwn(output, OPENAPI_BUNDLED_REFERENCES_EXTENSION)) throw new Error(`The OpenAPI document uses the reserved \`${OPENAPI_BUNDLED_REFERENCES_EXTENSION}\` extension.`);
+		output[OPENAPI_BUNDLED_REFERENCES_EXTENSION] = bundle;
+	}
+	return output;
+}
+function rewriteReferencesSync(value, currentDocument, getDocument, processDocument, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (!value || typeof value !== "object") return;
+	if (ancestors.has(value)) throw new Error("OpenAPI source documents cannot contain cyclic YAML aliases.");
+	ancestors.add(value);
+	if (Array.isArray(value)) {
+		for (const item of value) rewriteReferencesSync(item, currentDocument, getDocument, processDocument, ancestors);
+		ancestors.delete(value);
+		return;
+	}
+	const record = value;
+	if (Object.hasOwn(record, "$ref")) record.$ref = rewriteReferenceSync(record.$ref, currentDocument, getDocument, processDocument);
+	for (const [key, child] of Object.entries(record)) {
+		if (key === "$ref") continue;
+		rewriteReferencesSync(child, currentDocument, getDocument, processDocument, ancestors);
+	}
+	ancestors.delete(value);
+}
+async function rewriteReferences(value, currentDocument, getDocument, processDocument, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (!value || typeof value !== "object") return;
+	if (ancestors.has(value)) throw new Error("OpenAPI source documents cannot contain cyclic YAML aliases.");
+	ancestors.add(value);
+	if (Array.isArray(value)) {
+		for (const item of value) await rewriteReferences(item, currentDocument, getDocument, processDocument, ancestors);
+		ancestors.delete(value);
+		return;
+	}
+	const record = value;
+	if (Object.hasOwn(record, "$ref")) record.$ref = await rewriteReference(record.$ref, currentDocument, getDocument, processDocument);
+	for (const [key, child] of Object.entries(record)) {
+		if (key === "$ref") continue;
+		await rewriteReferences(child, currentDocument, getDocument, processDocument, ancestors);
+	}
+	ancestors.delete(value);
+}
+function rewriteReferenceSync(reference, currentDocument, getDocument, processDocument) {
+	const target = resolveReference(reference, currentDocument.baseUri);
+	const targetDocument = getDocument(target.documentUri, currentDocument.baseUri);
+	assertReferenceTarget(targetDocument.document, target.pointer, reference);
+	processDocument(targetDocument);
+	return buildBundledReference(targetDocument, target.pointer);
+}
+async function rewriteReference(reference, currentDocument, getDocument, processDocument) {
+	const target = resolveReference(reference, currentDocument.baseUri);
+	const targetDocument = await getDocument(target.documentUri, currentDocument.baseUri);
+	assertReferenceTarget(targetDocument.document, target.pointer, reference);
+	await processDocument(targetDocument);
+	return buildBundledReference(targetDocument, target.pointer);
+}
+function resolveReference(reference, baseUri) {
+	if (typeof reference !== "string" || !reference.trim()) throw new Error("OpenAPI `$ref` values must be non-empty URI strings.");
+	let url;
+	try {
+		url = new URL(reference, baseUri);
+	} catch {
+		throw new Error(`OpenAPI reference is not a valid URI: ${reference}`);
+	}
+	const pointer = normalizePointerFragment(url.hash, reference);
+	url.hash = "";
+	return {
+		documentUri: url.href,
+		pointer
+	};
+}
+function normalizePointerFragment(hash, reference) {
+	if (!hash || hash === "#") return "";
+	let decoded;
+	try {
+		decoded = decodeURIComponent(hash.slice(1));
+	} catch {
+		throw new Error(`OpenAPI reference has an invalid encoded fragment: ${String(reference)}`);
+	}
+	if (!decoded.startsWith("/")) throw new Error(`OpenAPI reference anchors are not supported yet; use a JSON Pointer fragment: ${String(reference)}`);
+	return decoded;
+}
+function assertReferenceTarget(document, pointer, reference) {
+	if (!pointer) return;
+	let current = document;
+	for (const token of pointer.slice(1).split("/")) {
+		if (!current || typeof current !== "object") throw new Error(`OpenAPI reference target was not found: ${String(reference)}`);
+		const key = decodeJsonPointerToken(token, reference);
+		if (!Object.hasOwn(current, key)) throw new Error(`OpenAPI reference target was not found: ${String(reference)}`);
+		current = current[key];
+	}
+}
+function decodeJsonPointerToken(token, reference) {
+	if (/~(?:[^01]|$)/.test(token)) throw new Error(`OpenAPI reference has an invalid JSON Pointer fragment: ${String(reference)}`);
+	return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function buildBundledReference(document, pointer) {
+	if (document.entry) return `#${pointer}`;
+	if (!document.bundleKey) throw new Error(`OpenAPI reference document was not bundled: ${document.retrievalUri}`);
+	return `#/${OPENAPI_BUNDLED_REFERENCES_EXTENSION}/${escapeJsonPointer(document.bundleKey)}${pointer}`;
+}
+function createDocumentState(loaded, entry) {
+	const retrievalUri = normalizeDocumentUri(loaded.uri);
+	const self = isRecord(loaded.document) ? loaded.document.$self : void 0;
+	let baseUri = retrievalUri;
+	if (typeof self === "string" && self.trim()) try {
+		baseUri = normalizeDocumentUri(new URL(self, retrievalUri).href);
+	} catch {
+		throw new Error(`OpenAPI document has an invalid \`$self\` URI: ${self}`);
+	}
+	return {
+		retrievalUri,
+		baseUri,
+		document: loaded.document,
+		entry,
+		processing: false,
+		processed: false
+	};
+}
+function registerDocument(documents, document, requestedUri) {
+	for (const uri of [
+		requestedUri,
+		document.retrievalUri,
+		document.baseUri
+	]) {
+		const normalized = normalizeDocumentUri(uri);
+		const existing = documents.get(normalized);
+		if (existing && existing !== document) throw new Error(`Multiple OpenAPI documents claim the same base URI: ${normalized}`);
+		documents.set(normalized, document);
+	}
+}
+function countDocuments(documents) {
+	return new Set(documents.values()).size;
+}
+function normalizeDocumentUri(value) {
+	const url = new URL(value);
+	url.hash = "";
+	return url.href;
+}
+function normalizeMaxDocuments(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : OPENAPI_REFERENCE_MAX_DOCUMENTS;
+}
+function createBundleKey(uri) {
+	return `ref-${createHash("sha256").update(uri).digest("hex").slice(0, 16)}`;
+}
+function escapeJsonPointer(value) {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/api-reference.ts
+const NEXT_ROUTE_FILE_RE = /^route\.(ts|tsx|js|jsx)$/;
+const SVELTE_ROUTE_FILE_RE = /^\+server\.(ts|js)$/;
+const ASTRO_ROUTE_FILE_RE = /^[^.].*\.(ts|js|mts|mjs)$/;
+const NUXT_ROUTE_FILE_RE = /^[^.].*\.(ts|js|mts|mjs)$/;
+const TANSTACK_ROUTE_FILE_RE = /\.(ts|tsx|js|jsx)$/;
+const METHOD_RE = /export\s+(?:async\s+function|function|const)\s+(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|ALL)\b/g;
+const METHOD_NAMES = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS",
+	"HEAD"
+];
+const DEFAULT_API_REFERENCE_OPENAPI_ROUTE = "/api/docs?format=openapi";
+const OPENAPI_SPEC_FETCH_TIMEOUT_MS = 1e4;
+const OPENAPI_SPEC_MAX_BYTES = 5 * 1024 * 1024;
+function normalizePathSegment(value) {
+	return value.replace(/^\/+|\/+$/g, "");
+}
+function resolveApiReferenceConfig(value) {
+	if (value === true) return {
+		enabled: true,
+		path: "api-reference",
+		specUrl: void 0,
+		overlays: [],
+		versions: [],
+		defaultVersion: void 0,
+		catalogTargets: void 0,
+		renderer: void 0,
+		mcp: void 0,
+		routeRoot: "api",
+		exclude: []
+	};
+	if (!value) return {
+		enabled: false,
+		path: "api-reference",
+		specUrl: void 0,
+		overlays: [],
+		versions: [],
+		defaultVersion: void 0,
+		catalogTargets: void 0,
+		renderer: void 0,
+		mcp: void 0,
+		routeRoot: "api",
+		exclude: []
+	};
+	const specUrl = normalizeRemoteSpecUrl(value.specUrl);
+	const overlays = normalizeOpenApiOverlaySources(value.overlays, "apiReference.overlays");
+	const { versions, defaultVersion } = resolveApiReferenceVersions(value);
+	if (versions.length > 0 && specUrl) throw new Error("`apiReference.versions` cannot be combined with `apiReference.specUrl`.");
+	if (versions.length > 0 && overlays.length > 0) throw new Error("`apiReference.versions` cannot be combined with top-level `apiReference.overlays`; configure overlays on each version instead.");
+	return {
+		enabled: value.enabled !== false,
+		path: normalizePathSegment(value.path ?? "api-reference"),
+		specUrl,
+		overlays,
+		versions,
+		defaultVersion,
+		catalogTargets: normalizeApiReferenceCatalogTargets(value.catalogTargets),
+		renderer: normalizeApiReferenceRenderer(value.renderer),
+		mcp: resolveOpenApiMcpConfig(value.mcp),
+		routeRoot: normalizePathSegment(value.routeRoot ?? "api") || "api",
+		exclude: normalizeApiReferenceExcludes(value.exclude)
+	};
+}
+function normalizeOpenApiOverlaySources(value, location) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`\`${location}\` must be an array of sources.`);
+	return value.map((source, index) => {
+		if (typeof source !== "string" || !source.trim()) throw new Error(`\`${location}[${index}]\` must be a non-empty string.`);
+		return source.trim();
+	});
+}
+function resolveApiReferenceVersions(value) {
+	if (value.versions === void 0) {
+		if (value.defaultVersion !== void 0) throw new Error("`apiReference.defaultVersion` requires `apiReference.versions`.");
+		return { versions: [] };
+	}
+	if (!value.versions || typeof value.versions !== "object" || Array.isArray(value.versions)) throw new Error("`apiReference.versions` must be an object keyed by version identifier.");
+	const entries = Object.entries(value.versions);
+	if (entries.length === 0) throw new Error("`apiReference.versions` must not be empty.");
+	const defaultVersion = value.defaultVersion?.trim();
+	if (!defaultVersion) throw new Error("`apiReference.defaultVersion` is required when versions are configured.");
+	if (!Object.prototype.hasOwnProperty.call(value.versions, defaultVersion)) throw new Error(`\`apiReference.defaultVersion\` references unknown version \`${defaultVersion}\`.`);
+	return {
+		versions: entries.map(([id, rawVersion]) => resolveApiReferenceVersionConfig(id, rawVersion, defaultVersion)),
+		defaultVersion
+	};
+}
+function resolveApiReferenceVersionConfig(rawId, value, defaultVersion) {
+	const id = rawId.trim();
+	if (!id || !/^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/.test(id)) throw new Error(`OpenAPI version identifier \`${rawId}\` must be URL-safe and contain only letters, numbers, dots, underscores, or hyphens.`);
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`\`apiReference.versions.${id}\` must be an object.`);
+	const specUrl = normalizeRemoteSpecUrl(value.specUrl);
+	if (!specUrl) throw new Error(`\`apiReference.versions.${id}.specUrl\` is required.`);
+	return {
+		id,
+		label: value.label?.trim() || id,
+		specUrl,
+		overlays: normalizeOpenApiOverlaySources(value.overlays, `apiReference.versions.${id}.overlays`),
+		default: id === defaultVersion
+	};
+}
+function resolveOpenApiMcpConfig(value) {
+	if (!value) return void 0;
+	return value === true ? { enabled: true } : {
+		...value,
+		enabled: value.enabled !== false
+	};
+}
+function normalizeApiReferenceRenderer(value) {
+	if (value === "farming-labs" || value === "fumadocs" || value === "scalar") return value;
+}
+function resolveApiReferenceRenderer(value, _framework) {
+	const config = resolveApiReferenceConfig(value);
+	if (config.renderer) return config.renderer;
+	return "farming-labs";
+}
+function resolveApiReferenceOpenApiDiscovery(value, options = {}) {
+	const config = resolveApiReferenceConfig(value);
+	if (!config.enabled) return { enabled: false };
+	const selectedSpecUrl = resolveApiReferenceVersion(config)?.specUrl ?? config.specUrl;
+	const catalogTargets = config.catalogTargets ?? (!selectedSpecUrl || isRequestRelativeSpecUrl(selectedSpecUrl) ? ["/"] : void 0);
+	const route = options.route ?? DEFAULT_API_REFERENCE_OPENAPI_ROUTE;
+	const versions = config.versions.length > 0 ? config.versions.map((version) => ({
+		id: version.id,
+		label: version.label,
+		default: version.default,
+		url: appendUrlSearchParam(route, "version", version.id),
+		apiReferencePath: `/${config.path}/${encodeURIComponent(version.id)}`,
+		specUrl: isLocalSpecSource(version.specUrl) ? void 0 : version.specUrl
+	})) : void 0;
+	return {
+		enabled: true,
+		url: route,
+		urlSource: options.route === void 0 ? "default" : "configured",
+		source: selectedSpecUrl ? "configured" : "generated",
+		specUrl: isLocalSpecSource(selectedSpecUrl) ? void 0 : selectedSpecUrl,
+		apiReferencePath: `/${config.path}`,
+		catalogTargets,
+		versions
+	};
+}
+function appendUrlSearchParam(url, name, value) {
+	const [withoutHash, hash] = url.split("#", 2);
+	return `${withoutHash}${withoutHash.includes("?") ? "&" : "?"}${encodeURIComponent(name)}=${encodeURIComponent(value)}${hash === void 0 ? "" : `#${hash}`}`;
+}
+function resolveApiReferenceVersion(config, requestedVersion) {
+	if (config.versions.length === 0) return void 0;
+	const versionId = requestedVersion?.trim() || config.defaultVersion;
+	return config.versions.find((version) => version.id === versionId);
+}
+function resolveApiReferenceVersionFromPathname(value, pathname) {
+	const config = resolveApiReferenceConfig(value);
+	if (config.versions.length === 0) return void 0;
+	const pathSegments = normalizePathSegment(config.path).split("/").filter(Boolean);
+	const pathnameSegments = pathname.split("/").filter(Boolean);
+	if (!pathSegments.every((segment, index) => pathnameSegments[index] === segment)) return;
+	const rawVersion = pathnameSegments[pathSegments.length];
+	if (!rawVersion) return void 0;
+	try {
+		return resolveApiReferenceVersion(config, decodeURIComponent(rawVersion));
+	} catch {
+		return;
+	}
+}
+function isApiReferenceOpenApiRequest(url) {
+	return url.searchParams.get("format")?.trim() === "openapi";
+}
+function normalizeRemoteSpecUrl(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return void 0;
+	return trimmed;
+}
+function normalizeApiReferenceCatalogTargets(value) {
+	if (value === void 0) return void 0;
+	return Array.from(new Set(value.filter((target) => typeof target === "string").map((target) => target.trim()).filter(Boolean)));
+}
+function isRequestRelativeSpecUrl(value) {
+	return typeof value === "string" && value.startsWith("/") && !value.startsWith("//");
+}
+function isRemoteSpecUrl(value) {
+	return /^(?:https?:)?\/\//i.test(value);
+}
+function isLocalSpecSource(value) {
+	if (!value) return false;
+	if (value.startsWith("file:")) return true;
+	return !isRemoteSpecUrl(value) && !isRequestRelativeSpecUrl(value) && !/^[a-z][a-z\d+.-]*:/i.test(value);
+}
+function buildApiReferencePageTitle(config, title = "API Reference") {
+	const template = config.metadata?.titleTemplate;
+	if (!template) return title;
+	return template.replace("%s", title);
+}
+function buildApiReferenceScalarCss(config) {
+	const theme = resolveTheme(config);
+	const colors = theme?.ui?.colors;
+	const typography = theme?.ui?.typography?.font?.style;
+	const layout = theme?.ui?.layout;
+	const radius = resolveApiReferenceRadius(theme);
+	const primary = colors?.primary ?? "#6366f1";
+	const border = colors?.border ?? "#2a2a2a";
+	const muted = colors?.muted ?? "#64748b";
+	const background = colors?.background ?? "#ffffff";
+	const card = colors?.card ?? background;
+	const foreground = colors?.foreground ?? inferApiReferenceForeground(theme, background);
+	const primaryForeground = colors?.primaryForeground ?? inferContrastingForeground(primary, theme, background);
+	const sidebarWidth = layout?.sidebarWidth ?? 280;
+	const sans = typography?.sans ?? "\"Geist\", \"Inter\", \"Segoe UI\", sans-serif";
+	const mono = typography?.mono ?? "\"Geist Mono\", \"SFMono-Regular\", \"Menlo\", monospace";
+	const isPixelBorder = theme?.name?.includes("pixel-border");
+	return `
+:root {
+  --scalar-font: ${sans};
+  --scalar-font-code: ${mono};
+  --scalar-radius: ${radius};
+  --scalar-radius-sm: calc(${radius} + 2px);
+  --scalar-theme-primary: ${primary};
+  --scalar-theme-border: ${border};
+  --scalar-theme-muted: ${muted};
+  --scalar-theme-background: ${background};
+  --scalar-theme-card: ${card};
+  --scalar-theme-foreground: ${foreground};
+}
+
+.dark-mode {
+  --scalar-background-1: color-mix(
+    in srgb,
+    var(--scalar-theme-background) 96%,
+    var(--scalar-theme-primary) 4%
+  );
+  --scalar-background-2: color-mix(in srgb, var(--scalar-theme-card) 94%, var(--scalar-theme-primary) 6%);
+  --scalar-background-3: color-mix(
+    in srgb,
+    var(--scalar-theme-card) 90%,
+    var(--scalar-theme-foreground) 10%
+  );
+  --scalar-color-1: var(--scalar-theme-foreground);
+  --scalar-color-2: color-mix(in srgb, var(--scalar-theme-foreground) 72%, transparent);
+  --scalar-color-3: color-mix(in srgb, var(--scalar-theme-foreground) 52%, transparent);
+  --scalar-color-accent: var(--scalar-theme-primary);
+  --scalar-sidebar-background-1: var(--scalar-background-1);
+  --scalar-sidebar-background-2: var(--scalar-background-2);
+  --scalar-sidebar-color-1: var(--scalar-color-1);
+  --scalar-sidebar-color-2: var(--scalar-color-2);
+  --scalar-sidebar-search-background: var(--scalar-background-2);
+  --scalar-sidebar-search-border-color: var(--scalar-border-color);
+  --scalar-sidebar-search-color: var(--scalar-color-2);
+  --scalar-sidebar-color-active: var(--scalar-theme-primary);
+  --scalar-sidebar-item-active-background: color-mix(
+    in srgb,
+    var(--scalar-theme-primary) 7%,
+    transparent
+  );
+  --scalar-border-color: ${isPixelBorder ? "color-mix(in srgb, var(--scalar-theme-foreground) 10%, transparent)" : "color-mix(in srgb, var(--scalar-theme-border) 14%, rgba(255, 255, 255, 0.02))"};
+  --scalar-button-1: var(--scalar-theme-primary);
+  --scalar-button-1-color: ${primaryForeground};
+  --scalar-button-1-hover: color-mix(in srgb, var(--scalar-theme-primary) 88%, white 12%);
+}
+
+.light-mode {
+  --scalar-background-1: var(--scalar-theme-background);
+  --scalar-background-2: color-mix(in srgb, var(--scalar-theme-card) 92%, white 8%);
+  --scalar-background-3: color-mix(in srgb, var(--scalar-theme-card) 84%, black 4%);
+  --scalar-color-1: var(--scalar-theme-foreground);
+  --scalar-color-2: var(--scalar-theme-muted);
+  --scalar-color-3: color-mix(in srgb, var(--scalar-theme-muted) 78%, white 22%);
+  --scalar-color-accent: var(--scalar-theme-primary);
+  --scalar-sidebar-background-1: var(--scalar-background-1);
+  --scalar-sidebar-background-2: var(--scalar-background-2);
+  --scalar-sidebar-color-1: var(--scalar-color-1);
+  --scalar-sidebar-color-2: var(--scalar-color-2);
+  --scalar-sidebar-search-background: var(--scalar-background-2);
+  --scalar-sidebar-search-border-color: var(--scalar-border-color);
+  --scalar-sidebar-search-color: var(--scalar-color-2);
+  --scalar-sidebar-color-active: var(--scalar-theme-primary);
+  --scalar-sidebar-item-active-background: color-mix(
+    in srgb,
+    var(--scalar-theme-primary) 5%,
+    transparent
+  );
+  --scalar-border-color: ${isPixelBorder ? "color-mix(in srgb, var(--scalar-theme-foreground) 14%, transparent)" : "color-mix(in srgb, var(--scalar-theme-border) 30%, white 70%)"};
+  --scalar-button-1: var(--scalar-theme-primary);
+  --scalar-button-1-color: ${primaryForeground};
+  --scalar-button-1-hover: color-mix(in srgb, var(--scalar-theme-primary) 88%, black 12%);
+}
+
+body {
+  background: var(--scalar-background-1);
+  color: var(--scalar-color-1);
+}
+
+.t-doc__sidebar {
+  width: min(${sidebarWidth}px, 100vw);
+  border-right: 1px solid var(--scalar-border-color);
+}
+
+.scalar-card,
+.t-doc__sidebar,
+.references-layout .reference-layout__content .request-card,
+.references-layout .reference-layout__content .response-card,
+.references-layout .reference-layout__content .scalar-card-header,
+.references-layout .reference-layout__content .scalar-card-footer,
+.references-layout .reference-layout__content .section,
+.references-layout .reference-layout__content .section-container {
+  border-color: var(--scalar-border-color) !important;
+}
+
+.t-doc__sidebar,
+.t-doc__sidebar * {
+  font-family: var(--scalar-font);
+}
+
+.t-doc__sidebar .sidebar-search {
+  margin: 0.5rem 0 1rem;
+}
+
+.t-doc__sidebar .sidebar-search input {
+  border-radius: var(--scalar-radius-sm);
+}
+
+.t-doc__sidebar .sidebar-item,
+.t-doc__sidebar .sidebar-heading {
+  border-radius: var(--scalar-radius-sm);
+}
+
+.t-doc__sidebar .sidebar-group-label {
+  font-size: 0.72rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--scalar-color-3);
+}
+
+.t-doc__sidebar .sidebar-item--active {
+  font-weight: 600;
+}
+
+.scalar-card,
+.references-layout .reference-layout__content .request-card,
+.references-layout .reference-layout__content .response-card {
+  border-radius: var(--scalar-radius);
+}
+
+.references-layout .reference-layout__content {
+  padding-top: 1.5rem;
+}
+
+.references-layout .section-content,
+.references-layout .section-flare {
+  background: transparent;
+}
+
+.references-layout .reference-layout__content,
+.references-layout .reference-layout__content * {
+  font-family: var(--scalar-font);
+}
+
+.references-layout code,
+.references-layout pre,
+.references-layout .scalar-codeblock {
+  font-family: var(--scalar-font-code);
+}
+
+.references-layout,
+.references-layout * {
+  color: inherit;
+}
+
+.references-layout .reference-layout__content .introduction,
+.references-layout .reference-layout__content .section,
+.references-layout .reference-layout__content .section-container,
+.references-layout .reference-layout__content .operation-details,
+.references-layout .reference-layout__content .markdown,
+.references-layout .reference-layout__content .markdown *,
+.references-layout .reference-layout__content .property,
+.references-layout .reference-layout__content .property *,
+.references-layout .reference-layout__content .parameter-item,
+.references-layout .reference-layout__content .parameter-item *,
+.references-layout .reference-layout__content .response-card,
+.references-layout .reference-layout__content .response-card *,
+.references-layout .reference-layout__content .request-card,
+.references-layout .reference-layout__content .request-card * {
+  color: var(--scalar-color-1);
+}
+
+.references-layout a,
+.references-layout button {
+  color: var(--scalar-color-1);
+}
+
+${isPixelBorder ? buildPixelBorderScalarCss() : ""}
+`;
+}
+function buildPixelBorderScalarCss() {
+	return `
+.t-doc__sidebar,
+.references-layout .reference-layout__content {
+  background-image:
+    repeating-linear-gradient(
+      -45deg,
+      color-mix(in srgb, var(--scalar-theme-border) 12%, transparent),
+      color-mix(in srgb, var(--scalar-theme-border) 12%, transparent) 1px,
+      transparent 1px,
+      transparent 8px
+    );
+}
+
+.t-doc__sidebar .sidebar-group-label,
+.t-doc__sidebar .sidebar-item,
+.references-layout .reference-layout__content .section-header {
+  font-family: var(--scalar-font-code);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+`;
+}
+function inferApiReferenceForeground(theme, background) {
+	if (looksDarkTheme(theme, background)) return "#f5f5f4";
+	return "#1b1b1b";
+}
+function resolveApiReferenceRadius(theme) {
+	if (theme?.ui?.radius) return theme.ui.radius;
+	const name = theme?.name?.toLowerCase() ?? "";
+	if (name.includes("pixel-border") || name.includes("darksharp")) return "0px";
+	return "var(--radius, 0.75rem)";
+}
+function inferContrastingForeground(value, theme, background) {
+	const rgb = parseCssColor(value);
+	if (rgb) return relativeLuminance(rgb) > .58 ? "#0b0b0b" : "#ffffff";
+	if (theme?.name?.includes("pixel-border")) return "#0b0b0b";
+	if (looksDarkTheme(theme, background)) return "#0b0b0b";
+	return "#ffffff";
+}
+function looksDarkTheme(theme, background) {
+	const name = theme?.name?.toLowerCase() ?? "";
+	if (name.includes("pixel-border") || name.includes("darksharp")) return true;
+	const rgb = parseCssColor(background);
+	if (!rgb) return false;
+	return relativeLuminance(rgb) < .45;
+}
+function parseCssColor(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized.startsWith("#")) return parseHexColor(normalized);
+	const rgbMatch = normalized.match(/^rgba?\((.+)\)$/);
+	if (rgbMatch) {
+		const [r, g, b] = rgbMatch[1].split(",").slice(0, 3).map((part) => Number.parseFloat(part.trim()));
+		if ([
+			r,
+			g,
+			b
+		].every((channel) => Number.isFinite(channel))) return [
+			r,
+			g,
+			b
+		];
+	}
+	const hslMatch = normalized.match(/^hsla?\((.+)\)$/);
+	if (hslMatch) {
+		const [h, s, l] = hslMatch[1].split(/[\s,/]+/).filter(Boolean).slice(0, 3);
+		const hue = Number.parseFloat(h);
+		const saturation = Number.parseFloat(s.replace("%", ""));
+		const lightness = Number.parseFloat(l.replace("%", ""));
+		if ([
+			hue,
+			saturation,
+			lightness
+		].every((channel) => Number.isFinite(channel))) return hslToRgb(hue, saturation / 100, lightness / 100);
+	}
+	const oklchMatch = normalized.match(/^oklch\((.+)\)$/);
+	if (oklchMatch) {
+		const [l, c, h] = oklchMatch[1].split(/[\s/]+/).filter(Boolean);
+		const lightness = Number.parseFloat(l);
+		const chroma = Number.parseFloat(c);
+		const hue = Number.parseFloat(h);
+		if ([
+			lightness,
+			chroma,
+			hue
+		].every((channel) => Number.isFinite(channel))) return oklchToRgb(lightness, chroma, hue);
+	}
+}
+function oklchToRgb(l, c, h) {
+	const hue = h * Math.PI / 180;
+	const a = Math.cos(hue) * c;
+	const b = Math.sin(hue) * c;
+	const l_ = l + .3963377774 * a + .2158037573 * b;
+	const m_ = l - .1055613458 * a - .0638541728 * b;
+	const s_ = l - .0894841775 * a - 1.291485548 * b;
+	const l3 = l_ ** 3;
+	const m3 = m_ ** 3;
+	const s3 = s_ ** 3;
+	const linearR = 4.0767416621 * l3 - 3.3077115913 * m3 + .2309699292 * s3;
+	const linearG = -1.2684380046 * l3 + 2.6097574011 * m3 - .3413193965 * s3;
+	const linearB = -.0041960863 * l3 - .7034186147 * m3 + 1.707614701 * s3;
+	return [
+		srgbFromLinear(linearR),
+		srgbFromLinear(linearG),
+		srgbFromLinear(linearB)
+	];
+}
+function srgbFromLinear(value) {
+	const normalized = value <= .0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - .055;
+	return Math.max(0, Math.min(255, Math.round(normalized * 255)));
+}
+function parseHexColor(value) {
+	const raw = value.slice(1);
+	if (raw.length === 3) return [
+		Number.parseInt(raw[0] + raw[0], 16),
+		Number.parseInt(raw[1] + raw[1], 16),
+		Number.parseInt(raw[2] + raw[2], 16)
+	];
+	if (raw.length === 6 || raw.length === 8) return [
+		Number.parseInt(raw.slice(0, 2), 16),
+		Number.parseInt(raw.slice(2, 4), 16),
+		Number.parseInt(raw.slice(4, 6), 16)
+	];
+}
+function hslToRgb(h, s, l) {
+	const hue = (h % 360 + 360) % 360 / 360;
+	if (s === 0) {
+		const gray = Math.round(l * 255);
+		return [
+			gray,
+			gray,
+			gray
+		];
+	}
+	const q = l < .5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	const convert = (channel) => {
+		let t = channel;
+		if (t < 0) t += 1;
+		if (t > 1) t -= 1;
+		if (t < 1 / 6) return p + (q - p) * 6 * t;
+		if (t < 1 / 2) return q;
+		if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+		return p;
+	};
+	return [
+		Math.round(convert(hue + 1 / 3) * 255),
+		Math.round(convert(hue) * 255),
+		Math.round(convert(hue - 1 / 3) * 255)
+	];
+}
+function relativeLuminance([r, g, b]) {
+	const normalize = (channel) => {
+		const value = channel / 255;
+		return value <= .03928 ? value / 12.92 : ((value + .055) / 1.055) ** 2.4;
+	};
+	return .2126 * normalize(r) + .7152 * normalize(g) + .0722 * normalize(b);
+}
+function buildApiReferenceOpenApiDocument(config, options) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	const selectedVersion = resolveApiReferenceVersion(apiReference, options.version);
+	if (apiReference.versions.length > 0 && !selectedVersion) return buildUnavailableOpenApiDocument(config, `Unknown OpenAPI version \`${options.version}\`. Available versions: ${apiReference.versions.map((version) => version.id).join(", ")}.`);
+	const specUrl = selectedVersion?.specUrl ?? apiReference.specUrl;
+	const overlays = selectedVersion?.overlays ?? apiReference.overlays;
+	if (specUrl) {
+		if (isLocalSpecSource(specUrl)) try {
+			if (overlays.some((overlay) => !isLocalSpecSource(overlay))) throw new Error("Remote OpenAPI overlays require the async API reference builder.");
+			return normalizeConfiguredOpenApiDocument(readLocalOpenApiDocument(specUrl, options.rootDir, overlays), config, options.baseUrl, specUrl, selectedVersion);
+		} catch (error) {
+			return buildUnavailableOpenApiDocument(config, `Unable to load the configured OpenAPI document. ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+		return buildUnavailableOpenApiDocument(config, `Remote OpenAPI specs require the async API reference builder. Use the framework route helper or buildApiReferenceOpenApiDocumentAsync().`);
+	}
+	const routes = buildApiReferenceRoutes(config, options);
+	return buildOpenApiDocumentFromRoutes(config, options.framework, routes, options.baseUrl);
+}
+async function buildApiReferenceOpenApiDocumentAsync(config, options) {
+	try {
+		return await loadApiReferenceOpenApiDocumentAsync(config, options);
+	} catch (error) {
+		return buildUnavailableOpenApiDocument(config, `Unable to load the configured OpenAPI document. ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Load the resolved OpenAPI document without replacing diagnostics with an unavailable schema.
+* This is used by CLI health checks that need the original parsing, reference, and overlay error.
+*/
+async function loadApiReferenceOpenApiDocumentAsync(config, options) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	const selectedVersion = resolveApiReferenceVersion(apiReference, options.version);
+	if (apiReference.versions.length > 0 && !selectedVersion) throw new Error(`Unknown OpenAPI version \`${options.version}\`. Available versions: ${apiReference.versions.map((version) => version.id).join(", ")}.`);
+	const specUrl = selectedVersion?.specUrl ?? apiReference.specUrl;
+	const overlays = selectedVersion?.overlays ?? apiReference.overlays;
+	if (!specUrl) return buildApiReferenceOpenApiDocument(config, options);
+	return normalizeConfiguredOpenApiDocument(isLocalSpecSource(specUrl) ? await readLocalOpenApiDocumentAsync(specUrl, options.rootDir, overlays, options.baseUrl) : await fetchRemoteOpenApiDocument(specUrl, options.baseUrl, overlays, options.rootDir), config, options.baseUrl, specUrl, selectedVersion);
+}
+/**
+* Build deterministic, operation-level source pages from every configured OpenAPI version.
+*
+* These pages are framework-neutral projections used by documentation search and other
+* read-only knowledge surfaces. They never inherit MCP execution headers or credentials.
+*/
+async function buildApiReferenceOperationPagesAsync(config, options) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	if (!apiReference.enabled) return [];
+	const versions = apiReference.versions.length > 0 ? apiReference.versions : [void 0];
+	return (await Promise.all(versions.map(async (version) => {
+		const model = buildNormalizedOpenApiModel(await buildApiReferenceOpenApiDocumentAsync(config, {
+			...options,
+			version: version?.id
+		}));
+		const basePath = `/${apiReference.path}${version ? `/${encodeURIComponent(version.id)}` : ""}`;
+		return model.operations.map((operation) => {
+			const url = `${basePath}/operations/${encodeURIComponent(operation.slug)}`;
+			const content = renderApiReferenceOperationMarkdown(operation, {
+				apiTitle: model.title,
+				apiVersion: version?.label ?? model.version,
+				specificationVersion: model.specificationVersion
+			});
+			const description = operation.summary ?? operation.description ?? operation.selector;
+			return {
+				title: operation.title,
+				url,
+				canonicalUrl: url,
+				content,
+				description,
+				rawContent: content,
+				agentContent: content,
+				agentRawContent: content,
+				type: "api",
+				...options.locale ? { locale: options.locale } : {},
+				...version?.id || model.version ? { version: version?.id ?? model.version } : {},
+				tags: Array.from(new Set([
+					"openapi",
+					operation.method.toLowerCase(),
+					...operation.tags
+				]))
+			};
+		});
+	}))).flat();
+}
+function normalizeApiReferenceMarkdownPath(value) {
+	const trimmed = value.trim().replace(/\.md$/i, "");
+	if (!trimmed) return "/";
+	return `/${trimmed.replace(/^\/+|\/+$/g, "")}`.replace(/\/{2,}/g, "/");
+}
+function isApiReferenceOperationPath(pathname, apiReferencePath) {
+	const basePath = `/${normalizePathSegment(apiReferencePath)}`;
+	if (!pathname.startsWith(`${basePath}/`)) return false;
+	const segments = pathname.slice(basePath.length + 1).split("/");
+	return segments.length === 2 && segments[0] === "operations" && Boolean(segments[1]) || segments.length === 3 && segments[1] === "operations" && Boolean(segments[0] && segments[2]);
+}
+function resolveApiReferenceOperationMarkdownPath(request, apiReferencePath, apiRoute = "/api/docs") {
+	if (request.method !== "GET" && request.method !== "HEAD") return null;
+	const url = new URL(request.url);
+	const pathname = normalizeApiReferenceMarkdownPath(url.pathname);
+	if (pathname === normalizeApiReferenceMarkdownPath(apiRoute) && url.searchParams.get("format")?.trim() === "markdown") {
+		const requestedPath = normalizeApiReferenceMarkdownPath(url.searchParams.get("path")?.trim() ?? "");
+		return isApiReferenceOperationPath(requestedPath, apiReferencePath) ? requestedPath : null;
+	}
+	if (url.pathname.toLowerCase().endsWith(".md")) return isApiReferenceOperationPath(pathname, apiReferencePath) ? pathname : null;
+	return (acceptsDocsMarkdown(request) || hasDocsMarkdownSignatureAgent(request) || detectDocsMarkdownAgentRequest(request).detected) && isApiReferenceOperationPath(pathname, apiReferencePath) ? pathname : null;
+}
+/**
+* Resolve a public per-operation Markdown request using the same generated projection as search,
+* Ask AI, and MCP. Returns `null` when the request is not an API operation Markdown route.
+*/
+async function createApiReferenceOperationMarkdownResponse(config, options) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	if (!apiReference.enabled) return null;
+	const requestedPath = resolveApiReferenceOperationMarkdownPath(options.request, apiReference.path, options.apiRoute);
+	if (!requestedPath) return null;
+	const requestUrl = new URL(options.request.url);
+	const origin = options.origin ?? options.baseUrl ?? requestUrl.origin;
+	const operationPages = options.operationPages ? await (typeof options.operationPages === "function" ? options.operationPages() : options.operationPages) : await buildApiReferenceOperationPagesAsync(config, {
+		framework: options.framework,
+		rootDir: options.rootDir,
+		baseUrl: options.baseUrl ?? requestUrl.origin,
+		locale: options.locale
+	});
+	const page = operationPages.find((candidate) => normalizeApiReferenceMarkdownPath(candidate.url) === requestedPath);
+	const canonicalPath = page?.canonicalUrl ?? page?.url ?? requestedPath;
+	const canonicalUrl = new URL(canonicalPath, origin).toString();
+	const contentLocation = new URL(toDocsMarkdownUrl(page?.url ?? requestedPath), origin).toString();
+	const relativeRequestedPath = requestedPath.slice(`/${apiReference.path}`.length).replace(/^\/+/, "");
+	return createDocsMarkdownResponse({
+		request: options.request,
+		apiRoute: options.apiRoute,
+		document: page ? renderDocsMarkdownDocument(page, {
+			origin,
+			sitemap: options.sitemap,
+			okf: options.okf
+		}) : null,
+		entry: apiReference.path,
+		requestedPath: relativeRequestedPath,
+		origin,
+		locale: options.locale,
+		canonicalUrl,
+		contentLocation,
+		pages: [...options.pages ?? [], ...operationPages],
+		sitemap: options.sitemap
+	});
+}
+function renderApiReferenceOperationMarkdown(operation, metadata) {
+	const lines = [
+		`# ${operation.title}`,
+		"",
+		`\`${operation.method} ${operation.path}\``,
+		"",
+		`- Operation ID: \`${operation.operationId}\``,
+		`- API: ${metadata.apiTitle}`,
+		`- API version: ${metadata.apiVersion}`,
+		`- OpenAPI: ${metadata.specificationVersion}`
+	];
+	if (operation.tags.length > 0) lines.push(`- Tags: ${operation.tags.join(", ")}`);
+	if (operation.deprecated) lines.push("- Deprecated: yes");
+	if (operation.description && operation.description !== operation.title) lines.push("", operation.description);
+	if (operation.servers.length > 0) lines.push("", "## Servers", "", ...operation.servers.map((server) => `- ${server}`));
+	if (operation.parameters.length > 0) {
+		lines.push("", "## Parameters", "");
+		for (const parameter of operation.parameters) lines.push(renderApiReferenceParameter(parameter));
+	}
+	if (operation.requestBody) {
+		lines.push("", "## Request body", "");
+		if (operation.requestBody.description) lines.push(operation.requestBody.description, "");
+		lines.push(`Required: ${operation.requestBody.required ? "yes" : "no"}`);
+		appendApiReferenceMediaTypes(lines, operation.requestBody.content);
+	}
+	if (operation.responses.length > 0) {
+		lines.push("", "## Responses", "");
+		for (const response of operation.responses) {
+			lines.push(`### ${response.status}`, "", response.description ?? "No response description.");
+			appendApiReferenceMediaTypes(lines, response.content);
+			lines.push("");
+		}
+	}
+	if (operation.security.length > 0) {
+		lines.push("", "## Security", "");
+		for (const requirement of operation.security) {
+			const schemes = Object.entries(requirement).map(([name, scopes]) => scopes.length > 0 ? `${name} (${scopes.join(", ")})` : name);
+			lines.push(`- ${schemes.join(" and ")}`);
+		}
+	}
+	return `${lines.join("\n").trim()}\n`;
+}
+function renderApiReferenceParameter(parameter) {
+	const details = [parameter.in, parameter.required ? "required" : "optional"];
+	const schema = renderApiReferenceSchema(parameter.schema);
+	if (schema) details.push(schema);
+	return `- \`${parameter.name}\` (${details.join(", ")})${parameter.description ? ` — ${parameter.description}` : ""}`;
+}
+function appendApiReferenceMediaTypes(lines, content) {
+	for (const media of content) {
+		lines.push("", `- Content type: \`${media.mediaType}\``);
+		const schema = renderApiReferenceSchema(media.schema);
+		if (schema) lines.push(`  Schema: \`${schema}\``);
+		for (const example of media.examples) {
+			const value = renderApiReferenceSchema(example.value);
+			lines.push(`  Example ${example.name}: ${value ? `\`${value}\`` : "available"}`);
+		}
+	}
+}
+function renderApiReferenceSchema(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || value === null) return String(value);
+	try {
+		const serialized = JSON.stringify(value);
+		return serialized.length > 500 ? `${serialized.slice(0, 497)}...` : serialized;
+	} catch {
+		return;
+	}
+}
+function buildOpenApiDocumentFromRoutes(config, framework, routes, baseUrl) {
+	const tags = Array.from(new Set(routes.map((route) => route.tag))).map((name) => ({
+		name,
+		description: `${name} endpoints`
+	}));
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "API Reference",
+			description: config.metadata?.description ?? `Generated API reference for ${framework}.`,
+			version: "0.0.0"
+		},
+		servers: [{ url: baseUrl ?? "/" }],
+		tags,
+		paths: buildOpenApiPaths(routes)
+	};
+}
+function buildApiReferenceHtmlDocument(config, options) {
+	return buildApiReferenceHtmlDocumentFromDocument(config, options, buildApiReferenceOpenApiDocument(config, options));
+}
+async function buildApiReferenceHtmlDocumentAsync(config, options) {
+	return buildApiReferenceHtmlDocumentFromDocument(config, options, await buildApiReferenceOpenApiDocumentAsync(config, options));
+}
+function buildApiReferenceHtmlDocumentFromDocument(config, options, document) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	const version = resolveApiReferenceVersion(apiReference, options.version);
+	const basePath = `/${apiReference.path}${version ? `/${encodeURIComponent(version.id)}` : ""}`;
+	if (resolveApiReferenceRenderer(config.apiReference, options.framework) === "farming-labs") {
+		const model = buildNormalizedOpenApiModel(document);
+		const info = document.info && typeof document.info === "object" && !Array.isArray(document.info) ? document.info : void 0;
+		const title = options.title ?? model.title;
+		const openApiUrl = version ? appendUrlSearchParam(DEFAULT_API_REFERENCE_OPENAPI_ROUTE, "version", version.id) : DEFAULT_API_REFERENCE_OPENAPI_ROUTE;
+		return renderNativeApiReferenceHtml({
+			model,
+			pageTitle: buildApiReferencePageTitle(config, version ? `${title} – ${version.label}` : title),
+			title: version ? `${title} – ${version.label}` : title,
+			description: typeof info?.description === "string" && info.description.trim() ? info.description : config.metadata?.description,
+			basePath,
+			openApiUrl,
+			activeVersion: version?.id,
+			versions: apiReference.versions.map((entry) => ({
+				id: entry.id,
+				label: entry.label,
+				href: `/${apiReference.path}/${encodeURIComponent(entry.id)}`,
+				active: entry.id === version?.id
+			})),
+			theme: resolveTheme(config)
+		});
+	}
+	const title = options.title ?? "API Reference";
+	return getHtmlDocument({
+		pageTitle: buildApiReferencePageTitle(config, title),
+		title,
+		content: () => document,
+		theme: "deepSpace",
+		layout: "modern",
+		customCss: buildApiReferenceScalarCss(config),
+		pathRouting: { basePath },
+		showSidebar: true,
+		defaultOpenFirstTag: true,
+		tagsSorter: "alpha",
+		operationsSorter: "alpha",
+		operationTitleSource: "summary",
+		defaultHttpClient: {
+			targetKey: "shell",
+			clientKey: "curl"
+		},
+		documentDownloadType: "json"
+	});
+}
+async function fetchRemoteOpenApiDocument(specUrl, baseUrl, overlays = [], rootDir = process.cwd()) {
+	let url;
+	try {
+		url = baseUrl ? new URL(specUrl, baseUrl) : new URL(specUrl);
+	} catch {
+		throw new Error(baseUrl ? "`apiReference.specUrl` must be an absolute URL or a request-relative path." : "`apiReference.specUrl` must be an absolute URL.");
+	}
+	const entry = await fetchOpenApiReferenceDocument(url, true);
+	return resolveOpenApiReferences(await applyConfiguredOpenApiOverlaysAsync(entry.document, overlays, rootDir, baseUrl), {
+		sourceUri: entry.uri,
+		loadDocument: async (referenceUrl) => {
+			if (referenceUrl.protocol !== "http:" && referenceUrl.protocol !== "https:") throw new Error(`Remote OpenAPI documents cannot load non-HTTP references: ${referenceUrl.href}`);
+			return fetchOpenApiReferenceDocument(referenceUrl, false);
+		}
+	});
+}
+async function fetchOpenApiReferenceDocument(url, validateContract) {
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("`apiReference.specUrl` must use HTTP or HTTPS for remote documents.");
+	const abortController = new AbortController();
+	const timeout = setTimeout(() => abortController.abort(), OPENAPI_SPEC_FETCH_TIMEOUT_MS);
+	let response;
+	let body;
+	try {
+		response = await fetch(url, {
+			headers: { accept: "application/json, application/yaml, application/x-yaml, text/yaml, text/x-yaml" },
+			redirect: "follow",
+			signal: abortController.signal
+		});
+		if (!response.ok) throw new Error(`Received ${response.status} ${response.statusText}`.trim());
+		if (response.url) {
+			const responseUrl = new URL(response.url);
+			if (responseUrl.protocol !== "http:" && responseUrl.protocol !== "https:") throw new Error("The remote OpenAPI endpoint redirected to a non-HTTP URL.");
+		}
+		body = await readOpenApiResponseBody(response);
+	} catch (error) {
+		if (abortController.signal.aborted) throw new Error(`The remote OpenAPI endpoint did not respond within ${OPENAPI_SPEC_FETCH_TIMEOUT_MS / 1e3} seconds.`);
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+	if (!body.trim()) throw new Error("The remote endpoint returned an empty response.");
+	const sourceUri = response.url || url.href;
+	return {
+		uri: sourceUri,
+		document: parseOpenApiDocument(body, sourceUri, response.headers.get("content-type"), "remote", validateContract)
+	};
+}
+async function readOpenApiResponseBody(response) {
+	const contentLength = response.headers.get("content-length");
+	if (contentLength) {
+		const declaredBytes = Number(contentLength);
+		if (Number.isFinite(declaredBytes) && declaredBytes > OPENAPI_SPEC_MAX_BYTES) throw new Error(`The remote OpenAPI document exceeds the ${formatByteLimit(OPENAPI_SPEC_MAX_BYTES)} size limit.`);
+	}
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let receivedBytes = 0;
+	let body = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			receivedBytes += value.byteLength;
+			if (receivedBytes > OPENAPI_SPEC_MAX_BYTES) {
+				await reader.cancel();
+				throw new Error(`The remote OpenAPI document exceeds the ${formatByteLimit(OPENAPI_SPEC_MAX_BYTES)} size limit.`);
+			}
+			body += decoder.decode(value, { stream: true });
+		}
+		body += decoder.decode();
+		return body;
+	} finally {
+		reader.releaseLock();
+	}
+}
+function formatByteLimit(bytes) {
+	return `${bytes / (1024 * 1024)} MiB`;
+}
+function readLocalOpenApiDocument(specUrl, rootDir = process.cwd(), overlays = []) {
+	const filePath = resolveLocalOpenApiFilePath(specUrl, rootDir);
+	const document = readOpenApiFileDocument(filePath, true);
+	const trustedRoot = specUrl.startsWith("file:") ? void 0 : realpathSync(resolve(rootDir));
+	return resolveOpenApiReferencesSync(applyConfiguredOpenApiOverlaysSync(document, overlays, rootDir), {
+		sourceUri: pathToFileURL(filePath).href,
+		loadDocument: (referenceUrl) => {
+			if (referenceUrl.protocol === "http:" || referenceUrl.protocol === "https:") throw new Error("Remote OpenAPI references require the async API reference builder.");
+			return readOpenApiFileReference(referenceUrl, trustedRoot);
+		}
+	});
+}
+async function readLocalOpenApiDocumentAsync(specUrl, rootDir = process.cwd(), overlays = [], baseUrl) {
+	const filePath = resolveLocalOpenApiFilePath(specUrl, rootDir);
+	const document = await readOpenApiFileDocumentAsync(filePath, true);
+	const trustedRoot = specUrl.startsWith("file:") ? void 0 : realpathSync(resolve(rootDir));
+	return resolveOpenApiReferences(await applyConfiguredOpenApiOverlaysAsync(document, overlays, rootDir, baseUrl), {
+		sourceUri: pathToFileURL(filePath).href,
+		loadDocument: async (referenceUrl, fromUrl) => {
+			if (referenceUrl.protocol === "http:" || referenceUrl.protocol === "https:") return fetchOpenApiReferenceDocument(referenceUrl, false);
+			if (fromUrl.protocol === "http:" || fromUrl.protocol === "https:") throw new Error(`Remote OpenAPI documents cannot load local file references: ${referenceUrl.href}`);
+			return readOpenApiFileReferenceAsync(referenceUrl, trustedRoot);
+		}
+	});
+}
+function applyConfiguredOpenApiOverlaysSync(document, overlays, rootDir) {
+	if (overlays.length === 0) return document;
+	const result = applyOpenApiOverlayDocuments(document, overlays.map((source) => {
+		if (!isLocalSpecSource(source)) throw new Error("Remote OpenAPI overlays require the async API reference builder.");
+		return {
+			source,
+			document: readOpenApiFileDocument(resolveLocalOpenApiFilePath(source, rootDir), false)
+		};
+	}));
+	assertValidOpenApiContract(result);
+	return result;
+}
+async function applyConfiguredOpenApiOverlaysAsync(document, overlays, rootDir, baseUrl) {
+	if (overlays.length === 0) return document;
+	const result = applyOpenApiOverlayDocuments(document, await Promise.all(overlays.map(async (source) => {
+		if (isLocalSpecSource(source)) return {
+			source,
+			document: await readOpenApiFileDocumentAsync(resolveLocalOpenApiFilePath(source, rootDir), false)
+		};
+		let url;
+		try {
+			url = baseUrl ? new URL(source, baseUrl) : new URL(source);
+		} catch {
+			throw new Error(baseUrl ? `OpenAPI overlay \`${source}\` must be an absolute URL or a request-relative path.` : `OpenAPI overlay \`${source}\` must be an absolute URL.`);
+		}
+		return {
+			source,
+			document: (await fetchOpenApiReferenceDocument(url, false)).document
+		};
+	})));
+	assertValidOpenApiContract(result);
+	return result;
+}
+function readOpenApiFileReference(url, trustedRoot) {
+	if (url.protocol !== "file:") throw new Error(`Local OpenAPI documents cannot load this reference: ${url.href}`);
+	const filePath = resolveReferencedOpenApiFilePath(url, trustedRoot);
+	return {
+		uri: pathToFileURL(filePath).href,
+		document: readOpenApiFileDocument(filePath, false)
+	};
+}
+async function readOpenApiFileReferenceAsync(url, trustedRoot) {
+	if (url.protocol !== "file:") throw new Error(`Local OpenAPI documents cannot load this reference: ${url.href}`);
+	const filePath = resolveReferencedOpenApiFilePath(url, trustedRoot);
+	return {
+		uri: pathToFileURL(filePath).href,
+		document: await readOpenApiFileDocumentAsync(filePath, false)
+	};
+}
+function readOpenApiFileDocument(filePath, validateContract) {
+	assertOpenApiFileSize(filePath);
+	const body = readFileSync(filePath, "utf-8");
+	if (!body.trim()) throw new Error(`The local OpenAPI file is empty: ${filePath}`);
+	return parseOpenApiDocument(body, filePath, void 0, "local", validateContract);
+}
+async function readOpenApiFileDocumentAsync(filePath, validateContract) {
+	assertOpenApiFileSize(filePath);
+	const body = await readFile(filePath, "utf-8");
+	if (!body.trim()) throw new Error(`The local OpenAPI file is empty: ${filePath}`);
+	return parseOpenApiDocument(body, filePath, void 0, "local", validateContract);
+}
+function assertOpenApiFileSize(filePath) {
+	if (statSync(filePath).size > OPENAPI_SPEC_MAX_BYTES) throw new Error(`The local OpenAPI document exceeds the ${formatByteLimit(OPENAPI_SPEC_MAX_BYTES)} size limit: ${filePath}`);
+}
+function resolveLocalOpenApiFilePath(specUrl, rootDir) {
+	if (specUrl.startsWith("file:")) return fileURLToPath(new URL(specUrl));
+	const resolvedRoot = resolve(rootDir);
+	return resolveContainedOpenApiFilePath(resolve(resolvedRoot, specUrl), realpathSync(resolvedRoot));
+}
+function resolveReferencedOpenApiFilePath(url, trustedRoot) {
+	const filePath = fileURLToPath(url);
+	return trustedRoot ? resolveContainedOpenApiFilePath(filePath, trustedRoot) : realpathSync(filePath);
+}
+function resolveContainedOpenApiFilePath(filePath, realRoot) {
+	const realFilePath = realpathSync(filePath);
+	const relativePath = relative(realRoot, realFilePath);
+	if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) throw new Error("Project-relative OpenAPI files must stay inside the project root. Use an explicit `file:` URL for an external local file.");
+	return realFilePath;
+}
+function parseOpenApiDocument(body, source, contentType, sourceKind, validateContract = true) {
+	const extension = getOpenApiSourceExtension(source);
+	const normalizedContentType = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+	const format = normalizedContentType?.includes("yaml") || extension === ".yaml" || extension === ".yml" ? "yaml" : normalizedContentType?.includes("json") || extension === ".json" ? "json" : "auto";
+	let parsed;
+	try {
+		if (format === "yaml") parsed = parse(body);
+		else if (format === "json") parsed = JSON.parse(body);
+		else try {
+			parsed = JSON.parse(body);
+		} catch {
+			parsed = parse(body);
+		}
+	} catch {
+		const location = sourceKind === "remote" ? "remote endpoint" : "local file";
+		const verb = sourceKind === "remote" ? "return" : "contain";
+		const expectedFormat = format === "auto" ? "JSON or YAML" : format.toUpperCase();
+		throw new Error(`The ${location} did not ${verb} valid ${expectedFormat}.`);
+	}
+	if (validateContract && (!parsed || typeof parsed !== "object" || Array.isArray(parsed))) throw new Error("The configured source contains a value instead of an OpenAPI object.");
+	if (validateContract) assertValidOpenApiContract(parsed);
+	return parsed;
+}
+function getOpenApiSourceExtension(source) {
+	try {
+		return extname(new URL(source, "https://farming-labs.invalid").pathname).toLowerCase();
+	} catch {
+		return extname(source).toLowerCase();
+	}
+}
+function normalizeConfiguredOpenApiDocument(document, config, baseUrl, specUrl, version) {
+	const info = document.info && typeof document.info === "object" && !Array.isArray(document.info) ? document.info : {};
+	const model = buildNormalizedOpenApiModel(document);
+	const normalizedPaths = normalizeRemoteOpenApiPaths(document.paths);
+	const normalizedTags = normalizeRemoteOpenApiTags(document.tags, normalizedPaths, model.tags);
+	const normalizedServers = isRequestRelativeSpecUrl(specUrl) ? [{ url: baseUrl ?? "/" }] : document.servers;
+	return {
+		...document,
+		info: {
+			title: "API Reference",
+			version: "0.0.0",
+			...info,
+			description: typeof info.description === "string" && info.description.trim() ? info.description : config.metadata?.description
+		},
+		servers: normalizedServers,
+		paths: normalizedPaths,
+		tags: normalizedTags,
+		...version ? { "x-farming-labs-api-version": {
+			id: version.id,
+			label: version.label,
+			default: version.default
+		} } : {}
+	};
+}
+function normalizeRemoteOpenApiPaths(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const paths = value;
+	const normalized = {};
+	for (const [routePath, pathItem] of Object.entries(paths)) {
+		if (!pathItem || typeof pathItem !== "object" || Array.isArray(pathItem)) continue;
+		const normalizedPathItem = { ...pathItem };
+		for (const method of [
+			"get",
+			"post",
+			"put",
+			"patch",
+			"delete",
+			"options",
+			"head",
+			"trace"
+		]) {
+			const operation = normalizedPathItem[method];
+			if (!operation || typeof operation !== "object" || Array.isArray(operation)) continue;
+			const operationRecord = operation;
+			const tags = Array.isArray(operationRecord.tags) ? operationRecord.tags.filter((tag) => typeof tag === "string" && tag.trim().length > 0) : [];
+			normalizedPathItem[method] = {
+				...operationRecord,
+				tags: tags.length > 0 ? tags : [inferRemoteOpenApiTag(routePath)]
+			};
+		}
+		normalized[routePath] = normalizedPathItem;
+	}
+	return normalized;
+}
+function inferRemoteOpenApiTag(routePath) {
+	return humanizeSegment(routePath.split("/").filter(Boolean).find((value) => !value.startsWith("{")) ?? "general");
+}
+function normalizeRemoteOpenApiTags(value, paths, modelTags = []) {
+	const existingTags = Array.isArray(value) ? value.filter((tag) => !!tag && typeof tag === "object") : [];
+	const tagsByName = /* @__PURE__ */ new Map();
+	for (const tag of existingTags) {
+		const name = typeof tag.name === "string" && tag.name.trim() ? tag.name.trim() : void 0;
+		if (!name) continue;
+		tagsByName.set(name, tag);
+	}
+	for (const name of modelTags) if (!tagsByName.has(name)) tagsByName.set(name, {
+		name,
+		description: `${name} endpoints`
+	});
+	if (paths) for (const pathItem of Object.values(paths)) for (const method of [
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete",
+		"options",
+		"head",
+		"trace"
+	]) {
+		const operation = pathItem[method];
+		if (!operation || typeof operation !== "object" || Array.isArray(operation)) continue;
+		const tags = Array.isArray(operation.tags) ? operation.tags : [];
+		for (const tag of tags) {
+			if (typeof tag !== "string" || !tag.trim()) continue;
+			if (!tagsByName.has(tag)) tagsByName.set(tag, {
+				name: tag,
+				description: `${tag} endpoints`
+			});
+		}
+	}
+	if (tagsByName.size === 0) return [{
+		name: "General",
+		description: "General endpoints"
+	}];
+	return Array.from(tagsByName.values());
+}
+function buildUnavailableOpenApiDocument(config, description) {
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "API Reference",
+			description,
+			version: "0.0.0"
+		},
+		servers: [{ url: "/" }],
+		tags: [{
+			name: "Unavailable",
+			description: config.metadata?.description ?? "OpenAPI spec could not be loaded."
+		}],
+		paths: {}
+	};
+}
+function buildApiReferenceRoutes(config, options) {
+	const apiReference = resolveApiReferenceConfig(config.apiReference);
+	if (!apiReference.enabled) return [];
+	const rootDir = options.rootDir ?? process.cwd();
+	switch (options.framework) {
+		case "next": return buildFileConventionRoutes({
+			rootDir,
+			sourceDir: resolveRootedDir(rootDir, apiReference.routeRoot, getNextAppDir(rootDir)),
+			routePathBase: toRouteBase(apiReference.routeRoot, getNextAppDir(rootDir)),
+			isRouteFile: (name) => NEXT_ROUTE_FILE_RE.test(name),
+			toRouteSegments: (relativeFile) => relativeFile.split("/").slice(0, -1).filter(Boolean),
+			exclude: apiReference.exclude
+		});
+		case "farmjs": return buildFileConventionRoutes({
+			rootDir,
+			sourceDir: resolveRootedDir(rootDir, apiReference.routeRoot, getFarmAppDir(rootDir)),
+			routePathBase: toRouteBase(apiReference.routeRoot, getFarmAppDir(rootDir)),
+			isRouteFile: (name) => NEXT_ROUTE_FILE_RE.test(name),
+			toRouteSegments: (relativeFile) => relativeFile.split("/").slice(0, -1).filter(Boolean),
+			exclude: apiReference.exclude
+		});
+		case "sveltekit": return buildFileConventionRoutes({
+			rootDir,
+			sourceDir: resolveRootedDir(rootDir, apiReference.routeRoot, "src/routes"),
+			routePathBase: toRouteBase(apiReference.routeRoot, "src/routes"),
+			isRouteFile: (name) => SVELTE_ROUTE_FILE_RE.test(name),
+			toRouteSegments: (relativeFile) => relativeFile.split("/").slice(0, -1).filter(Boolean),
+			exclude: apiReference.exclude
+		});
+		case "astro": return buildFileConventionRoutes({
+			rootDir,
+			sourceDir: resolveRootedDir(rootDir, apiReference.routeRoot, "src/pages"),
+			routePathBase: toRouteBase(apiReference.routeRoot, "src/pages"),
+			isRouteFile: (name) => ASTRO_ROUTE_FILE_RE.test(name),
+			toRouteSegments: (relativeFile) => routeSegmentsFromEndpointFile(relativeFile),
+			exclude: apiReference.exclude
+		});
+		case "nuxt": return buildFileConventionRoutes({
+			rootDir,
+			sourceDir: resolveRootedDir(rootDir, apiReference.routeRoot, "server"),
+			routePathBase: toRouteBase(apiReference.routeRoot, "server"),
+			isRouteFile: (name) => NUXT_ROUTE_FILE_RE.test(name),
+			toRouteSegments: (relativeFile) => routeSegmentsFromEndpointFile(stripNuxtMethodSuffix(relativeFile)),
+			exclude: apiReference.exclude,
+			getMethods: (source, file) => extractNuxtMethods(source, file)
+		});
+		case "tanstack-start": return buildTanstackRoutes(rootDir, apiReference);
+	}
+}
+function getFarmAppDir(rootDir) {
+	return existsSync(join(rootDir, "src", "app")) ? "src/app" : "app";
+}
+function buildFileConventionRoutes({ rootDir, sourceDir, routePathBase, isRouteFile, toRouteSegments, exclude, getMethods = extractMethods }) {
+	const files = scanRouteFiles(sourceDir, isRouteFile);
+	const routes = [];
+	for (const file of files) {
+		const source = readFileSync(file, "utf-8");
+		const methods = getMethods(source, file);
+		if (methods.length === 0) continue;
+		const relativeFile = relative(sourceDir, file).replace(/\\/g, "/");
+		const routeSegments = toRouteSegments(relativeFile);
+		const routePath = buildRoutePath(routePathBase, routeSegments);
+		if (shouldExcludeRoute(exclude, routePath, relativeFile, routeSegments.join("/"))) continue;
+		routes.push(createApiReferenceRoute({
+			rootDir,
+			file,
+			source,
+			methods,
+			routePath
+		}));
+	}
+	return routes.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+function buildTanstackRoutes(rootDir, apiReference) {
+	const routesDir = join(rootDir, "src", "routes");
+	const files = scanRouteFiles(routesDir, (name) => TANSTACK_ROUTE_FILE_RE.test(name));
+	const routeBase = `/${normalizePathSegment(apiReference.routeRoot)}`;
+	const routes = [];
+	for (const file of files) {
+		const source = readFileSync(file, "utf-8");
+		if (!source.includes("createFileRoute(") || !source.includes("handlers")) continue;
+		const pathMatch = source.match(/createFileRoute\(\s*["'`]([^"'`]+)["'`]\s*\)/);
+		if (!pathMatch) continue;
+		const routePath = normalizeTanstackRoutePath(pathMatch[1]);
+		if (!routePath.startsWith(routeBase)) continue;
+		const methods = extractTanstackMethods(source);
+		if (methods.length === 0) continue;
+		const relativeFile = relative(routesDir, file).replace(/\\/g, "/");
+		if (shouldExcludeRoute(apiReference.exclude, routePath, relativeFile, relativeFile)) continue;
+		routes.push(createApiReferenceRoute({
+			rootDir,
+			file,
+			source,
+			methods,
+			routePath
+		}));
+	}
+	return routes.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+function createApiReferenceRoute({ rootDir, file, source, methods, routePath }) {
+	const docBlock = extractDocBlock(source);
+	const pathSegments = routePath.split("/").filter(Boolean);
+	const titleSegment = pathSegments[pathSegments.length - 1] ?? "overview";
+	const tagSegment = pathSegments[0] ?? "general";
+	const title = humanizeSegment(titleSegment);
+	return {
+		title,
+		summary: docBlock.summary ?? `${title} endpoint`,
+		description: docBlock.description,
+		routePath,
+		sourceFile: relative(rootDir, file).replace(/\\/g, "/"),
+		methods,
+		tag: humanizeSegment(tagSegment),
+		parameters: buildPathParameters(routePath)
+	};
+}
+function buildPathParameters(routePath) {
+	const parameters = [];
+	for (const segment of routePath.split("/")) {
+		const match = segment.match(/^\{(.+)\}$/);
+		if (!match) continue;
+		parameters.push({
+			name: match[1],
+			in: "path",
+			required: true,
+			description: `${humanizeSegment(match[1])} path parameter.`,
+			schema: { type: "string" }
+		});
+	}
+	return parameters;
+}
+function buildOpenApiPaths(routes) {
+	const paths = {};
+	for (const route of routes) {
+		const pathItem = {};
+		for (const method of route.methods) pathItem[method.toLowerCase()] = {
+			tags: [route.tag],
+			summary: route.summary,
+			description: route.description ?? route.summary,
+			operationId: createOperationId(route, method),
+			...route.parameters.length > 0 ? { parameters: route.parameters } : {},
+			...buildRequestBody(method) ? { requestBody: buildRequestBody(method) } : {},
+			responses: buildResponses(method),
+			"x-farming-labs-source": route.sourceFile
+		};
+		paths[route.routePath] = pathItem;
+	}
+	return paths;
+}
+function buildRequestBody(method) {
+	if (![
+		"POST",
+		"PUT",
+		"PATCH"
+	].includes(method)) return void 0;
+	return {
+		required: method === "POST",
+		content: { "application/json": {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			example: { example: true }
+		} }
+	};
+}
+function buildResponses(method) {
+	return { "200": {
+		description: method === "DELETE" ? "Resource removed successfully." : "Request completed successfully.",
+		content: { "application/json": {
+			schema: {
+				type: "object",
+				additionalProperties: true
+			},
+			example: { ok: true }
+		} }
+	} };
+}
+function createOperationId(route, method) {
+	return `${method.toLowerCase()}_${route.routePath.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+}
+function resolveTheme(config) {
+	return config.theme;
+}
+function normalizeApiReferenceExcludes(values) {
+	return (values ?? []).map(normalizeExcludeMatcher).filter(Boolean);
+}
+function normalizeExcludeMatcher(value) {
+	return value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.(ts|tsx|js|jsx|mjs|mts)$/i, "").replace(/\/route$/i, "").replace(/\/\+server$/i, "").replace(/\/index$/i, "").replace(/\.(get|post|put|patch|delete|options|head)$/i, "");
+}
+function shouldExcludeRoute(excludes, routePath, relativeFile, relativeDir) {
+	if (excludes.length === 0) return false;
+	const candidates = new Set([
+		normalizeExcludeMatcher(routePath),
+		normalizeExcludeMatcher(routePath.replace(/^\/+/, "")),
+		normalizeExcludeMatcher(relativeFile),
+		normalizeExcludeMatcher(relativeDir)
+	]);
+	return excludes.some((entry) => candidates.has(entry));
+}
+function scanRouteFiles(dir, isRouteFile) {
+	if (!existsSync(dir)) return [];
+	const results = [];
+	for (const name of readdirSync(dir)) {
+		const full = join(dir, name);
+		if (statSync(full).isDirectory()) {
+			results.push(...scanRouteFiles(full, isRouteFile));
+			continue;
+		}
+		if (isRouteFile(name)) results.push(full);
+	}
+	return results;
+}
+function resolveRootedDir(rootDir, routeRoot, defaultRoot) {
+	const normalized = normalizePathSegment(routeRoot) || "api";
+	if (normalized === defaultRoot || normalized.startsWith(`${defaultRoot}/`)) return join(rootDir, ...normalized.split("/"));
+	return join(rootDir, ...defaultRoot.split("/"), ...normalized.split("/"));
+}
+function toRouteBase(routeRoot, defaultRoot) {
+	const normalized = normalizePathSegment(routeRoot) || "api";
+	return `/${normalizePathSegment(normalized === defaultRoot || normalized.startsWith(`${defaultRoot}/`) ? normalized.slice(defaultRoot.length).replace(/^\/+/, "") : normalized)}`;
+}
+function getNextAppDir(rootDir) {
+	if (existsSync(join(rootDir, "src", "app"))) return "src/app";
+	return "app";
+}
+function routeSegmentsFromEndpointFile(relativeFile) {
+	const segments = relativeFile.split("/");
+	const name = (segments.pop() ?? "").replace(/\.(ts|js|mts|mjs)$/i, "");
+	if (name !== "index") segments.push(name);
+	return segments.filter(Boolean);
+}
+function stripNuxtMethodSuffix(relativeFile) {
+	return relativeFile.replace(/\.(get|post|put|patch|delete|options|head)(?=\.(ts|js|mts|mjs)$)/i, "");
+}
+function buildRoutePath(basePath, rawSegments) {
+	const segments = rawSegments.filter(Boolean).map((segment) => endpointSegmentFromConvention(segment)).join("/");
+	const path = [normalizePathSegment(basePath), segments].filter(Boolean).join("/");
+	return path ? `/${path}` : "/";
+}
+function endpointSegmentFromConvention(value) {
+	if (value.startsWith("[[...") && value.endsWith("]]")) return `{${value.slice(5, -2)}}`;
+	if (value.startsWith("[...") && value.endsWith("]")) return `{${value.slice(4, -1)}}`;
+	if (value.startsWith("[") && value.endsWith("]")) return `{${value.slice(1, -1)}}`;
+	return value;
+}
+function normalizeTanstackRoutePath(value) {
+	return `/${value.replace(/^\/+|\/+$/g, "").split("/").map((segment) => segment.startsWith("$") ? `{${segment.slice(1)}}` : segment).filter(Boolean).join("/")}`;
+}
+function extractDocBlock(source) {
+	const match = source.match(/\/\*\*([\s\S]*?)\*\//);
+	if (!match) return {};
+	const lines = match[1].split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter(Boolean).filter((line) => !line.startsWith("@"));
+	if (lines.length === 0) return {};
+	return {
+		summary: lines[0],
+		description: lines.slice(1).join(" ")
+	};
+}
+function extractMethods(source) {
+	const methods = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(METHOD_RE)) {
+		if (match[1] === "ALL") {
+			METHOD_NAMES.forEach((method) => methods.add(method));
+			continue;
+		}
+		methods.add(match[1]);
+	}
+	return Array.from(methods);
+}
+function extractNuxtMethods(source, file) {
+	const methods = extractMethods(source);
+	if (methods.length > 0) return methods;
+	const suffix = basename(file).match(/\.(get|post|put|patch|delete|options|head)\.(ts|js|mts|mjs)$/i);
+	if (suffix) return [suffix[1].toUpperCase()];
+	if (/defineEventHandler|eventHandler/.test(source)) return ["GET"];
+	return [];
+}
+function extractTanstackMethods(source) {
+	const methods = /* @__PURE__ */ new Set();
+	const handlersMatch = source.match(/handlers\s*:\s*\{([\s\S]*?)\}/m);
+	if (!handlersMatch) return [];
+	for (const match of handlersMatch[1].matchAll(/\b(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*:/g)) methods.add(match[1]);
+	return Array.from(methods);
+}
+function humanizeSegment(value) {
+	return value.replace(/^\{/, "").replace(/\}$/, "").replace(/^\[\[?\.{3}/, "").replace(/^\[/, "").replace(/\]\]?$/, "").replace(/^\$/, "").replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+//#endregion
+export { validateOpenApiContract as _, buildApiReferenceOpenApiDocumentAsync as a, buildApiReferenceScalarCss as c, loadApiReferenceOpenApiDocumentAsync as d, resolveApiReferenceConfig as f, resolveApiReferenceVersionFromPathname as g, resolveApiReferenceVersion as h, buildApiReferenceOpenApiDocument as i, createApiReferenceOperationMarkdownResponse as l, resolveApiReferenceRenderer as m, buildApiReferenceHtmlDocument as n, buildApiReferenceOperationPagesAsync as o, resolveApiReferenceOpenApiDiscovery as p, buildApiReferenceHtmlDocumentAsync as r, buildApiReferencePageTitle as s, DEFAULT_API_REFERENCE_OPENAPI_ROUTE as t, isApiReferenceOpenApiRequest as u };