@farming-labs/next 0.2.120 → 0.2.122

package/dist/config-woF1rXS1.mjs

@@ -0,0 +1,2345 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_A2A_AGENT_CARD_ROUTE, DEFAULT_AGENT_SKILLS_INDEX_ROUTE, DEFAULT_AGENT_SKILLS_ROUTE_PREFIX, DEFAULT_AGENT_SKILL_ARCHIVE_FORMAT, DEFAULT_API_CATALOG_ROUTE, DEFAULT_LEGACY_SKILLS_INDEX_ROUTE, DEFAULT_LEGACY_SKILLS_ROUTE_PREFIX, DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN, DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN, DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN, ensureDocsReviewWorkflow, renderDocsAgentSkillsBundle, resolveConfiguredAgentSkillsSync } from "@farming-labs/docs/build";
+import matter from "gray-matter";
+import { parse } from "@babel/parser";
+import createMDX from "@next/mdx";
+
+//#region src/package-resolution.ts
+/** Pin shared packages without replacing exported subpaths with filesystem paths. */
+var DocsPackageResolutionPlugin = class {
+	roots;
+	constructor(packages) {
+		this.roots = new Map(Object.entries(packages).filter(([, directory]) => isAbsolute(directory)).map(([name, directory]) => [name, dirname(dirname(directory))]));
+	}
+	apply(resolver) {
+		resolver.getHook("described-resolve").tapAsync("DocsPackageResolutionPlugin", (request, context, done) => {
+			const name = request.request;
+			if (!name) return done();
+			const entry = [...this.roots].find(([pkg]) => name === pkg || name.startsWith(`${pkg}/`));
+			if (!entry || request.path === entry[1]) return done();
+			resolver.doResolve(resolver.ensureHook("resolve"), {
+				...request,
+				path: entry[1],
+				descriptionFilePath: void 0,
+				descriptionFileRoot: void 0,
+				descriptionFileData: void 0,
+				relativePath: void 0
+			}, `resolve shared docs package ${name}`, context, done);
+		});
+	}
+};
+
+//#endregion
+//#region src/code-block-themes.ts
+const DEFAULT_CODE_BLOCK_THEMES = {
+	light: "github-light",
+	dark: "github-dark"
+};
+const SHADCN_CODE_BLOCK_THEMES = {
+	light: "github-light-default",
+	dark: "vesper"
+};
+const SHADCN_THEME_IMPORT = /(?:from\s*|import\s*)["']@farming-labs\/theme\/shadcn["']/;
+function resolveCodeBlockThemes({ root, configPath, theme, readSource = (path) => readFileSync(path, "utf8") }) {
+	const configFile = join(root, configPath);
+	const fallback = existsSync(configFile) && SHADCN_THEME_IMPORT.test(readSource(configFile)) ? SHADCN_CODE_BLOCK_THEMES : DEFAULT_CODE_BLOCK_THEMES;
+	const codeBlock = theme?.ui?.codeBlock;
+	return {
+		light: codeBlock?.theme ?? fallback.light,
+		dark: codeBlock?.darkTheme ?? fallback.dark
+	};
+}
+
+//#endregion
+//#region src/mdx-options.ts
+function isJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || seen.has(value)) return false;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+	seen.add(value);
+	const valid = Object.values(value).every((item) => isJsonValue(item, seen));
+	seen.delete(value);
+	return valid;
+}
+function copyPlugin(plugin) {
+	const module = Array.isArray(plugin) ? plugin[0] : plugin;
+	if (typeof module !== "string" || !module.trim() || Array.isArray(plugin) && plugin.length > 2) throw new TypeError("withDocs MDX plugins must be module names/paths or [module, JSON options] tuples.");
+	if (!Array.isArray(plugin)) return plugin;
+	if (plugin[1] === void 0) return [module];
+	if (!isJsonValue(plugin[1])) throw new TypeError(`withDocs MDX plugin ${module} requires JSON-serializable options for Turbopack. Put callbacks in the plugin module instead.`);
+	return [module, JSON.parse(JSON.stringify(plugin[1]))];
+}
+function resolveMdxExtensions(options) {
+	return {
+		remarkPlugins: (options?.remarkPlugins ?? []).map(copyPlugin),
+		rehypePlugins: (options?.rehypePlugins ?? []).map(copyPlugin),
+		codeHighlighter: options?.codeHighlighter === void 0 ? void 0 : copyPlugin(options.codeHighlighter)
+	};
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Next.js config wrapper for @farming-labs/docs.
+* Handles MDX compilation, frontmatter, syntax highlighting, TOC extraction,
+* and auto-generates mdx-components.tsx + docs layout when missing.
+*
+* @example
+* // next.config.ts — this is all you need:
+*   import { withDocs } from "@farming-labs/next/config";
+*   export default withDocs();
+*
+* @example
+* // With existing Next.js config
+*   import { withDocs } from "@farming-labs/next/config";
+*   export default withDocs({
+*     images: { remotePatterns: [{ hostname: "example.com" }] },
+*   });
+*
+* @example
+* // Full static export (Cloudflare Pages, etc.) — no server; API route is skipped.
+* // In docs.config set ai.enabled: false and staticExport: true.
+*   export default withDocs({ output: "export" });
+*/
+/** Resolve Next.js App Router directory: prefer src/app when present, else app. */
+function getNextAppDir(root) {
+	if (existsSync(join(root, "src", "app"))) return "src/app";
+	return "app";
+}
+const GENERATED_BANNER = "// Auto-generated by @farming-labs/next — do not edit manually.\n";
+const MDX_COMPONENTS_TEMPLATE = `\
+${GENERATED_BANNER}
+import { getMDXComponents, type GetMDXComponentsOptions } from "@farming-labs/theme/mdx";
+import type { MDXComponents } from "mdx/types";
+import docsConfig from "@/docs.config";
+
+export function useMDXComponents(components?: MDXComponents): MDXComponents {
+  const promptIconRegistry = docsConfig.icons as GetMDXComponentsOptions["icons"];
+  const promptOpenDocsProviders =
+    docsConfig.pageActions?.openDocs && typeof docsConfig.pageActions.openDocs === "object"
+      ? (docsConfig.pageActions.openDocs.providers as GetMDXComponentsOptions["openDocsProviders"])
+      : undefined;
+
+  return getMDXComponents(
+    {
+      ...(docsConfig.components as MDXComponents),
+      ...components,
+    },
+    {
+      onCopyClick: docsConfig.onCopyClick,
+      theme: docsConfig.theme,
+      icons: promptIconRegistry,
+      openDocsProviders: promptOpenDocsProviders,
+    },
+  );
+}
+`;
+const DOCS_LAYOUT_TEMPLATE = `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+import { createNextDocsLayout, createNextDocsMetadata } from "@farming-labs/next/layout";
+
+export const metadata = createNextDocsMetadata(docsConfig);
+
+const DocsLayout = createNextDocsLayout(docsConfig);
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return <DocsLayout>{children}</DocsLayout>;
+}
+`;
+const DOCS_API_ROUTE_TEMPLATE = `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+import { createDocsAPI } from "@farming-labs/next/api";
+import { createDocsCloudServer } from "@farming-labs/docs/cloud/server";
+
+const docsCloud = createDocsCloudServer({
+  config: docsConfig,
+});
+
+export const { GET, HEAD, POST } = createDocsAPI(docsConfig, docsCloud);
+
+export const revalidate = false;
+`;
+const DOCS_MCP_ROUTE_TEMPLATE = `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+import { createDocsMCPAPI } from "@farming-labs/next/api";
+
+export const { GET, POST, DELETE, OPTIONS } = createDocsMCPAPI(docsConfig);
+
+export const revalidate = false;
+`;
+const API_REFERENCE_ROUTE_TEMPLATE = `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+import { createNextApiReference } from "@farming-labs/next/api-reference";
+
+export const GET = createNextApiReference(docsConfig);
+
+export const revalidate = false;
+`;
+const API_REFERENCE_PAGE_TEMPLATE = `\
+${GENERATED_BANNER}
+import "@farming-labs/next/api-reference.css";
+import docsConfig from "@/docs.config";
+import { createNextApiReferencePage } from "@farming-labs/next/api-reference";
+
+const ApiReferencePage = createNextApiReferencePage(docsConfig);
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+export default ApiReferencePage;
+`;
+const API_REFERENCE_LAYOUT_TEMPLATE = `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+import { createNextApiReferenceLayout } from "@farming-labs/next/api-reference";
+
+const ApiReferenceLayout = createNextApiReferenceLayout(docsConfig);
+
+export default ApiReferenceLayout;
+`;
+const CHANGELOG_SOURCE_LAYOUT_TEMPLATE = `\
+${GENERATED_BANNER}
+import { notFound } from "next/navigation";
+
+export default function HiddenChangelogSourceLayout() {
+  notFound();
+}
+`;
+const FILE_EXTS = [
+	"tsx",
+	"ts",
+	"jsx",
+	"js"
+];
+const INTERNAL_DOCS_CONFIG_ALIAS = "@farming-labs/next-internal-docs-config";
+const AGENT_SKILLS_BUNDLE_ALIAS = "@farming-labs/docs/agent-skills-bundle";
+const AGENT_SKILLS_BUNDLE_PATH = ".docs/agent-skills-bundle.mjs";
+const NEXT_PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const DEFAULT_AGENT_SPEC_ROUTE = "/api/docs/agent/spec";
+const DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE = "/.well-known/agent";
+const DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE = "/.well-known/agent.json";
+const DEFAULT_AGENT_FEEDBACK_ROUTE = "/api/docs/agent/feedback";
+const DEFAULT_MCP_ROUTE = "/api/docs/mcp";
+const DEFAULT_MCP_PUBLIC_ROUTE = "/mcp";
+const DEFAULT_MCP_WELL_KNOWN_ROUTE = "/.well-known/mcp";
+const DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE = "/.well-known/oauth-protected-resource";
+const DEFAULT_LLMS_TXT_ROUTE = "/llms.txt";
+const DEFAULT_LLMS_FULL_TXT_ROUTE = "/llms-full.txt";
+const DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms.txt";
+const DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE = "/.well-known/llms-full.txt";
+const DEFAULT_SKILL_MD_ROUTE = "/skill.md";
+const DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE = "/.well-known/skill.md";
+const DEFAULT_AGENTS_MD_ROUTE = "/AGENTS.md";
+const DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENTS.md";
+const DEFAULT_AGENT_MD_ROUTE = "/AGENT.md";
+const DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE = "/.well-known/AGENT.md";
+const DEFAULT_ROBOTS_TXT_ROUTE = "/robots.txt";
+const DEFAULT_SITEMAP_XML_ROUTE = "/sitemap.xml";
+const DEFAULT_SITEMAP_MD_ROUTE = "/sitemap.md";
+const DEFAULT_SITEMAP_MD_DOCS_ROUTE = "/docs/sitemap.md";
+const DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE = "/.well-known/sitemap.md";
+const DEFAULT_SITEMAP_MANIFEST_PATH = ".farming-labs/sitemap-manifest.json";
+const MARKDOWN_ACCEPT_HEADER_VALUE = [
+	"^",
+	"(?!.*(?:^|,)\\s*(?:[Tt][Ee][Xx][Tt]/[Hh][Tt][Mm][Ll]|[Tt][Ee][Xx][Tt]/\\*|\\*/\\*)(?:\\s*;[^,]*)?\\s*(?:,|$))",
+	"(?=.*(?:^|,)\\s*[Tt][Ee][Xx][Tt]/[Mm][Aa][Rr][Kk][Dd][Oo][Ww][Nn]",
+	"(?:\\s*;",
+	"(?!\\s*(?:[^,;]*;\\s*)*[Qq]\\s*=\\s*(?:0+(?:\\.0*)?|\\.0+)\\s*(?:;|,|$))",
+	"[^,]*)?",
+	"\\s*(?:,|$))",
+	".*$"
+].join("");
+function resolvePackageAlias(packageName, fallbacks = []) {
+	return [join(NEXT_PACKAGE_ROOT, "node_modules", packageName), ...fallbacks.map((value) => join(NEXT_PACKAGE_ROOT, value))].find((value) => existsSync(value));
+}
+function resolvePackageSubpath(packageDir, relativePath) {
+	if (!isAbsolute(packageDir)) return `${packageDir}/${relativePath.replace(/^dist\//, "").replace(/\/index\.js$/, "")}`;
+	return join(packageDir, relativePath);
+}
+function toTurbopackAliasPath(root, value) {
+	if (!isAbsolute(value)) return value;
+	const relativePath = relative(root, value).replaceAll("\\", "/");
+	return relativePath === ".." || relativePath.startsWith("../") ? relativePath : relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+}
+const FUMADOCS_OPENAPI_PACKAGE_ALIAS = resolvePackageAlias("fumadocs-openapi") ?? "fumadocs-openapi";
+const FUMADOCS_CORE_PACKAGE_ALIAS = resolvePackageAlias("fumadocs-core") ?? "fumadocs-core";
+const FUMADOCS_UI_PACKAGE_ALIAS = resolvePackageAlias("fumadocs-ui", ["node_modules/fumadocs-openapi/node_modules/fumadocs-ui", "../node_modules/fumadocs-ui"]) ?? "fumadocs-ui";
+const FUMADOCS_OPENAPI_UI_ALIAS = resolvePackageSubpath(FUMADOCS_OPENAPI_PACKAGE_ALIAS, "dist/ui/index.js");
+const FUMADOCS_OPENAPI_SERVER_ALIAS = resolvePackageSubpath(FUMADOCS_OPENAPI_PACKAGE_ALIAS, "dist/server/index.js");
+const FUMADOCS_CORE_FRAMEWORK_ALIAS = resolvePackageSubpath(FUMADOCS_CORE_PACKAGE_ALIAS, "dist/framework/index.js");
+const FUMADOCS_CORE_FRAMEWORK_NEXT_ALIAS = resolvePackageSubpath(FUMADOCS_CORE_PACKAGE_ALIAS, "dist/framework/next.js");
+const FUMADOCS_UI_NOTEBOOK_ALIAS = resolvePackageSubpath(FUMADOCS_UI_PACKAGE_ALIAS, "dist/layouts/notebook/index.js");
+const FUMADOCS_UI_NOTEBOOK_PAGE_ALIAS = resolvePackageSubpath(FUMADOCS_UI_PACKAGE_ALIAS, "dist/layouts/notebook/page/index.js");
+const FUMADOCS_UI_PROVIDER_NEXT_ALIAS = resolvePackageSubpath(FUMADOCS_UI_PACKAGE_ALIAS, "dist/provider/next.js");
+function isDocsWorkspaceRoot(root) {
+	return existsSync(join(root, "packages", "docs", "src", "index.ts")) && existsSync(join(root, "packages", "fumadocs", "src", "index.ts")) && existsSync(join(root, "packages", "next", "src", "config.ts"));
+}
+function findDocsWorkspaceRoot(start) {
+	let current = start;
+	while (true) {
+		if (isDocsWorkspaceRoot(current)) return current;
+		const parent = dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+function normalizeEnvValue(value) {
+	const normalized = value?.trim();
+	return normalized ? normalized : void 0;
+}
+function createPublicDocsCloudAnalyticsEnv() {
+	const projectId = normalizeEnvValue(process.env.NEXT_PUBLIC_DOCS_CLOUD_PROJECT_ID) ?? normalizeEnvValue(process.env.PUBLIC_DOCS_CLOUD_PROJECT_ID) ?? normalizeEnvValue(process.env.DOCS_CLOUD_PROJECT_ID);
+	const configuredEndpoint = normalizeEnvValue(process.env.NEXT_PUBLIC_DOCS_CLOUD_ANALYTICS_ENDPOINT) ?? normalizeEnvValue(process.env.PUBLIC_DOCS_CLOUD_ANALYTICS_ENDPOINT) ?? normalizeEnvValue(process.env.DOCS_CLOUD_ANALYTICS_ENDPOINT);
+	const enabled = normalizeEnvValue(process.env.NEXT_PUBLIC_DOCS_CLOUD_ANALYTICS_ENABLED) ?? normalizeEnvValue(process.env.PUBLIC_DOCS_CLOUD_ANALYTICS_ENABLED) ?? normalizeEnvValue(process.env.DOCS_CLOUD_ANALYTICS_ENABLED);
+	const env = {};
+	if (projectId) env.NEXT_PUBLIC_DOCS_CLOUD_PROJECT_ID = projectId;
+	if (configuredEndpoint) env.NEXT_PUBLIC_DOCS_CLOUD_ANALYTICS_ENDPOINT = configuredEndpoint;
+	if (enabled) env.NEXT_PUBLIC_DOCS_CLOUD_ANALYTICS_ENABLED = enabled;
+	return env;
+}
+function createDocsWorkspaceAliases(root, workspaceRoot) {
+	const workspaceAlias = (...parts) => toTurbopackAliasPath(root, join(workspaceRoot, ...parts));
+	const workspaceEntrypoint = (distParts, sourceParts) => {
+		const distPath = join(workspaceRoot, ...distParts);
+		const sourcePath = join(workspaceRoot, ...sourceParts);
+		return workspaceAlias(...existsSync(distPath) || !existsSync(sourcePath) ? distParts : sourceParts);
+	};
+	return {
+		"@farming-labs/docs": workspaceEntrypoint([
+			"packages",
+			"docs",
+			"dist",
+			"index.mjs"
+		], [
+			"packages",
+			"docs",
+			"src",
+			"index.ts"
+		]),
+		"@farming-labs/docs/server": workspaceEntrypoint([
+			"packages",
+			"docs",
+			"dist",
+			"server.mjs"
+		], [
+			"packages",
+			"docs",
+			"src",
+			"server.ts"
+		]),
+		"@farming-labs/docs/cloud/server": workspaceEntrypoint([
+			"packages",
+			"docs",
+			"dist",
+			"docs-cloud-server.mjs"
+		], [
+			"packages",
+			"docs",
+			"src",
+			"docs-cloud-server.ts"
+		]),
+		"@farming-labs/next": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"index.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"index.ts"
+		]),
+		"@farming-labs/next/api": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"api.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"api.ts"
+		]),
+		"@farming-labs/next/changelog": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"changelog.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"changelog.tsx"
+		]),
+		"@farming-labs/next/client-callbacks": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"client-callbacks.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"client-callbacks.tsx"
+		]),
+		"@farming-labs/next/layout": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"layout.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"layout.tsx"
+		]),
+		"@farming-labs/next/mdx-plugins/rehype-code": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"rehype-code.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"rehype-code.ts"
+		]),
+		"@farming-labs/next/mdx-plugins/rehype-toc": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"rehype-toc.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"rehype-toc.ts"
+		]),
+		"@farming-labs/next/mdx-plugins/remark-code-group": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"remark-code-group.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"remark-code-group.ts"
+		]),
+		"@farming-labs/next/mdx-plugins/remark-heading": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"remark-heading.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"remark-heading.ts"
+		]),
+		"@farming-labs/next/mdx-plugins/remark-og": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"remark-og.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"remark-og.ts"
+		]),
+		"@farming-labs/next/mdx-plugins/remark-markdown-alternate": workspaceEntrypoint([
+			"packages",
+			"next",
+			"dist",
+			"mdx-plugins",
+			"remark-markdown-alternate.mjs"
+		], [
+			"packages",
+			"next",
+			"src",
+			"mdx-plugins",
+			"remark-markdown-alternate.ts"
+		]),
+		"@farming-labs/theme": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"index.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"index.ts"
+		]),
+		"@farming-labs/theme/api": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"docs-api.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"docs-api.ts"
+		]),
+		"@farming-labs/theme/client-hooks": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"docs-client-hooks.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"docs-client-hooks.tsx"
+		]),
+		"@farming-labs/theme/concrete": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"concrete",
+			"index.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"concrete",
+			"index.ts"
+		]),
+		"@farming-labs/theme/hardline": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"hardline",
+			"index.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"hardline",
+			"index.ts"
+		]),
+		"@farming-labs/theme/ledger": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"ledger",
+			"index.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"ledger",
+			"index.ts"
+		]),
+		"@farming-labs/theme/shadcn": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"shadcn",
+			"index.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"shadcn",
+			"index.ts"
+		]),
+		"@farming-labs/theme/mdx": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"mdx.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"mdx.ts"
+		]),
+		"@farming-labs/theme/search": workspaceEntrypoint([
+			"packages",
+			"fumadocs",
+			"dist",
+			"search.mjs"
+		], [
+			"packages",
+			"fumadocs",
+			"src",
+			"search.ts"
+		])
+	};
+}
+function hasFile(root, baseName) {
+	return FILE_EXTS.some((ext) => existsSync(join(root, `${baseName}.${ext}`)));
+}
+function isManagedGeneratedFile(filePath) {
+	if (!existsSync(filePath)) return false;
+	try {
+		return readFileSync(filePath, "utf-8").startsWith(GENERATED_BANNER);
+	} catch {
+		return false;
+	}
+}
+/** Scope file contents to one configuration pass so later calls see edits. */
+function createConfigSourceReader() {
+	const sources = /* @__PURE__ */ new Map();
+	return (path) => {
+		let content = sources.get(path);
+		if (content === void 0) {
+			content = readFileSync(path, "utf-8");
+			sources.set(path, content);
+		}
+		return content;
+	};
+}
+/** Read the docs entry path from docs.config.ts[x] (defaults to "docs"). */
+function readDocsEntry(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (existsSync(configPath)) try {
+			const match = readSource(configPath).match(/entry\s*:\s*["']([^"']+)["']/);
+			if (match) return match[1];
+		} catch {}
+	}
+	return "docs";
+}
+function readDocsContentDir(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const contentDir = readTopLevelStringProperty(readSource(configPath), "contentDir");
+			if (contentDir) return contentDir;
+		} catch {}
+	}
+}
+function readDocsPath(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			return readTopLevelStringProperty(readSource(configPath), "docsPath");
+		} catch {}
+	}
+}
+function readDocsConfigPath(root) {
+	for (const ext of FILE_EXTS) {
+		const relativePath = `docs.config.${ext}`;
+		if (existsSync(join(root, relativePath))) return relativePath;
+	}
+	return "docs.config.ts";
+}
+function unwrapStaticExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSInstantiationExpression") current = current.expression;
+	return current;
+}
+function readStaticPropertyName(property) {
+	const key = unwrapStaticExpression(property.key);
+	if (property.computed) return void 0;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "StringLiteral") return key.value;
+	if (key.type === "NumericLiteral") return String(key.value);
+	if (key.type === "BigIntLiteral") return key.value;
+	if (key.type === "TemplateLiteral" && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? void 0;
+}
+function resolveStaticObjectProperty(object, key) {
+	let resolution = { status: "absent" };
+	for (const entry of object.properties) {
+		if (entry.type === "SpreadElement") {
+			resolution = { status: "unknown" };
+			continue;
+		}
+		const name = readStaticPropertyName(entry);
+		if (name === void 0) {
+			if (entry.computed) resolution = { status: "unknown" };
+			continue;
+		}
+		if (name === "__proto__" && !entry.computed && entry.type === "ObjectProperty" && !entry.shorthand) {
+			if (resolution.status !== "value") resolution = { status: "unknown" };
+			continue;
+		}
+		if (name !== key) continue;
+		if (entry.type !== "ObjectProperty" || entry.shorthand) {
+			resolution = { status: "unknown" };
+			continue;
+		}
+		resolution = {
+			status: "value",
+			value: entry.value
+		};
+	}
+	return resolution;
+}
+function hasDefineDocsImport(program, localName) {
+	return program.body.some((statement) => statement.type === "ImportDeclaration" && statement.importKind !== "type" && statement.source.value === "@farming-labs/docs" && statement.specifiers.some((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.local.name === localName && specifier.imported.type === "Identifier" && specifier.imported.name === "defineDocs"));
+}
+function readDocsConfigRootObject(configPath, content) {
+	let program;
+	try {
+		const extension = extname(configPath).toLowerCase();
+		program = parse(content, {
+			sourceType: "module",
+			sourceFilename: configPath,
+			plugins: extension === ".tsx" ? [
+				"typescript",
+				"jsx",
+				"decorators-legacy"
+			] : extension === ".ts" ? ["typescript", "decorators-legacy"] : extension === ".jsx" ? ["jsx", "decorators-legacy"] : ["decorators-legacy"],
+			createParenthesizedExpressions: true
+		}).program;
+	} catch (error) {
+		throw new Error(`withDocs could not parse ${configPath} while bundling Agent Skills: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const defaults = program.body.filter((statement) => statement.type === "ExportDefaultDeclaration");
+	if (defaults.length !== 1) throw new Error("withDocs could not statically determine agent.skills. Pass the live docs config as the second withDocs argument or use a literal agent object.");
+	let expression = unwrapStaticExpression(defaults[0].declaration);
+	if (expression.type === "CallExpression") {
+		const callee = expression.callee.type === "V8IntrinsicIdentifier" ? void 0 : unwrapStaticExpression(expression.callee);
+		const argument = expression.arguments[0];
+		if (!callee || callee.type !== "Identifier" || !hasDefineDocsImport(program, callee.name) || !argument || argument.type === "SpreadElement" || argument.type === "ArgumentPlaceholder") throw new Error("withDocs could not statically determine agent.skills. Pass the live docs config as the second withDocs argument or use a literal agent object.");
+		expression = unwrapStaticExpression(argument);
+	}
+	if (expression.type !== "ObjectExpression") throw new Error("withDocs could not statically determine agent.skills. Pass the live docs config as the second withDocs argument or use a literal agent object.");
+	return expression;
+}
+function readStaticStringPaths(expression) {
+	const value = unwrapStaticExpression(expression);
+	if (value.type === "StringLiteral") return [value.value];
+	if (value.type !== "ArrayExpression") return null;
+	const paths = [];
+	for (const entry of value.elements) {
+		if (!entry || entry.type === "SpreadElement") return null;
+		const item = unwrapStaticExpression(entry);
+		if (item.type !== "StringLiteral") return null;
+		paths.push(item.value);
+	}
+	return paths;
+}
+function readAgentSkillPaths(root, configPath, readSource) {
+	const absoluteConfigPath = join(root, configPath);
+	if (!existsSync(absoluteConfigPath)) return [];
+	const agent = resolveStaticObjectProperty(readDocsConfigRootObject(absoluteConfigPath, readSource(absoluteConfigPath)), "agent");
+	if (agent.status === "absent") return [];
+	if (agent.status === "unknown") throw new Error("withDocs could not statically determine agent.skills from a composed agent config. Pass the live docs config as the second withDocs argument.");
+	const agentValue = unwrapStaticExpression(agent.value);
+	if (agentValue.type !== "ObjectExpression") throw new Error("withDocs could not statically determine agent.skills from a composed agent config. Pass the live docs config as the second withDocs argument.");
+	const skills = resolveStaticObjectProperty(agentValue, "skills");
+	if (skills.status === "absent") return [];
+	if (skills.status === "unknown") throw new Error("withDocs could not statically determine agent.skills from a composed agent config. Pass the live docs config as the second withDocs argument.");
+	const skillsValue = unwrapStaticExpression(skills.value);
+	let configured;
+	if (skillsValue.type === "ObjectExpression") {
+		const paths = resolveStaticObjectProperty(skillsValue, "paths");
+		configured = paths.status === "value" ? readStaticStringPaths(paths.value) : null;
+	} else configured = readStaticStringPaths(skillsValue);
+	if (!configured) throw new Error("withDocs could not statically bundle agent.skills. Use a literal path, a literal path array, or { paths: [...] } so configured skills are included in production.");
+	return configured;
+}
+const ROOT_DOCUMENT_FILES = [
+	"skill.md",
+	"AGENTS.md",
+	"AGENT.md"
+];
+/**
+* Snapshot the project-root agent documents into the skills bundle. Tracing
+* them by bare filename is not an option: Turbopack matches such globs at any
+* depth, which drags `node_modules/next/AGENTS.md` into the trace through the
+* pnpm workspace symlink and breaks Vercel output materialization.
+*/
+function readRootDocumentsSnapshot(root) {
+	const documents = {};
+	for (const fileName of ROOT_DOCUMENT_FILES) {
+		const filePath = join(root, fileName);
+		if (!existsSync(filePath)) continue;
+		try {
+			documents[fileName] = readFileSync(filePath, "utf8");
+		} catch {}
+	}
+	return Object.keys(documents).length > 0 ? documents : void 0;
+}
+function writeAgentSkillsBundle(root, configuredSkills) {
+	const bundlePath = join(root, AGENT_SKILLS_BUNDLE_PATH);
+	const source = `${GENERATED_BANNER}${renderDocsAgentSkillsBundle(resolveConfiguredAgentSkillsSync(configuredSkills, { rootDir: root }), readRootDocumentsSnapshot(root))}`;
+	makeGeneratedDir(dirname(bundlePath));
+	if (!existsSync(bundlePath) || readFileSync(bundlePath, "utf8") !== source) writeGeneratedFile(bundlePath, source);
+	return bundlePath;
+}
+/** Read the OG endpoint from docs.config.ts[x] (returns undefined if not set). */
+function readOgEndpoint(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (existsSync(configPath)) try {
+			const match = readSource(configPath).match(/endpoint\s*:\s*["']([^"']+)["']/);
+			if (match && match[1]) return match[1];
+		} catch {}
+	}
+}
+function readApiReferenceConfig(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			if (content.match(/apiReference\s*:\s*false/)) return {
+				enabled: false,
+				path: "api-reference",
+				renderer: "farming-labs",
+				routeRoot: "api"
+			};
+			if (content.match(/apiReference\s*:\s*true/)) return {
+				enabled: true,
+				path: "api-reference",
+				renderer: "farming-labs",
+				routeRoot: "api"
+			};
+			const block = extractObjectLiteral(content, "apiReference");
+			if (!block) continue;
+			const enabledMatch = block.match(/enabled\s*:\s*(true|false)/);
+			const pathMatch = block.match(/path\s*:\s*["']([^"']+)["']/);
+			const rendererMatch = block.match(/renderer\s*:\s*["'](farming-labs|fumadocs|scalar)["']/);
+			const rendererConfigNameMatch = extractObjectLiteral(block, "renderer")?.match(/name\s*:\s*["'](farming-labs|fumadocs|scalar)["']/);
+			const usesFumadocsRendererHelper = /renderer\s*:\s*fumadocsRenderer\s*\(/.test(block);
+			const routeRootMatch = block.match(/routeRoot\s*:\s*["']([^"']+)["']/);
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				path: pathMatch?.[1]?.replace(/^\/+|\/+$/g, "") || "api-reference",
+				renderer: rendererMatch?.[1] ?? rendererConfigNameMatch?.[1] ?? (usesFumadocsRendererHelper ? "fumadocs" : void 0) ?? "farming-labs",
+				routeRoot: routeRootMatch?.[1]?.replace(/^\/+|\/+$/g, "") || "api"
+			};
+		} catch {
+			return {
+				enabled: false,
+				path: "api-reference",
+				renderer: "farming-labs",
+				routeRoot: "api"
+			};
+		}
+	}
+	return {
+		enabled: false,
+		path: "api-reference",
+		renderer: "farming-labs",
+		routeRoot: "api"
+	};
+}
+function readChangelogConfig(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			if (content.match(/changelog\s*:\s*false/)) return {
+				enabled: false,
+				path: "changelog",
+				contentDir: "changelog"
+			};
+			if (content.match(/changelog\s*:\s*true/)) return {
+				enabled: true,
+				path: "changelog",
+				contentDir: "changelog"
+			};
+			const block = extractObjectLiteral(content, "changelog");
+			if (!block) continue;
+			const enabledMatch = block.match(/enabled\s*:\s*(true|false)/);
+			const pathMatch = block.match(/path\s*:\s*["']([^"']+)["']/);
+			const contentDirMatch = block.match(/contentDir\s*:\s*["']([^"']+)["']/);
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				path: pathMatch?.[1]?.replace(/^\/+|\/+$/g, "") || "changelog",
+				contentDir: contentDirMatch?.[1]?.replace(/\/+$/, "") || "changelog"
+			};
+		} catch {
+			return {
+				enabled: false,
+				path: "changelog",
+				contentDir: "changelog"
+			};
+		}
+	}
+	return {
+		enabled: false,
+		path: "changelog",
+		contentDir: "changelog"
+	};
+}
+function resolveDocsContentDir(root, appDir, entry, readSource) {
+	const configuredContentDir = readDocsContentDir(root, readSource);
+	if (!configuredContentDir) return join(root, appDir, entry);
+	return isAbsolute(configuredContentDir) ? configuredContentDir : join(root, configuredContentDir);
+}
+function resolveChangelogContentDir(root, appDir, entry, changelogContentDir, readSource) {
+	if (isAbsolute(changelogContentDir)) return changelogContentDir;
+	return join(resolveDocsContentDir(root, appDir, entry, readSource), changelogContentDir);
+}
+function findChangelogSourceEntries(changelogDir) {
+	if (!existsSync(changelogDir)) return [];
+	const entries = [];
+	for (const name of readdirSync(changelogDir).sort()) {
+		if (!/^\d{4}-\d{2}-\d{2}$/.test(name)) continue;
+		const entryDir = join(changelogDir, name);
+		try {
+			if (!statSync(entryDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const sourceFile = ["page.mdx", "page.md"].map((fileName) => join(entryDir, fileName)).find((value) => existsSync(value));
+		if (!sourceFile) continue;
+		let metadata = {};
+		try {
+			metadata = matter(readFileSync(sourceFile, "utf-8")).data;
+		} catch {
+			metadata = {};
+		}
+		entries.push({
+			slug: name,
+			date: name,
+			sourceFile,
+			metadata
+		});
+	}
+	return entries.sort((left, right) => right.date.localeCompare(left.date));
+}
+function extractRootObjectLiteral(content) {
+	const candidateIndexes = [content.search(/\bdefineDocs\s*\(/), content.search(/\bexport\s+default\b/)].filter((value) => value !== -1);
+	for (const startIndex of candidateIndexes) {
+		const braceStart = content.indexOf("{", startIndex);
+		if (braceStart === -1) continue;
+		let depth = 0;
+		let inString = null;
+		let escaped = false;
+		for (let index = braceStart; index < content.length; index += 1) {
+			const char = content[index];
+			if (inString) {
+				if (escaped) {
+					escaped = false;
+					continue;
+				}
+				if (char === "\\") {
+					escaped = true;
+					continue;
+				}
+				if (char === inString) inString = null;
+				continue;
+			}
+			if (char === "\"" || char === "'" || char === "`") {
+				inString = char;
+				continue;
+			}
+			if (char === "{") {
+				depth += 1;
+				continue;
+			}
+			if (char !== "}") continue;
+			depth -= 1;
+			if (depth === 0) return content.slice(braceStart + 1, index);
+		}
+	}
+}
+function findTopLevelPropertyValueIndex(block, key) {
+	let objectDepth = 0;
+	let arrayDepth = 0;
+	let parenDepth = 0;
+	let inString = null;
+	let inLineComment = false;
+	let inBlockComment = false;
+	let escaped = false;
+	for (let index = 0; index < block.length; index += 1) {
+		const char = block[index];
+		const next = block[index + 1];
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === inString) inString = null;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			inString = char;
+			continue;
+		}
+		if (char === "{") {
+			objectDepth += 1;
+			continue;
+		}
+		if (char === "}") {
+			objectDepth = Math.max(0, objectDepth - 1);
+			continue;
+		}
+		if (char === "[") {
+			arrayDepth += 1;
+			continue;
+		}
+		if (char === "]") {
+			arrayDepth = Math.max(0, arrayDepth - 1);
+			continue;
+		}
+		if (char === "(") {
+			parenDepth += 1;
+			continue;
+		}
+		if (char === ")") {
+			parenDepth = Math.max(0, parenDepth - 1);
+			continue;
+		}
+		if (objectDepth !== 0 || arrayDepth !== 0 || parenDepth !== 0) continue;
+		if (!block.startsWith(key, index)) continue;
+		const before = block[index - 1] ?? "";
+		const after = block[index + key.length] ?? "";
+		if (/[A-Za-z0-9_$]/.test(before) || /[A-Za-z0-9_$]/.test(after)) continue;
+		let cursor = index + key.length;
+		while (/\s/.test(block[cursor] ?? "")) cursor += 1;
+		if (block[cursor] !== ":") continue;
+		cursor += 1;
+		while (/\s/.test(block[cursor] ?? "")) cursor += 1;
+		return cursor;
+	}
+}
+function findMatchingObjectEnd(block, start) {
+	let depth = 0;
+	let inString = null;
+	let inLineComment = false;
+	let inBlockComment = false;
+	let escaped = false;
+	for (let index = start; index < block.length; index += 1) {
+		const char = block[index];
+		const next = block[index + 1];
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+		if (inBlockComment) {
+			if (char === "*" && next === "/") {
+				inBlockComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === inString) inString = null;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			inLineComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			inBlockComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			inString = char;
+			continue;
+		}
+		if (char === "{") {
+			depth += 1;
+			continue;
+		}
+		if (char !== "}") continue;
+		depth -= 1;
+		if (depth === 0) return index;
+	}
+}
+function readTopLevelStringProperty(content, key) {
+	const block = extractRootObjectLiteral(content);
+	if (!block) return void 0;
+	const cursor = findTopLevelPropertyValueIndex(block, key);
+	if (cursor === void 0) return void 0;
+	const quote = block[cursor];
+	if (quote !== "\"" && quote !== "'") return void 0;
+	let value = "";
+	for (let index = cursor + 1; index < block.length; index += 1) {
+		const valueChar = block[index];
+		if (valueChar === "\\") {
+			const escapedChar = block[index + 1];
+			if (escapedChar) {
+				value += escapedChar;
+				index += 1;
+			}
+			continue;
+		}
+		if (valueChar === quote) return value;
+		value += valueChar;
+	}
+}
+function readTopLevelBooleanProperty(content, key) {
+	const block = extractRootObjectLiteral(content);
+	if (!block) return void 0;
+	const cursor = findTopLevelPropertyValueIndex(block, key);
+	if (cursor === void 0) return void 0;
+	if (block.startsWith("true", cursor)) return true;
+	if (block.startsWith("false", cursor)) return false;
+}
+function extractTopLevelObjectLiteral(content, key) {
+	const block = extractRootObjectLiteral(content);
+	if (!block) return void 0;
+	const cursor = findTopLevelPropertyValueIndex(block, key);
+	if (cursor === void 0 || block[cursor] !== "{") return void 0;
+	const end = findMatchingObjectEnd(block, cursor);
+	return end === void 0 ? void 0 : block.slice(cursor + 1, end);
+}
+function extractObjectLiteral(content, key) {
+	const keyIndex = content.search(new RegExp(`${key}\\s*:\\s*\\{`));
+	if (keyIndex === -1) return void 0;
+	const braceStart = content.indexOf("{", keyIndex);
+	if (braceStart === -1) return void 0;
+	let depth = 0;
+	for (let index = braceStart; index < content.length; index += 1) {
+		const char = content[index];
+		if (char === "{") {
+			depth += 1;
+			continue;
+		}
+		if (char !== "}") continue;
+		depth -= 1;
+		if (depth === 0) return content.slice(braceStart + 1, index);
+	}
+}
+function toImportPath(fromFile, toFile) {
+	const relativePath = relative(dirname(fromFile), toFile).replaceAll("\\", "/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function toObjectKeySource(key) {
+	return /^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function toInlineValueSource(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return JSON.stringify(value) ?? "undefined";
+}
+function toObjectPropertySource(key, value, depth) {
+	const childIndent = " ".repeat(depth + 2);
+	const wrappedValueIndent = " ".repeat(depth + 4);
+	const valueSource = toChangelogMetadataSource(value, depth + 2);
+	const inlineSource = `${childIndent}${toObjectKeySource(key)}: ${valueSource},`;
+	if (!valueSource.includes("\n") && inlineSource.length > 100) return `${childIndent}${toObjectKeySource(key)}:\n${wrappedValueIndent}${valueSource},`;
+	return inlineSource;
+}
+function toChangelogMetadataSource(value, depth = 0) {
+	const indent = " ".repeat(depth);
+	const childIndent = " ".repeat(depth + 2);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		if (value.every((item) => item === null || typeof item === "string" || typeof item === "number" || typeof item === "boolean")) return `[${value.map(toInlineValueSource).join(", ")}]`;
+		return `[
+${value.map((item) => `${childIndent}${toChangelogMetadataSource(item, depth + 2)},`).join("\n")}
+${indent}]`;
+	}
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value).filter((entry) => entry[1] !== void 0);
+		if (entries.length === 0) return "{}";
+		return `{
+${entries.map(([key, item]) => toObjectPropertySource(key, item, depth)).join("\n")}
+${indent}}`;
+	}
+	return toInlineValueSource(value);
+}
+function buildInlineChangelogEntriesSource(root, pagePath, entryPath, routePath, entries) {
+	const imports = [];
+	const records = [];
+	entries.forEach((entry, index) => {
+		const importName = `ChangelogEntry${index + 1}`;
+		imports.push(`import ${importName} from "${toImportPath(pagePath, entry.sourceFile)}";`);
+		records.push(`  {
+    slug: ${JSON.stringify(entry.slug)},
+    date: ${JSON.stringify(entry.date)},
+    url: ${JSON.stringify(`/${entryPath}/${routePath}/${entry.slug}`)},
+    sourcePath: ${JSON.stringify(relative(root, entry.sourceFile).replaceAll("\\", "/"))},
+    Component: ${importName},
+    metadata: ${toChangelogMetadataSource(entry.metadata, 4)},
+  }`);
+	});
+	return {
+		importsSource: `import type { GeneratedChangelogEntry } from "@farming-labs/next/changelog";
+${imports.join("\n")}`.trimEnd(),
+		entriesSource: `export const changelogEntries: GeneratedChangelogEntry[] = [
+${records.length > 0 ? `${records.join(",\n")},` : ""}
+];`
+	};
+}
+function buildChangelogIndexPageSource(root, pagePath, entryPath, routePath, entries) {
+	const { importsSource, entriesSource } = buildInlineChangelogEntriesSource(root, pagePath, entryPath, routePath, entries);
+	return `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+${importsSource}
+import {
+  createNextChangelogIndexMetadata,
+  createNextChangelogIndexPage,
+} from "@farming-labs/next/changelog";
+
+${entriesSource}
+
+export const metadata = createNextChangelogIndexMetadata(docsConfig);
+
+const ChangelogPage = createNextChangelogIndexPage(docsConfig, changelogEntries);
+
+export default ChangelogPage;
+`;
+}
+function buildChangelogEntryPageSource(root, pagePath, entryPath, routePath, entries) {
+	const { importsSource, entriesSource } = buildInlineChangelogEntriesSource(root, pagePath, entryPath, routePath, entries);
+	return `\
+${GENERATED_BANNER}
+import docsConfig from "@/docs.config";
+${importsSource}
+import {
+  createNextChangelogEntryMetadata,
+  createNextChangelogEntryPage,
+  createNextChangelogStaticParams,
+} from "@farming-labs/next/changelog";
+
+${entriesSource}
+
+export const generateStaticParams = createNextChangelogStaticParams(changelogEntries);
+export const generateMetadata = createNextChangelogEntryMetadata(docsConfig, changelogEntries);
+
+const ChangelogEntryPage = createNextChangelogEntryPage(docsConfig, changelogEntries);
+
+export default ChangelogEntryPage;
+`;
+}
+function resolveManagedChangelogSourceLayoutPath(root, appDir, entry, changelogContentDir, readSource) {
+	if (isAbsolute(changelogContentDir)) return void 0;
+	const appRoot = join(root, appDir);
+	const contentRoot = resolveChangelogContentDir(root, appDir, entry, changelogContentDir, readSource);
+	const relativePath = relative(appRoot, contentRoot);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) return void 0;
+	return join(contentRoot, "layout.tsx");
+}
+function removeManagedFile(filePath) {
+	if (isManagedGeneratedFile(filePath)) withReadOnlyFsGuard(filePath, () => rmSync(filePath, { force: true }));
+}
+const READ_ONLY_FS_CODES = new Set([
+	"EROFS",
+	"EACCES",
+	"EPERM"
+]);
+/** Generation must not take down config evaluation on read-only filesystems; the build already shipped these files. */
+function withReadOnlyFsGuard(target, mutate) {
+	try {
+		return mutate();
+	} catch (error) {
+		const code = error?.code;
+		if (!code || !READ_ONLY_FS_CODES.has(code)) throw error;
+		console.warn(`[docs] Skipped generating ${target} (${code}): filesystem is read-only; using existing files.`);
+		return;
+	}
+}
+function makeGeneratedDir(dirPath) {
+	withReadOnlyFsGuard(dirPath, () => mkdirSync(dirPath, { recursive: true }));
+}
+function writeGeneratedFile(filePath, content) {
+	withReadOnlyFsGuard(filePath, () => {
+		if (existsSync(filePath) && readFileSync(filePath, "utf8") === content) return;
+		writeFileSync(filePath, content, "utf8");
+	});
+}
+function resolveMcpConfig(mcp) {
+	if (mcp === false) return {
+		enabled: false,
+		route: DEFAULT_MCP_ROUTE,
+		protectedResource: false
+	};
+	if (!mcp || mcp === true) return {
+		enabled: true,
+		route: DEFAULT_MCP_ROUTE,
+		protectedResource: false
+	};
+	return {
+		enabled: mcp.enabled ?? true,
+		route: normalizeRoutePath(mcp.route ?? DEFAULT_MCP_ROUTE),
+		protectedResource: Boolean(mcp.security?.authenticate && mcp.security.protectedResource)
+	};
+}
+function readMcpConfig(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			if (content.match(/mcp\s*:\s*false/)) return {
+				enabled: false,
+				route: DEFAULT_MCP_ROUTE,
+				protectedResource: false
+			};
+			if (content.match(/mcp\s*:\s*true/)) return {
+				enabled: true,
+				route: DEFAULT_MCP_ROUTE,
+				protectedResource: false
+			};
+			const block = extractObjectLiteral(content, "mcp");
+			if (!block) continue;
+			const enabledMatch = block.match(/enabled\s*:\s*(true|false)/);
+			const routeMatch = block.match(/route\s*:\s*["']([^"']+)["']/);
+			const securityBlock = extractObjectLiteral(block, "security");
+			const protectedResource = Boolean(securityBlock && /\bauthenticate\b/u.test(securityBlock) && extractObjectLiteral(securityBlock, "protectedResource"));
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				route: normalizeRoutePath(routeMatch?.[1] ?? DEFAULT_MCP_ROUTE),
+				protectedResource
+			};
+		} catch {
+			return {
+				enabled: true,
+				route: DEFAULT_MCP_ROUTE,
+				protectedResource: false
+			};
+		}
+	}
+	return {
+		enabled: true,
+		route: DEFAULT_MCP_ROUTE,
+		protectedResource: false
+	};
+}
+function normalizeRoutePath(route) {
+	const normalized = `/${route}`.replace(/\/+/g, "/");
+	return normalized !== "/" ? normalized.replace(/\/+$/, "") : DEFAULT_MCP_ROUTE;
+}
+function normalizeMcpResourcePath(route) {
+	return route.trim() === "/" ? "/" : normalizeRoutePath(route);
+}
+function buildMcpProtectedResourceMetadataRoute(resourcePath) {
+	const normalized = normalizeMcpResourcePath(resourcePath);
+	return normalized === "/" ? DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE : `${DEFAULT_MCP_PROTECTED_RESOURCE_METADATA_ROUTE}${normalized}`;
+}
+function normalizeRoutePrefix(prefix) {
+	if (!prefix) return "";
+	const normalized = `/${prefix.replace(/^\/+|\/+$/g, "")}`.replace(/\/+/g, "/");
+	return normalized === "/" ? "" : normalized;
+}
+function joinPublicRoute(prefix, route) {
+	return `${prefix}/${route.replace(/^\/+/, "")}`.replace(/\/+/g, "/");
+}
+function readSitemapConfig(root, readSource) {
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			if (content.match(/sitemap\s*:\s*false/)) return {
+				enabled: false,
+				routePrefix: ""
+			};
+			if (content.match(/sitemap\s*:\s*true/)) return {
+				enabled: true,
+				routePrefix: ""
+			};
+			const block = extractObjectLiteral(content, "sitemap");
+			if (!block) continue;
+			const enabledMatch = block.match(/enabled\s*:\s*(true|false)/);
+			const routePrefixMatch = block.match(/routePrefix\s*:\s*["']([^"']+)["']/);
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				routePrefix: normalizeRoutePrefix(routePrefixMatch?.[1])
+			};
+		} catch {
+			return {
+				enabled: true,
+				routePrefix: ""
+			};
+		}
+	}
+	return {
+		enabled: true,
+		routePrefix: ""
+	};
+}
+function readRobotsConfig(root, readSource) {
+	const publicStaticPath = join(root, "public", "robots.txt");
+	const appDir = getNextAppDir(root);
+	const appStaticPath = join(root, appDir, "robots.txt");
+	const appRouteExists = FILE_EXTS.some((ext) => existsSync(join(root, appDir, `robots.${ext}`)));
+	const hasStaticFile = existsSync(publicStaticPath) || existsSync(appStaticPath) || appRouteExists;
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			if (content.match(/robots\s*:\s*false/)) return {
+				enabled: false,
+				hasStaticFile
+			};
+			if (content.match(/robots\s*:\s*true/)) return {
+				enabled: true,
+				hasStaticFile
+			};
+			const block = extractObjectLiteral(content, "robots");
+			if (!block) continue;
+			const enabledMatch = block.match(/enabled\s*:\s*(true|false)/);
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				hasStaticFile
+			};
+		} catch {
+			return {
+				enabled: true,
+				hasStaticFile
+			};
+		}
+	}
+	return {
+		enabled: true,
+		hasStaticFile
+	};
+}
+function normalizeAgentFeedbackRoute(route, fallback = DEFAULT_AGENT_FEEDBACK_ROUTE) {
+	if (!route || route.trim().length === 0) return fallback;
+	const normalized = `/${route}`.replace(/\/+/g, "/");
+	return normalized !== "/" ? normalized.replace(/\/+$/, "") : fallback;
+}
+function readAgentFeedbackConfig(root, readSource) {
+	const defaultRoute = normalizeAgentFeedbackRoute();
+	const enabled = {
+		enabled: true,
+		route: defaultRoute,
+		schemaRoute: `${defaultRoute}/schema`
+	};
+	const disabled = {
+		enabled: false,
+		route: defaultRoute,
+		schemaRoute: `${defaultRoute}/schema`
+	};
+	for (const ext of FILE_EXTS) {
+		const configPath = join(root, `docs.config.${ext}`);
+		if (!existsSync(configPath)) continue;
+		try {
+			const content = readSource(configPath);
+			const feedbackBoolean = readTopLevelBooleanProperty(content, "feedback");
+			if (feedbackBoolean === false) return disabled;
+			if (feedbackBoolean === true) return enabled;
+			const feedbackBlock = extractTopLevelObjectLiteral(content, "feedback");
+			if (!feedbackBlock) return enabled;
+			if (feedbackBlock.match(/agent\s*:\s*false/)) return disabled;
+			if (feedbackBlock.match(/agent\s*:\s*true/)) return enabled;
+			const agentBlock = extractObjectLiteral(feedbackBlock, "agent");
+			if (!agentBlock) return enabled;
+			const enabledMatch = agentBlock.match(/enabled\s*:\s*(true|false)/);
+			const routeMatch = agentBlock.match(/route\s*:\s*["']([^"']+)["']/);
+			const schemaRouteMatch = agentBlock.match(/schemaRoute\s*:\s*["']([^"']+)["']/);
+			const route = normalizeAgentFeedbackRoute(routeMatch?.[1], defaultRoute);
+			return {
+				enabled: enabledMatch ? enabledMatch[1] !== "false" : true,
+				route,
+				schemaRoute: normalizeAgentFeedbackRoute(schemaRouteMatch?.[1], `${route}/schema`)
+			};
+		} catch {
+			return disabled;
+		}
+	}
+	return enabled;
+}
+function normalizeRouteSegment(value, fallback = "docs") {
+	return (value ?? fallback).replace(/^\/+|\/+$/g, "") || fallback;
+}
+function normalizeDocsPath(value, entry) {
+	if (typeof value !== "string") return `/${normalizeRouteSegment(entry)}`;
+	const cleaned = value.trim().replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
+	if (cleaned === "") return "";
+	return `/${cleaned}`;
+}
+function docsRootSource(entry) {
+	return [
+		"/:slug((?!",
+		"_next/",
+		"|api/",
+		`|${normalizeRouteSegment(entry)}(?:/|$)`,
+		"|favicon\\.ico",
+		"|robots\\.txt",
+		"|sitemap\\.xml",
+		"|sitemap\\.md",
+		"|docs\\.md",
+		"|llms\\.txt",
+		"|llms-full\\.txt",
+		"|mcp(?:/|$)",
+		"|AGENTS\\.md",
+		"|AGENT\\.md",
+		"|skill\\.md",
+		"|\\.well-known/",
+		"|.*\\..*",
+		").*)"
+	].join("");
+}
+function docsRootMarkdownSource(entry) {
+	return [
+		"/:slug((?!",
+		"_next/",
+		"|api/",
+		`|${normalizeRouteSegment(entry)}/`,
+		"|docs\\.md",
+		"|sitemap\\.md",
+		"|AGENTS\\.md",
+		"|AGENT\\.md",
+		"|skill\\.md",
+		"|\\.well-known/",
+		").*)\\.md"
+	].join("");
+}
+function buildDocsPathRewrites(entry, docsPath) {
+	const normalizedEntry = normalizeRouteSegment(entry);
+	const internalBase = `/${normalizedEntry}`;
+	if (docsPath === internalBase) return [];
+	if (docsPath === "") return [{
+		source: "/",
+		destination: `${internalBase}/`
+	}, {
+		source: docsRootSource(normalizedEntry),
+		destination: `${internalBase}/:slug`
+	}];
+	return [{
+		source: docsPath,
+		destination: internalBase
+	}, {
+		source: `${docsPath}/:slug*`,
+		destination: `${internalBase}/:slug*`
+	}];
+}
+function buildDocsMarkdownRewrites(entry, docsPath) {
+	const normalizedEntry = normalizeRouteSegment(entry);
+	const publicBase = docsPath || "";
+	const markdownAcceptHeader = {
+		type: "header",
+		key: "accept",
+		value: MARKDOWN_ACCEPT_HEADER_VALUE
+	};
+	const markdownSignatureAgentHeader = {
+		type: "header",
+		key: "signature-agent",
+		value: ".+"
+	};
+	const markdownAgentUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownBotLikeUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownTraditionalBotUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownSecFetchModeHeader = {
+		type: "header",
+		key: "sec-fetch-mode"
+	};
+	if (publicBase === "") {
+		const rootPageSource = docsRootSource(normalizedEntry);
+		return [
+			{
+				source: `/${normalizedEntry}.md`,
+				destination: "/api/docs?format=markdown"
+			},
+			{
+				source: docsRootMarkdownSource(normalizedEntry),
+				destination: "/api/docs?format=markdown&path=:slug"
+			},
+			{
+				source: "/",
+				has: [markdownAcceptHeader],
+				destination: "/api/docs?format=markdown"
+			},
+			{
+				source: rootPageSource,
+				has: [markdownAcceptHeader],
+				destination: "/api/docs?format=markdown&path=:slug"
+			},
+			{
+				source: "/",
+				has: [markdownSignatureAgentHeader],
+				destination: "/api/docs?format=markdown"
+			},
+			{
+				source: rootPageSource,
+				has: [markdownSignatureAgentHeader],
+				destination: "/api/docs?format=markdown&path=:slug"
+			},
+			{
+				source: "/",
+				has: [markdownAgentUserAgentHeader],
+				destination: "/api/docs?format=markdown"
+			},
+			{
+				source: rootPageSource,
+				has: [markdownAgentUserAgentHeader],
+				destination: "/api/docs?format=markdown&path=:slug"
+			},
+			{
+				source: "/",
+				has: [markdownBotLikeUserAgentHeader],
+				missing: [markdownTraditionalBotUserAgentHeader, markdownSecFetchModeHeader],
+				destination: "/api/docs?format=markdown"
+			},
+			{
+				source: rootPageSource,
+				has: [markdownBotLikeUserAgentHeader],
+				missing: [markdownTraditionalBotUserAgentHeader, markdownSecFetchModeHeader],
+				destination: "/api/docs?format=markdown&path=:slug"
+			}
+		];
+	}
+	return [
+		{
+			source: `${publicBase}.md`,
+			destination: "/api/docs?format=markdown"
+		},
+		{
+			source: `${publicBase}/:slug*.md`,
+			destination: "/api/docs?format=markdown&path=:slug*"
+		},
+		{
+			source: publicBase,
+			has: [markdownAcceptHeader],
+			destination: "/api/docs?format=markdown"
+		},
+		{
+			source: `${publicBase}/:slug*`,
+			has: [markdownAcceptHeader],
+			destination: "/api/docs?format=markdown&path=:slug*"
+		},
+		{
+			source: publicBase,
+			has: [markdownSignatureAgentHeader],
+			destination: "/api/docs?format=markdown"
+		},
+		{
+			source: `${publicBase}/:slug*`,
+			has: [markdownSignatureAgentHeader],
+			destination: "/api/docs?format=markdown&path=:slug*"
+		},
+		{
+			source: publicBase,
+			has: [markdownAgentUserAgentHeader],
+			destination: "/api/docs?format=markdown"
+		},
+		{
+			source: `${publicBase}/:slug*`,
+			has: [markdownAgentUserAgentHeader],
+			destination: "/api/docs?format=markdown&path=:slug*"
+		},
+		{
+			source: publicBase,
+			has: [markdownBotLikeUserAgentHeader],
+			missing: [markdownTraditionalBotUserAgentHeader, markdownSecFetchModeHeader],
+			destination: "/api/docs?format=markdown"
+		},
+		{
+			source: `${publicBase}/:slug*`,
+			has: [markdownBotLikeUserAgentHeader],
+			missing: [markdownTraditionalBotUserAgentHeader, markdownSecFetchModeHeader],
+			destination: "/api/docs?format=markdown&path=:slug*"
+		}
+	];
+}
+function buildApiReferenceMarkdownRewrites(apiReference) {
+	if (!apiReference.enabled) return [];
+	const basePath = `/${apiReference.path}`;
+	const markdownAcceptHeader = {
+		type: "header",
+		key: "accept",
+		value: MARKDOWN_ACCEPT_HEADER_VALUE
+	};
+	const markdownSignatureAgentHeader = {
+		type: "header",
+		key: "signature-agent",
+		value: ".+"
+	};
+	const markdownAgentUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_AI_AGENT_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownBotLikeUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_BOT_LIKE_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownTraditionalBotUserAgentHeader = {
+		type: "header",
+		key: "user-agent",
+		value: DOCS_TRADITIONAL_BOT_USER_AGENT_HEADER_PATTERN
+	};
+	const markdownSecFetchModeHeader = {
+		type: "header",
+		key: "sec-fetch-mode"
+	};
+	return [{
+		source: `${basePath}/operations/:operation`,
+		path: `${apiReference.path}/operations/:operation`
+	}, {
+		source: `${basePath}/:version/operations/:operation`,
+		path: `${apiReference.path}/:version/operations/:operation`
+	}].flatMap((route) => [
+		{
+			source: `${route.source}.md`,
+			destination: `/api/docs?format=markdown&path=${route.path}`
+		},
+		{
+			source: route.source,
+			has: [markdownAcceptHeader],
+			destination: `/api/docs?format=markdown&path=${route.path}`
+		},
+		{
+			source: route.source,
+			has: [markdownSignatureAgentHeader],
+			destination: `/api/docs?format=markdown&path=${route.path}`
+		},
+		{
+			source: route.source,
+			has: [markdownAgentUserAgentHeader],
+			destination: `/api/docs?format=markdown&path=${route.path}`
+		},
+		{
+			source: route.source,
+			has: [markdownBotLikeUserAgentHeader],
+			missing: [markdownTraditionalBotUserAgentHeader, markdownSecFetchModeHeader],
+			destination: `/api/docs?format=markdown&path=${route.path}`
+		}
+	]);
+}
+function buildAgentSpecRewrites() {
+	return [
+		{
+			source: DEFAULT_AGENT_SPEC_ROUTE,
+			destination: "/api/docs?agent=spec"
+		},
+		{
+			source: DEFAULT_AGENT_SPEC_WELL_KNOWN_ROUTE,
+			destination: "/api/docs?agent=spec"
+		},
+		{
+			source: DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE,
+			destination: "/api/docs?agent=spec"
+		}
+	];
+}
+function buildStandardsDiscoveryRewrites() {
+	return [
+		{
+			source: DEFAULT_API_CATALOG_ROUTE,
+			destination: "/api/docs?format=api-catalog"
+		},
+		{
+			source: DEFAULT_AGENT_SKILLS_INDEX_ROUTE,
+			destination: "/api/docs?format=agent-skills"
+		},
+		{
+			source: `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/:name/SKILL.md`,
+			destination: "/api/docs?format=agent-skill-file&name=:name&path=SKILL.md"
+		},
+		{
+			source: `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/:name/skill.md`,
+			destination: "/api/docs?format=agent-skill-file&name=:name&path=SKILL.md"
+		},
+		{
+			source: `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/:name.tar.gz`,
+			destination: `/api/docs?format=${DEFAULT_AGENT_SKILL_ARCHIVE_FORMAT}&name=:name`
+		},
+		{
+			source: `${DEFAULT_AGENT_SKILLS_ROUTE_PREFIX}/:name/:path*`,
+			destination: "/api/docs?format=agent-skill-file&name=:name&path=:path*"
+		},
+		{
+			source: DEFAULT_LEGACY_SKILLS_INDEX_ROUTE,
+			destination: "/api/docs?format=legacy-skills"
+		},
+		{
+			source: `${DEFAULT_LEGACY_SKILLS_ROUTE_PREFIX}/:name/skill.md`,
+			destination: "/api/docs?format=agent-skill-file&name=:name&path=SKILL.md"
+		},
+		{
+			source: `${DEFAULT_LEGACY_SKILLS_ROUTE_PREFIX}/:name/:path*`,
+			destination: "/api/docs?format=agent-skill-file&name=:name&path=:path*"
+		},
+		{
+			source: DEFAULT_A2A_AGENT_CARD_ROUTE,
+			destination: "/api/docs?format=agent-card"
+		}
+	];
+}
+function buildLlmsTxtRewrites(entry, docsPath) {
+	const internalBase = `/${normalizeRouteSegment(entry)}`;
+	const publicBase = docsPath;
+	const baseRoutes = Array.from(new Set([internalBase, publicBase].filter(Boolean)));
+	return [
+		{
+			source: DEFAULT_LLMS_TXT_ROUTE,
+			destination: "/api/docs?format=llms"
+		},
+		{
+			source: DEFAULT_LLMS_FULL_TXT_ROUTE,
+			destination: "/api/docs?format=llms-full"
+		},
+		{
+			source: DEFAULT_LLMS_TXT_WELL_KNOWN_ROUTE,
+			destination: "/api/docs?format=llms"
+		},
+		{
+			source: DEFAULT_LLMS_FULL_TXT_WELL_KNOWN_ROUTE,
+			destination: "/api/docs?format=llms-full"
+		},
+		...baseRoutes.flatMap((baseRoute) => [
+			{
+				source: `${baseRoute}/llms.txt`,
+				destination: "/api/docs?format=llms"
+			},
+			{
+				source: `${baseRoute}/llms-full.txt`,
+				destination: "/api/docs?format=llms-full"
+			},
+			{
+				source: `${baseRoute}/:section*/llms.txt`,
+				destination: `/api/docs?format=llms&section=${baseRoute}/:section*/llms.txt`
+			},
+			{
+				source: `${baseRoute}/:section*/llms-full.txt`,
+				destination: `/api/docs?format=llms-full&section=${baseRoute}/:section*/llms-full.txt`
+			}
+		])
+	];
+}
+function buildSkillMdRewrites() {
+	return [{
+		source: DEFAULT_SKILL_MD_ROUTE,
+		destination: "/api/docs?format=skill"
+	}, {
+		source: DEFAULT_SKILL_MD_WELL_KNOWN_ROUTE,
+		destination: "/api/docs?format=skill"
+	}];
+}
+function buildAgentsMdRewrites() {
+	return [
+		{
+			source: DEFAULT_AGENTS_MD_ROUTE,
+			destination: "/api/docs?format=agents"
+		},
+		{
+			source: DEFAULT_AGENTS_MD_WELL_KNOWN_ROUTE,
+			destination: "/api/docs?format=agents"
+		},
+		{
+			source: DEFAULT_AGENT_MD_ROUTE,
+			destination: "/api/docs?format=agents"
+		},
+		{
+			source: DEFAULT_AGENT_MD_WELL_KNOWN_ROUTE,
+			destination: "/api/docs?format=agents"
+		}
+	];
+}
+function buildSitemapRewrites(config) {
+	if (!config.enabled) return [];
+	const prefix = config.routePrefix;
+	return [
+		{
+			source: joinPublicRoute(prefix, DEFAULT_SITEMAP_XML_ROUTE),
+			destination: "/api/docs?format=sitemap-xml"
+		},
+		{
+			source: joinPublicRoute(prefix, DEFAULT_SITEMAP_MD_ROUTE),
+			destination: "/api/docs?format=sitemap-md"
+		},
+		...prefix ? [] : [{
+			source: DEFAULT_SITEMAP_MD_DOCS_ROUTE,
+			destination: "/api/docs?format=sitemap-md"
+		}],
+		{
+			source: joinPublicRoute(prefix, DEFAULT_SITEMAP_MD_WELL_KNOWN_ROUTE),
+			destination: "/api/docs?format=sitemap-md"
+		}
+	];
+}
+function buildRobotsRewrites(config) {
+	if (!config.enabled || config.hasStaticFile) return [];
+	return [{
+		source: DEFAULT_ROBOTS_TXT_ROUTE,
+		destination: "/api/docs?format=robots"
+	}];
+}
+function buildMcpRewrites(config) {
+	if (!config.enabled) return [];
+	const endpointRewrites = [DEFAULT_MCP_PUBLIC_ROUTE, DEFAULT_MCP_WELL_KNOWN_ROUTE].filter((source) => source !== config.route).map((source) => ({
+		source,
+		destination: config.route
+	}));
+	const metadataRewrites = config.protectedResource ? Array.from(new Set([
+		config.route,
+		DEFAULT_MCP_PUBLIC_ROUTE,
+		DEFAULT_MCP_WELL_KNOWN_ROUTE
+	])).map(buildMcpProtectedResourceMetadataRoute).map((source) => ({
+		source,
+		destination: config.route
+	})) : [];
+	return [...endpointRewrites, ...metadataRewrites];
+}
+function buildAgentFeedbackRewrites(config) {
+	if (!config.enabled) return [];
+	return [{
+		source: config.route,
+		destination: "/api/docs?feedback=agent"
+	}, {
+		source: config.schemaRoute,
+		destination: "/api/docs?feedback=agent&schema=1"
+	}];
+}
+function dedupeRewrites(rewrites) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const rewrite of rewrites) {
+		const key = JSON.stringify({
+			source: rewrite.source,
+			destination: rewrite.destination,
+			has: rewrite.has ?? [],
+			missing: rewrite.missing ?? []
+		});
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(rewrite);
+	}
+	return result;
+}
+function dedupeRedirects(redirects) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const redirect of redirects) {
+		const key = redirect.source;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(redirect);
+	}
+	return result;
+}
+function resolveDocsPageSourceFile(dir) {
+	return ["page.mdx", "page.md"].map((fileName) => join(dir, fileName)).find((candidate) => existsSync(candidate));
+}
+function readDocsPageFrontmatter(filePath) {
+	try {
+		return matter(readFileSync(filePath, "utf-8")).data;
+	} catch {
+		return {};
+	}
+}
+function resolveDocsPageFolderIndexBehavior(data) {
+	const sidebar = data.sidebar;
+	if (!sidebar || typeof sidebar !== "object") return void 0;
+	const value = sidebar.folderIndexBehavior;
+	return value === "link" || value === "toggle" || value === "hidden" ? value : void 0;
+}
+function publicDocsRoute(docsPath, slugParts = []) {
+	const slug = slugParts.join("/");
+	if (!slug) return docsPath || "/";
+	return docsPath ? `${docsPath}/${slug}` : `/${slug}`;
+}
+function buildHiddenFolderRedirects(docsDir, docsPath) {
+	const redirects = [];
+	const frontmatterByDir = /* @__PURE__ */ new Map();
+	const childrenByDir = /* @__PURE__ */ new Map();
+	const firstVisibleByDir = /* @__PURE__ */ new Map();
+	function frontmatter(dir) {
+		if (!frontmatterByDir.has(dir)) {
+			const source = resolveDocsPageSourceFile(dir);
+			frontmatterByDir.set(dir, source ? readDocsPageFrontmatter(source) : void 0);
+		}
+		return frontmatterByDir.get(dir);
+	}
+	function childDirectories(dir) {
+		const cached = childrenByDir.get(dir);
+		if (cached) return cached;
+		const children = [];
+		try {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				const fullPath = join(dir, entry.name);
+				try {
+					if (entry.isSymbolicLink() ? !statSync(fullPath).isDirectory() : !entry.isDirectory()) continue;
+				} catch {
+					continue;
+				}
+				const order = frontmatter(fullPath)?.order;
+				children.push({
+					name: entry.name,
+					order: typeof order === "number" ? order : Number.POSITIVE_INFINITY
+				});
+			}
+		} catch {}
+		const names = children.sort((left, right) => {
+			if (left.order !== right.order) return left.order - right.order;
+			return left.name.localeCompare(right.name);
+		}).map(({ name }) => name);
+		childrenByDir.set(dir, names);
+		return names;
+	}
+	function firstVisibleChild(dir, slugParts) {
+		if (firstVisibleByDir.has(dir)) return firstVisibleByDir.get(dir);
+		let destination;
+		for (const name of childDirectories(dir)) {
+			const childDir = join(dir, name);
+			const childSlugParts = [...slugParts, name];
+			const data = frontmatter(childDir);
+			if (!data || data.hidden === true || resolveDocsPageFolderIndexBehavior(data) === "hidden") {
+				destination = firstVisibleChild(childDir, childSlugParts);
+				if (!destination) continue;
+			} else destination = childSlugParts;
+			break;
+		}
+		firstVisibleByDir.set(dir, destination);
+		return destination;
+	}
+	function scan(dir, slugParts) {
+		const data = frontmatter(dir);
+		if (data && resolveDocsPageFolderIndexBehavior(data) === "hidden") {
+			const destinationSlug = firstVisibleChild(dir, slugParts);
+			if (destinationSlug && destinationSlug.join("/") !== slugParts.join("/")) redirects.push({
+				source: publicDocsRoute(docsPath, slugParts),
+				destination: publicDocsRoute(docsPath, destinationSlug),
+				permanent: false
+			});
+		}
+		for (const name of childDirectories(dir)) scan(join(dir, name), [...slugParts, name]);
+	}
+	scan(docsDir, []);
+	return dedupeRedirects(redirects);
+}
+function mergeDocsMarkdownRewrites(entry, docsPath, apiReference, mcp, sitemap, agentFeedback, robots, result) {
+	const autoBeforeFilesRewrites = [
+		...buildAgentSpecRewrites(),
+		...buildStandardsDiscoveryRewrites(),
+		...buildMcpRewrites(mcp),
+		...buildAgentsMdRewrites(),
+		...buildSkillMdRewrites(),
+		...buildSitemapRewrites(sitemap),
+		...buildRobotsRewrites(robots),
+		...buildDocsMarkdownRewrites(entry, docsPath),
+		...buildApiReferenceMarkdownRewrites(apiReference),
+		...buildDocsPathRewrites(entry, docsPath),
+		...buildAgentFeedbackRewrites(agentFeedback)
+	];
+	const autoAfterFilesRewrites = buildLlmsTxtRewrites(entry, docsPath);
+	if (!result) return {
+		beforeFiles: dedupeRewrites(autoBeforeFilesRewrites),
+		afterFiles: dedupeRewrites(autoAfterFilesRewrites)
+	};
+	if (Array.isArray(result)) return {
+		beforeFiles: dedupeRewrites(autoBeforeFilesRewrites),
+		afterFiles: dedupeRewrites([...result, ...autoAfterFilesRewrites])
+	};
+	return {
+		beforeFiles: dedupeRewrites([...result.beforeFiles ?? [], ...autoBeforeFilesRewrites]),
+		afterFiles: dedupeRewrites([...result.afterFiles ?? [], ...autoAfterFilesRewrites]),
+		fallback: result.fallback ?? []
+	};
+}
+function mergeDocsRedirects(autoRedirects, redirects) {
+	return dedupeRedirects([...redirects ?? [], ...autoRedirects]);
+}
+function withDocs(nextConfig = {}, docsConfig, options = {}) {
+	const mdx = resolveMdxExtensions(options.mdx);
+	const root = process.cwd();
+	const readSource = createConfigSourceReader();
+	const workspaceRoot = findDocsWorkspaceRoot(root);
+	const docsConfigPath = readDocsConfigPath(root);
+	const docsConfigAbsolutePath = join(root, docsConfigPath);
+	const codeBlockThemes = resolveCodeBlockThemes({
+		root,
+		configPath: docsConfigPath,
+		readSource,
+		theme: docsConfig?.theme
+	});
+	const mcp = docsConfig ? resolveMcpConfig(docsConfig.mcp) : readMcpConfig(root, readSource);
+	const nextBasePath = normalizeRoutePrefix(nextConfig.basePath);
+	if (mcp.enabled && mcp.protectedResource && nextBasePath) throw new Error(`@farming-labs/next: mcp.security.protectedResource cannot be combined with Next.js basePath ${JSON.stringify(nextBasePath)} because RFC 9728 metadata must be hosted at origin-root well-known URLs. Host the protected docs app at the origin root or publish the metadata and MCP proxy at the edge.`);
+	const agentSkillsBundlePath = writeAgentSkillsBundle(root, docsConfig === void 0 || !Object.hasOwn(docsConfig, "agent") ? readAgentSkillPaths(root, docsConfigPath, readSource) : docsConfig.agent?.skills);
+	const agentFeedback = readAgentFeedbackConfig(root, readSource);
+	const docsConfigRelativeAlias = docsConfigPath.startsWith("./") || docsConfigPath.startsWith("../") ? docsConfigPath : `./${docsConfigPath}`;
+	withReadOnlyFsGuard(".github/workflows/docs-review.yml", () => ensureDocsReviewWorkflow({
+		rootDir: root,
+		configPath: docsConfigPath,
+		configContent: existsSync(docsConfigAbsolutePath) ? readSource(docsConfigAbsolutePath) : void 0,
+		log: process.env.NODE_ENV === "test" ? void 0 : (message) => console.log(message)
+	}));
+	if (!hasFile(root, "mdx-components")) writeGeneratedFile(join(root, "mdx-components.tsx"), MDX_COMPONENTS_TEMPLATE);
+	const entry = readDocsEntry(root, readSource);
+	const docsPath = normalizeDocsPath(readDocsPath(root, readSource), entry);
+	const configuredContentDir = readDocsContentDir(root, readSource);
+	const appDir = getNextAppDir(root);
+	const docsContentDir = configuredContentDir ?? join(appDir, entry);
+	const layoutDir = join(root, appDir, entry);
+	if (!existsSync(layoutDir)) makeGeneratedDir(layoutDir);
+	const docsLayoutPath = join(layoutDir, "layout.tsx");
+	if (!hasFile(layoutDir, "layout") || isManagedGeneratedFile(docsLayoutPath)) writeGeneratedFile(join(layoutDir, "layout.tsx"), DOCS_LAYOUT_TEMPLATE);
+	const isStaticExport = nextConfig.output === "export";
+	const docsApiRouteDir = join(root, appDir, "api", "docs");
+	const existingDocsApiRoutePath = FILE_EXTS.map((ext) => join(docsApiRouteDir, `route.${ext}`)).find((filePath) => existsSync(filePath));
+	const docsApiRoutePath = existingDocsApiRoutePath ?? join(docsApiRouteDir, "route.ts");
+	if (!isStaticExport && (!existingDocsApiRoutePath || isManagedGeneratedFile(existingDocsApiRoutePath))) {
+		makeGeneratedDir(docsApiRouteDir);
+		writeGeneratedFile(docsApiRoutePath, DOCS_API_ROUTE_TEMPLATE);
+	}
+	const sitemap = readSitemapConfig(root, readSource);
+	const robots = readRobotsConfig(root, readSource);
+	const docsMcpRouteDir = join(root, appDir, "api", "docs", "mcp");
+	if (mcp.enabled && mcp.route === DEFAULT_MCP_ROUTE && !isStaticExport && !hasFile(docsMcpRouteDir, "route")) {
+		makeGeneratedDir(docsMcpRouteDir);
+		writeGeneratedFile(join(docsMcpRouteDir, "route.ts"), DOCS_MCP_ROUTE_TEMPLATE);
+	}
+	const apiReference = readApiReferenceConfig(root, readSource);
+	if (apiReference.enabled && !isStaticExport) {
+		const apiReferenceBaseDir = join(root, appDir, ...apiReference.path.split("/"));
+		const apiReferencePageDir = join(apiReferenceBaseDir, "[[...slug]]");
+		const apiReferencePagePath = join(apiReferencePageDir, "page.tsx");
+		const apiReferenceLayoutPath = join(apiReferenceBaseDir, "layout.tsx");
+		const apiReferenceRouteDir = join(apiReferenceBaseDir, "[[...slug]]");
+		const apiReferenceRoutePath = join(apiReferenceRouteDir, "route.ts");
+		const legacyApiReferencePagePath = join(apiReferenceBaseDir, "page.tsx");
+		if (apiReference.renderer === "fumadocs") {
+			removeManagedFile(apiReferenceRoutePath);
+			removeManagedFile(legacyApiReferencePagePath);
+			if (!hasFile(apiReferenceBaseDir, "layout") || isManagedGeneratedFile(apiReferenceLayoutPath)) {
+				makeGeneratedDir(apiReferenceBaseDir);
+				writeGeneratedFile(apiReferenceLayoutPath, API_REFERENCE_LAYOUT_TEMPLATE);
+			}
+			if (!hasFile(apiReferencePageDir, "page") || isManagedGeneratedFile(apiReferencePagePath)) {
+				makeGeneratedDir(apiReferencePageDir);
+				writeGeneratedFile(apiReferencePagePath, API_REFERENCE_PAGE_TEMPLATE);
+			}
+		} else {
+			removeManagedFile(apiReferenceLayoutPath);
+			removeManagedFile(apiReferencePagePath);
+			if (!hasFile(apiReferenceRouteDir, "route") || isManagedGeneratedFile(apiReferenceRoutePath)) {
+				makeGeneratedDir(apiReferenceRouteDir);
+				writeGeneratedFile(apiReferenceRoutePath, API_REFERENCE_ROUTE_TEMPLATE);
+			}
+		}
+	}
+	const changelog = readChangelogConfig(root, readSource);
+	if (changelog.enabled) {
+		const changelogBaseDir = join(root, appDir, entry, ...changelog.path.split("/"));
+		const changelogEntryDir = join(changelogBaseDir, "[slug]");
+		const changelogIndexPath = join(changelogBaseDir, "page.tsx");
+		const changelogEntryPath = join(changelogEntryDir, "page.tsx");
+		const changelogSourceDir = resolveChangelogContentDir(root, appDir, entry, changelog.contentDir, readSource);
+		const changelogUsesSourcePagesAsDetails = !isAbsolute(changelog.contentDir) && changelog.contentDir === changelog.path;
+		const changelogEntries = findChangelogSourceEntries(changelogSourceDir);
+		const changelogSourceLayoutPath = resolveManagedChangelogSourceLayoutPath(root, appDir, entry, changelog.contentDir, readSource);
+		const legacyChangelogBaseDirs = new Set([join(root, appDir, ...changelog.path.split("/")), ...isAbsolute(changelog.contentDir) ? [] : [join(root, appDir, ...changelog.contentDir.split("/"))]]);
+		for (const legacyChangelogBaseDir of legacyChangelogBaseDirs) {
+			if (legacyChangelogBaseDir === changelogBaseDir) continue;
+			removeManagedFile(join(legacyChangelogBaseDir, "[slug]", "page.tsx"));
+			removeManagedFile(join(legacyChangelogBaseDir, "page.tsx"));
+			removeManagedFile(join(legacyChangelogBaseDir, "__changelog.generated.tsx"));
+		}
+		makeGeneratedDir(changelogBaseDir);
+		removeManagedFile(join(changelogBaseDir, "__changelog.generated.tsx"));
+		if (!hasFile(changelogBaseDir, "page") || isManagedGeneratedFile(changelogIndexPath)) writeGeneratedFile(changelogIndexPath, buildChangelogIndexPageSource(root, changelogIndexPath, entry, changelog.path, changelogEntries));
+		if (changelogUsesSourcePagesAsDetails) {
+			removeManagedFile(changelogEntryPath);
+			if (changelogSourceLayoutPath) removeManagedFile(changelogSourceLayoutPath);
+		} else {
+			if (!hasFile(changelogEntryDir, "page") || isManagedGeneratedFile(changelogEntryPath)) {
+				makeGeneratedDir(changelogEntryDir);
+				writeGeneratedFile(changelogEntryPath, buildChangelogEntryPageSource(root, changelogEntryPath, entry, changelog.path, changelogEntries));
+			}
+			if (changelogSourceLayoutPath) {
+				const changelogSourceLayoutDir = dirname(changelogSourceLayoutPath);
+				if (!hasFile(changelogSourceLayoutDir, "layout") || isManagedGeneratedFile(changelogSourceLayoutPath)) {
+					makeGeneratedDir(changelogSourceLayoutDir);
+					writeGeneratedFile(changelogSourceLayoutPath, CHANGELOG_SOURCE_LAYOUT_TEMPLATE);
+				}
+			}
+		}
+	}
+	const ogEndpoint = readOgEndpoint(root, readSource);
+	const remarkPlugins = ["remark-gfm", "remark-frontmatter"];
+	if (ogEndpoint) remarkPlugins.push(["@farming-labs/next/mdx-plugins/remark-og", { endpoint: ogEndpoint }]);
+	remarkPlugins.push(["@farming-labs/next/mdx-plugins/remark-markdown-alternate", {
+		entry,
+		appDir,
+		contentDir: docsContentDir,
+		docsPath,
+		enabled: !isStaticExport
+	}]);
+	remarkPlugins.push(["remark-mdx-frontmatter", { name: "metadata" }], "@farming-labs/next/mdx-plugins/remark-code-group", "@farming-labs/next/mdx-plugins/remark-heading", ...mdx.remarkPlugins);
+	const withMDX = createMDX({
+		extension: /\.mdx?$/,
+		options: {
+			remarkPlugins,
+			rehypePlugins: [
+				"@farming-labs/next/mdx-plugins/rehype-toc",
+				mdx.codeHighlighter ?? ["@farming-labs/next/mdx-plugins/rehype-code", { themes: codeBlockThemes }],
+				...mdx.rehypePlugins
+			]
+		}
+	});
+	const defaultExts = [
+		"js",
+		"jsx",
+		"md",
+		"mdx",
+		"ts",
+		"tsx"
+	];
+	const userExts = nextConfig.pageExtensions;
+	if (userExts) {
+		for (const ext of ["md", "mdx"]) if (!userExts.includes(ext)) userExts.push(ext);
+	} else nextConfig.pageExtensions = defaultExts;
+	const publicDocsCloudAnalyticsEnv = createPublicDocsCloudAnalyticsEnv();
+	if (Object.keys(publicDocsCloudAnalyticsEnv).length > 0) nextConfig.env = {
+		...publicDocsCloudAnalyticsEnv,
+		...nextConfig.env
+	};
+	const existingTurbopack = nextConfig.turbopack ?? {};
+	const existingResolveAlias = existingTurbopack.resolveAlias ?? {};
+	nextConfig.turbopack = {
+		...existingTurbopack,
+		...workspaceRoot && !existingTurbopack.root ? { root: workspaceRoot } : {},
+		resolveAlias: {
+			...workspaceRoot ? createDocsWorkspaceAliases(root, workspaceRoot) : {},
+			...existingResolveAlias,
+			[INTERNAL_DOCS_CONFIG_ALIAS]: docsConfigRelativeAlias,
+			[AGENT_SKILLS_BUNDLE_ALIAS]: toTurbopackAliasPath(root, agentSkillsBundlePath),
+			"fumadocs-openapi": toTurbopackAliasPath(root, FUMADOCS_OPENAPI_PACKAGE_ALIAS),
+			"fumadocs-openapi/ui": toTurbopackAliasPath(root, FUMADOCS_OPENAPI_UI_ALIAS),
+			"fumadocs-openapi/server": toTurbopackAliasPath(root, FUMADOCS_OPENAPI_SERVER_ALIAS),
+			"fumadocs-core": toTurbopackAliasPath(root, FUMADOCS_CORE_PACKAGE_ALIAS),
+			"fumadocs-core/framework": toTurbopackAliasPath(root, FUMADOCS_CORE_FRAMEWORK_ALIAS),
+			"fumadocs-core/framework/next": toTurbopackAliasPath(root, FUMADOCS_CORE_FRAMEWORK_NEXT_ALIAS),
+			"fumadocs-ui": toTurbopackAliasPath(root, FUMADOCS_UI_PACKAGE_ALIAS),
+			"fumadocs-ui/layouts/notebook": toTurbopackAliasPath(root, FUMADOCS_UI_NOTEBOOK_ALIAS),
+			"fumadocs-ui/layouts/notebook/page": toTurbopackAliasPath(root, FUMADOCS_UI_NOTEBOOK_PAGE_ALIAS),
+			"fumadocs-ui/provider/next": toTurbopackAliasPath(root, FUMADOCS_UI_PROVIDER_NEXT_ALIAS)
+		}
+	};
+	const userWebpack = nextConfig.webpack;
+	nextConfig.webpack = (config, options) => {
+		const resolvedConfig = userWebpack ? userWebpack(config, options) : config;
+		resolvedConfig.resolve ??= {};
+		resolvedConfig.resolve.alias ??= {};
+		if (workspaceRoot) Object.assign(resolvedConfig.resolve.alias, {
+			"@farming-labs/docs$": join(workspaceRoot, "packages", "docs", "dist", "index.mjs"),
+			"@farming-labs/docs/server": join(workspaceRoot, "packages", "docs", "dist", "server.mjs"),
+			"@farming-labs/docs/cloud/server": join(workspaceRoot, "packages", "docs", "dist", "docs-cloud-server.mjs"),
+			"@farming-labs/next$": join(workspaceRoot, "packages", "next", "dist", "index.mjs"),
+			"@farming-labs/next/api": join(workspaceRoot, "packages", "next", "dist", "api.mjs"),
+			"@farming-labs/next/changelog": join(workspaceRoot, "packages", "next", "dist", "changelog.mjs"),
+			"@farming-labs/next/client-callbacks": join(workspaceRoot, "packages", "next", "dist", "client-callbacks.mjs"),
+			"@farming-labs/next/layout": join(workspaceRoot, "packages", "next", "dist", "layout.mjs"),
+			"@farming-labs/next/mdx-plugins/remark-markdown-alternate": join(workspaceRoot, "packages", "next", "dist", "mdx-plugins", "remark-markdown-alternate.mjs"),
+			"@farming-labs/theme$": join(workspaceRoot, "packages", "fumadocs", "dist", "index.mjs"),
+			"@farming-labs/theme/api": join(workspaceRoot, "packages", "fumadocs", "dist", "docs-api.mjs")
+		});
+		resolvedConfig.resolve.alias[INTERNAL_DOCS_CONFIG_ALIAS] = docsConfigAbsolutePath;
+		resolvedConfig.resolve.alias[AGENT_SKILLS_BUNDLE_ALIAS] = agentSkillsBundlePath;
+		resolvedConfig.resolve.plugins ??= [];
+		resolvedConfig.resolve.plugins.push(new DocsPackageResolutionPlugin({
+			"fumadocs-core": FUMADOCS_CORE_PACKAGE_ALIAS,
+			"fumadocs-ui": FUMADOCS_UI_PACKAGE_ALIAS,
+			"fumadocs-openapi": FUMADOCS_OPENAPI_PACKAGE_ALIAS
+		}));
+		return resolvedConfig;
+	};
+	const existingTracingIncludes = nextConfig.outputFileTracingIncludes ?? {};
+	const existingTracingExcludes = nextConfig.outputFileTracingExcludes ?? {};
+	const docsTraceGlob = docsContentDir.replace(/\\/g, "/").replace(/^\.?\//, "") + "/**/*";
+	const sitemapManifestTraceFile = DEFAULT_SITEMAP_MANIFEST_PATH;
+	const docsContentRoot = isAbsolute(docsContentDir) ? docsContentDir : join(root, docsContentDir);
+	if (!isStaticExport) {
+		const existingRewrites = nextConfig.rewrites;
+		nextConfig.rewrites = async () => {
+			return mergeDocsMarkdownRewrites(entry, docsPath, apiReference, mcp, sitemap, agentFeedback, robots, typeof existingRewrites === "function" ? await existingRewrites() : existingRewrites);
+		};
+		const autoRedirects = buildHiddenFolderRedirects(docsContentRoot, docsPath);
+		if (autoRedirects.length > 0) {
+			const existingRedirects = nextConfig.redirects;
+			nextConfig.redirects = async () => {
+				return mergeDocsRedirects(autoRedirects, typeof existingRedirects === "function" ? await existingRedirects() : existingRedirects);
+			};
+		}
+	}
+	nextConfig.outputFileTracingIncludes = {
+		...existingTracingIncludes,
+		"/api/docs": [...new Set([
+			...existingTracingIncludes["/api/docs"] ?? [],
+			docsTraceGlob,
+			sitemapManifestTraceFile
+		])],
+		[DEFAULT_MCP_ROUTE]: [...new Set([...existingTracingIncludes[DEFAULT_MCP_ROUTE] ?? [], docsTraceGlob])]
+	};
+	nextConfig.outputFileTracingExcludes = {
+		...existingTracingExcludes,
+		"/api/docs": [...new Set([
+			...existingTracingExcludes["/api/docs"] ?? [],
+			"next.config.js",
+			"next.config.mjs",
+			"next.config.ts"
+		])],
+		[DEFAULT_MCP_ROUTE]: [...new Set([
+			...existingTracingExcludes[DEFAULT_MCP_ROUTE] ?? [],
+			"next.config.js",
+			"next.config.mjs",
+			"next.config.ts"
+		])]
+	};
+	return withMDX(nextConfig);
+}
+
+//#endregion
+export { withDocs as t };