@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-Q5B4LNON.mjs

@@ -0,0 +1,19 @@
+// src/write-file-if-changed.ts
+import { readFileSync, writeFileSync } from "fs";
+function writeFileIfChanged(filePath, content) {
+  try {
+    if (readFileSync(filePath, "utf8") === content) {
+      return false;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  writeFileSync(filePath, content, "utf8");
+  return true;
+}
+
+export {
+  writeFileIfChanged
+};

package/dist/chunk-QFQDRJKJ.mjs

@@ -0,0 +1,666 @@
+import {
+  discoverFarmDocsPages,
+  getFarmDocsMarkdownPath,
+  loadFarmDocsPage,
+  resolveFarmDocsContentDir,
+  toFarmDocsMarkdownPage
+} from "./chunk-GXSMF7UR.mjs";
+import {
+  docsEngine,
+  loadFarmDocsEngine
+} from "./chunk-VE3FWJBO.mjs";
+import {
+  resolveDocsConfig
+} from "./chunk-VJXLUTBM.mjs";
+import {
+  getFarmDocsAdapterConfigModule,
+  isSecretDocsConfigKey
+} from "./chunk-EJCVG25Z.mjs";
+
+// src/docs/adapter.ts
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+function hasFarmDocsRuntimeAdapter(docs) {
+  return Boolean(docs?.enabled && docs.adapter?.server && docs.adapter.react);
+}
+function assertFarmDocsAdapterServesNoGuardedPages(docs, options, isPathGuarded) {
+  if (!isPathGuarded || !hasFarmDocsRuntimeAdapter(docs)) return;
+  const guarded = discoverFarmDocsPages(resolveFarmDocsContentDir(docs, options), docs).filter((page) => isPathGuarded(page.href) || isPathGuarded(getFarmDocsMarkdownPath(page.href))).map((page) => page.href);
+  if (guarded.length === 0) return;
+  throw new Error(
+    `Docs pages behind a path guard (${guarded.join(", ")}) would be public: the docs adapter ${JSON.stringify(docs.adapter.id)} serves their content in llms-full.txt, search, Markdown, and MCP without running the app's guards. Move those pages out of the docs content directory, or set docs.adapter = false to use Farm's built-in docs runtime, which keeps guarded pages off anonymous surfaces.`
+  );
+}
+async function loadFarmDocsConfigModule(docs, loadModule) {
+  const configModule = getFarmDocsAdapterConfigModule(docs);
+  if (!configModule) return void 0;
+  const loaded = await loadModule(configModule);
+  const config = loaded?.default ?? loaded;
+  return config && typeof config === "object" ? config : void 0;
+}
+function createFarmDocsAdapterRuntimeConfig(docs, options, moduleConfig) {
+  return {
+    ...moduleConfig ? { ...moduleConfig, ...docs.configOverrides } : docs.runtimeConfig ?? docs.config,
+    entry: docs.config.entry || docs.entry.replace(/^\/+|\/+$/g, "") || "docs",
+    docsPath: docs.entry,
+    contentDir: resolveFarmDocsContentDir(docs, options)
+  };
+}
+function getFarmDocsAdapterStylesheets(options) {
+  return [options.fontStylesheetHref, options.globalStylesheetHref].filter(
+    (value) => typeof value === "string" && value.length > 0
+  );
+}
+async function compileFarmDocsAdapterEdgeManifest(docs, options) {
+  if (!hasFarmDocsRuntimeAdapter(docs)) {
+    throw new Error("Farm docs adapter requires server and react runtime entrypoints.");
+  }
+  const compilerEntry = docs.adapter.edgeCompiler;
+  if (!compilerEntry) {
+    throw new Error(
+      `Farm docs adapter ${JSON.stringify(docs.adapter.id)} does not declare the edge compiler required for this deployment.`
+    );
+  }
+  const requireFromApp = createRequire(path.join(options.root, "package.json"));
+  let compilerPath;
+  try {
+    compilerPath = requireFromApp.resolve(compilerEntry);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Farm docs adapter ${JSON.stringify(docs.adapter.id)} edge compiler ${JSON.stringify(compilerEntry)} could not be resolved from the application: ${message}`
+    );
+  }
+  const compilerModule = await import(
+    /* @vite-ignore */
+    pathToFileURL(compilerPath).href
+  );
+  if (typeof compilerModule.compileFarmDocsEdgeManifest !== "function") {
+    throw new Error(
+      `Farm docs adapter ${JSON.stringify(docs.adapter.id)} does not export compileFarmDocsEdgeManifest from ${JSON.stringify(compilerEntry)}.`
+    );
+  }
+  const manifest = await compilerModule.compileFarmDocsEdgeManifest(
+    createFarmDocsAdapterRuntimeConfig(docs, options),
+    {
+      rootDir: options.root,
+      clientEntry: options.clientEntry,
+      stylesheets: getFarmDocsAdapterStylesheets(options)
+    }
+  );
+  if (!manifest || manifest.protocol !== 1 || !manifest.routes || typeof manifest.routes !== "object" || !manifest.api || typeof manifest.api !== "object") {
+    throw new Error(
+      `Farm docs adapter ${JSON.stringify(docs.adapter.id)} returned an invalid edge manifest.`
+    );
+  }
+  return manifest;
+}
+async function createFarmDocsAdapterHandler(docs, options) {
+  if (!hasFarmDocsRuntimeAdapter(docs)) {
+    throw new Error("Farm docs adapter requires server and react runtime entrypoints.");
+  }
+  assertFarmDocsAdapterServesNoGuardedPages(docs, options, options.isPathGuarded);
+  const serverModule = await options.loadModule(
+    docs.adapter.server
+  );
+  if (typeof serverModule.createFarmDocsRuntimeHandler !== "function") {
+    const adapterId = JSON.stringify(docs.adapter.id);
+    const serverEntry = JSON.stringify(docs.adapter.server);
+    throw new Error(
+      `Farm docs adapter ${adapterId} does not export createFarmDocsRuntimeHandler from ${serverEntry}. Upgrade the adapter to a runtime-enabled release.`
+    );
+  }
+  const runtimeConfig = createFarmDocsAdapterRuntimeConfig(
+    docs,
+    options,
+    await loadFarmDocsConfigModule(docs, options.loadModule)
+  );
+  return serverModule.createFarmDocsRuntimeHandler(runtimeConfig, {
+    rootDir: options.root,
+    clientEntry: options.clientEntry,
+    stylesheets: getFarmDocsAdapterStylesheets(options),
+    resolveLayoutFonts: options.resolveLayoutFonts,
+    loadReactModule: () => options.loadModule(docs.adapter.react),
+    ...options.registerMCPServer ? { registerMCPServer: options.registerMCPServer } : {}
+  });
+}
+
+// src/docs/api.ts
+import path2 from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isResolvedDocsConfig(value) {
+  return isRecord(value) && typeof value.enabled === "boolean" && typeof value.entry === "string" && isRecord(value.config);
+}
+function isFarmDocsAPIRequest(requestOrPathname) {
+  const pathname = typeof requestOrPathname === "string" ? requestOrPathname : new URL(requestOrPathname.url).pathname;
+  return pathname === "/api/docs" || pathname.startsWith("/api/docs/");
+}
+function json(data, init = {}) {
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  return new Response(JSON.stringify(data), { ...init, headers });
+}
+function text(content, contentType, init = {}) {
+  const headers = new Headers(init.headers);
+  headers.set("Content-Type", contentType);
+  return new Response(content, { ...init, headers });
+}
+function omitHeadBody(response) {
+  return new Response(null, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function normalizeAction(value) {
+  return value?.trim().toLowerCase().replace(/_/g, "-") || void 0;
+}
+function getDocsTitle(docs) {
+  return typeof docs.config.nav === "object" && docs.config.nav && "title" in docs.config.nav ? String(docs.config.nav.title || "Documentation") : "Documentation";
+}
+function isDocsCloudServer(value) {
+  return isRecord(value) && typeof value.handleRequest === "function";
+}
+function resolveDocsCloudIntegration(integration) {
+  if (!integration) return void 0;
+  if (isDocsCloudServer(integration)) {
+    return { docsCloud: integration, routeOptions: {} };
+  }
+  if (!integration.docsCloud) return void 0;
+  return {
+    docsCloud: integration.docsCloud,
+    routeOptions: {
+      locale: integration.locale,
+      publicBaseUrl: integration.publicBaseUrl
+    }
+  };
+}
+function isDocsCloudGetRequest(request) {
+  const url = new URL(request.url);
+  const cloud = normalizeAction(url.searchParams.get("cloud"));
+  const action = normalizeAction(url.searchParams.get("action"));
+  const format = normalizeAction(url.searchParams.get("format"));
+  return cloud === "config" || cloud === "public-config" || action === "cloud-config" || action === "docs-cloud-config" || format === "cloud-config" || format === "docs-cloud-config";
+}
+function isDocsCloudAction(action) {
+  return Boolean(
+    action && ["analytics", "track", "track-event", "event", "ask-ai", "ai", "chat", "docs-cloud"].includes(
+      action
+    )
+  );
+}
+async function readJson(request) {
+  try {
+    return await request.clone().json();
+  } catch {
+    return void 0;
+  }
+}
+async function isDocsCloudPostRequest(request) {
+  const url = new URL(request.url);
+  const cloud = normalizeAction(url.searchParams.get("cloud"));
+  const action = normalizeAction(url.searchParams.get("action"));
+  if (isDocsCloudAction(cloud) || isDocsCloudAction(action)) return true;
+  const body = await readJson(request);
+  if (!isRecord(body)) return false;
+  const bodyAction = normalizeAction(typeof body.action === "string" ? body.action : void 0);
+  if (isDocsCloudAction(bodyAction)) return true;
+  if (typeof body.type === "string") return true;
+  if (isRecord(body.event) && typeof body.event.type === "string") return true;
+  if (isRecord(body.payload) && typeof body.payload.type === "string") return true;
+  return false;
+}
+function normalizeDocsApiSlug(value, docs) {
+  const entry = docs.entry.replace(/^\/+|\/+$/g, "");
+  let slug = (value || "").trim().replace(/^\/+|\/+$/g, "");
+  if (entry && slug === entry) return "";
+  if (entry && slug.startsWith(`${entry}/`)) {
+    slug = slug.slice(entry.length + 1);
+  }
+  let decoded = slug;
+  try {
+    decoded = decodeURIComponent(slug);
+  } catch {
+  }
+  return decoded.replace(/\.(mdx?|markdown)$/i, "");
+}
+function getDocsAPIPathTarget(request) {
+  const pathname = new URL(request.url).pathname.replace(/\/+$/, "") || "/";
+  const prefix = "/api/docs";
+  if (pathname !== prefix && !pathname.startsWith(`${prefix}/`)) return {};
+  const rawValue = pathname === prefix ? "" : pathname.slice(prefix.length + 1);
+  const value = rawValue.replace(/^\/+|\/+$/g, "");
+  const normalizedValue = normalizeAction(value);
+  if (!value) return {};
+  if (normalizedValue === "agent" || normalizedValue === "agent.json" || normalizedValue === "agent/spec") {
+    return { format: "agent-spec" };
+  }
+  if (normalizedValue === "agents" || normalizedValue === "agents.md" || normalizedValue === "agent.md") {
+    return { format: "agents" };
+  }
+  if (normalizedValue === "skill" || normalizedValue === "skill.md") return { format: "skill" };
+  if (normalizedValue === "llms.txt") return { format: "llms" };
+  if (normalizedValue === "llms-full.txt") return { format: "llms-full" };
+  if (normalizedValue === "sitemap.md") return { format: "sitemap-md" };
+  if (normalizedValue === "sitemap.xml") return { format: "sitemap-xml" };
+  if (normalizedValue === "robots.txt") return { format: "robots" };
+  if (/\.(mdx?|markdown)$/i.test(value)) return { format: "markdown", slug: value };
+  return { slug: value };
+}
+function getDocsAPIFormat(request) {
+  const url = new URL(request.url);
+  return normalizeAction(url.searchParams.get("format") || url.searchParams.get("type")) || getDocsAPIPathTarget(request).format;
+}
+function getDocsDescription(docs) {
+  return docs.config.metadata?.description;
+}
+function getLoadedDocsPages(context) {
+  return discoverFarmDocsPages(context.contentDir, context.docs).filter((page) => !context.isPathGuarded(page.href)).map((page) => loadFarmDocsPage(context.contentDir, context.docs, page.slug)).filter((page) => Boolean(page));
+}
+function toDocsSourcePage(page) {
+  return {
+    ...toFarmDocsMarkdownPage(page),
+    sourcePath: page.sourcePath
+  };
+}
+function toDocsSitemapPage(page) {
+  return {
+    ...toFarmDocsMarkdownPage(page),
+    sourcePath: page.sourcePath
+  };
+}
+function toDocsLlmsPage(page) {
+  return toFarmDocsMarkdownPage(page);
+}
+function getDocsLlmsOptions(context, request) {
+  const configured = isRecord(context.docs.config.llmsTxt) ? context.docs.config.llmsTxt : {};
+  return {
+    enabled: true,
+    baseUrl: new URL(request.url).origin,
+    siteTitle: getDocsTitle(context.docs),
+    siteDescription: getDocsDescription(context.docs),
+    ...configured
+  };
+}
+function getDocsDiscoveryOptions(context, request) {
+  const origin = new URL(request.url).origin;
+  return {
+    origin,
+    entry: context.docs.entry,
+    i18n: null,
+    search: context.docs.config.search ?? true,
+    mcp: {
+      enabled: false,
+      route: "/api/docs/mcp",
+      name: `${getDocsTitle(context.docs)} MCP`,
+      version: "1",
+      tools: {
+        listDocs: false,
+        listPages: false,
+        readPage: false,
+        searchDocs: false,
+        getNavigation: false,
+        getCodeExamples: false,
+        getConfigSchema: false,
+        getContext: false
+      }
+    },
+    feedback: void 0,
+    llms: getDocsLlmsOptions(context, request),
+    sitemap: context.docs.config.sitemap ?? true,
+    robots: context.docs.config.robots ?? true,
+    openapi: docsEngine().resolveApiReferenceOpenApiDiscovery(context.docs.config.apiReference),
+    markdown: {
+      acceptHeader: true,
+      signatureAgentHeader: true
+    }
+  };
+}
+function buildSitemapManifest(context, request) {
+  const origin = new URL(request.url).origin;
+  return docsEngine().buildDocsSitemapManifest({
+    pages: getLoadedDocsPages(context).map(toDocsSitemapPage),
+    entry: context.docs.entry,
+    siteTitle: getDocsTitle(context.docs),
+    baseUrl: origin
+  });
+}
+function renderLlmsTxt(context, request, full) {
+  const generated = docsEngine().renderDocsLlmsTxt(
+    getLoadedDocsPages(context).map(toDocsLlmsPage),
+    getDocsLlmsOptions(context, request)
+  );
+  return full ? generated.llmsFullTxt : generated.llmsTxt;
+}
+function renderSkillDocument(context, request) {
+  const farmAliases = [
+    "## Farm API Route Aliases",
+    "",
+    "- Search JSON: /api/docs?query=<term>",
+    "- Config JSON: /api/docs?format=config",
+    "- Markdown by query: /api/docs?format=markdown&path=<slug>",
+    "- Markdown by path: /api/docs/<slug>.md",
+    "- LLM summary: /api/docs?format=llms",
+    "- Full LLM document: /api/docs?format=llms-full",
+    "- Sitemap XML: /api/docs?format=sitemap-xml",
+    "- Agent spec JSON: /api/docs/agent/spec"
+  ].join("\n");
+  return `${docsEngine().renderDocsSkillDocument(getDocsDiscoveryOptions(context, request)).trim()}
+
+${farmAliases}
+`;
+}
+function renderAgentsDocument(context, request) {
+  return `${docsEngine().renderDocsAgentsDocument(getDocsDiscoveryOptions(context, request)).trim()}
+`;
+}
+function buildAgentSpec(context, request) {
+  const url = new URL(request.url);
+  const origin = url.origin;
+  const pages = discoverFarmDocsPages(context.contentDir, context.docs).filter(
+    (page) => !context.isPathGuarded(page.href)
+  );
+  const spec = docsEngine().buildDocsAgentDiscoverySpec(getDocsDiscoveryOptions(context, request));
+  const title = getDocsTitle(context.docs);
+  return {
+    ...spec,
+    name: title,
+    site: {
+      ...spec.site,
+      title,
+      description: getDocsDescription(context.docs),
+      entry: context.docs.entry
+    },
+    entry: context.docs.entry,
+    routes: {
+      docs: `${origin}${context.docs.entry}`,
+      config: `${origin}/api/docs?format=config`,
+      search: `${origin}/api/docs?query=<term>`,
+      markdown: `${origin}/api/docs/<slug>.md`,
+      markdownQuery: `${origin}/api/docs?format=markdown&path=<slug>`,
+      llms: `${origin}/api/docs?format=llms`,
+      llmsFull: `${origin}/api/docs?format=llms-full`,
+      sitemapXml: `${origin}/api/docs?format=sitemap-xml`,
+      sitemapMarkdown: `${origin}/api/docs?format=sitemap-md`,
+      robots: `${origin}/api/docs?format=robots`,
+      skill: `${origin}/api/docs?format=skill`,
+      agents: `${origin}/api/docs?format=agents`,
+      agentSpec: `${origin}/api/docs/agent/spec`
+    },
+    capabilities: {
+      ...spec.capabilities,
+      search: spec.capabilities.search,
+      markdown: spec.capabilities.markdownRoutes,
+      llms: spec.capabilities.llms,
+      sitemap: spec.capabilities.sitemap,
+      robots: spec.capabilities.robots,
+      post: false
+    },
+    // Same root-relative source paths the precompiled runtime serves.
+    pages: pages.map(({ sourcePath, ...page }) => {
+      const publicSourcePath = toPublicDocsPath(sourcePath, context.root);
+      return publicSourcePath ? { ...page, sourcePath: `./${publicSourcePath}` } : page;
+    })
+  };
+}
+var REDACTED_DOCS_CONFIG_VALUE = "[redacted]";
+function redactDocsConfigValue(value, key, inHeaders) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactDocsConfigValue(entry, key, inHeaders));
+  }
+  if (isRecord(value) && !(value instanceof Date) && !(value instanceof URL)) {
+    const headers = inHeaders || key.toLowerCase() === "headers";
+    return Object.fromEntries(
+      Object.entries(value).map(([childKey, child]) => [
+        childKey,
+        redactDocsConfigValue(child, childKey, headers)
+      ])
+    );
+  }
+  if (value === null || value === void 0 || typeof value === "function") return value;
+  return inHeaders || isSecretDocsConfigKey(key) ? REDACTED_DOCS_CONFIG_VALUE : value;
+}
+function toPublicDocsPath(value, root) {
+  if (typeof value !== "string" || !value) return void 0;
+  if (!path2.isAbsolute(value)) return value;
+  const relative = path2.relative(root, value);
+  if (path2.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path2.sep}`)) {
+    return void 0;
+  }
+  return relative.split(path2.sep).join("/") || ".";
+}
+function buildPublicConfig(context) {
+  const redacted = redactDocsConfigValue(context.docs.config, "", false);
+  const contentDir = toPublicDocsPath(redacted.contentDir, context.root);
+  const publicInput = { ...redacted, contentDir };
+  const map = docsEngine().buildDocsConfigMap(publicInput, {
+    file: toPublicDocsPath(context.docs.configPath, context.root) || "farm.config.ts"
+  });
+  const config = Object.fromEntries(Object.keys(map.values).map((key) => [key, publicInput[key]]));
+  return {
+    entry: context.docs.entry,
+    contentDir: toPublicDocsPath(context.docs.contentDir, context.root) || contentDir || null,
+    config,
+    map
+  };
+}
+function buildDiagnostics(context) {
+  const pages = discoverFarmDocsPages(context.contentDir, context.docs);
+  const diagnostics = docsEngine().buildDocsDiagnostics(context.docs.config, {
+    entry: context.docs.entry,
+    mcp: {
+      enabled: false,
+      route: "/api/docs/mcp",
+      name: `${getDocsTitle(context.docs)} MCP`,
+      version: "1",
+      tools: {
+        listDocs: false,
+        listPages: false,
+        readPage: false,
+        searchDocs: false,
+        getNavigation: false,
+        getCodeExamples: false,
+        getConfigSchema: false,
+        getContext: false
+      }
+    }
+  });
+  return {
+    ...diagnostics,
+    enabled: context.docs.enabled,
+    entry: context.docs.entry,
+    root: context.root,
+    srcDir: context.srcDir,
+    contentDir: context.contentDir,
+    configPath: context.docs.configPath || null,
+    pageCount: pages.length,
+    pages
+  };
+}
+async function searchDocs(context, request, query) {
+  const loadedPages = getLoadedDocsPages(context);
+  const sourcePages = loadedPages.map(toDocsSourcePage);
+  const sourcePageByUrl = new Map(sourcePages.map((page) => [page.url, page]));
+  const resultLimit = isRecord(context.docs.config.search) && typeof context.docs.config.search.maxResults === "number" ? context.docs.config.search.maxResults : void 0;
+  const results = await docsEngine().performDocsSearch({
+    pages: sourcePages,
+    query,
+    search: context.docs.config.search ?? true,
+    pathname: new URL(request.url).pathname,
+    siteTitle: getDocsTitle(context.docs),
+    limit: resultLimit
+  });
+  return results.map((result) => {
+    const pageUrl = result.url.split("#")[0];
+    const page = sourcePageByUrl.get(pageUrl);
+    return {
+      ...result,
+      title: page?.title || result.content,
+      href: page?.url || pageUrl,
+      description: result.description || page?.description
+    };
+  });
+}
+async function resolveAPIContext(options) {
+  await loadFarmDocsEngine();
+  const runtimeConfig = globalThis.__FARM_DOCS_RUNTIME_CONFIG__;
+  const root = options.rootDir || options.root || runtimeConfig?.root || process.cwd();
+  const srcDir = options.srcDir || runtimeConfig?.srcDir || "src";
+  const canUseRuntimeDocs = options.docs === void 0 && options.config === void 0 && options.configPath === void 0 && options.entry === void 0 && options.docsPath === void 0 && options.contentDir === void 0 && options.root === void 0 && options.rootDir === void 0 && options.srcDir === void 0;
+  const docsInput = options.docs ?? (canUseRuntimeDocs ? runtimeConfig?.docs : void 0) ?? {
+    enabled: true,
+    entry: options.entry,
+    docsPath: options.docsPath,
+    contentDir: options.contentDir,
+    config: options.config,
+    configPath: options.configPath
+  };
+  const docs = isResolvedDocsConfig(docsInput) ? docsInput : await resolveDocsConfig(docsInput, { root, srcDir });
+  const guardedPaths = new Set(runtimeConfig?.guardedPaths ?? []);
+  return {
+    root,
+    srcDir,
+    docs,
+    contentDir: resolveFarmDocsContentDir(docs, { root, srcDir }),
+    diagnostics: options.diagnostics === true,
+    isPathGuarded: options.isPathGuarded ?? ((pathname) => guardedPaths.has(pathname))
+  };
+}
+async function handleDocsAPIGet(request, context) {
+  if (!context.docs.enabled) {
+    return json({ error: "Docs are disabled" }, { status: 404 });
+  }
+  const url = new URL(request.url);
+  const format = getDocsAPIFormat(request);
+  const pathTarget = getDocsAPIPathTarget(request);
+  if (format === "config" || format === "docs-config") {
+    return json(buildPublicConfig(context));
+  }
+  if (format === "skill")
+    return text(renderSkillDocument(context, request), "text/markdown; charset=utf-8");
+  if (format === "agents")
+    return text(renderAgentsDocument(context, request), "text/markdown; charset=utf-8");
+  if (format === "agent" || format === "agent-spec") return json(buildAgentSpec(context, request));
+  if (format === "diagnostics") {
+    return context.diagnostics ? json(buildDiagnostics(context)) : json({ error: "Docs diagnostics are only available in development" }, { status: 404 });
+  }
+  if (format === "llms")
+    return text(renderLlmsTxt(context, request, false), "text/plain; charset=utf-8");
+  if (format === "llms-full")
+    return text(renderLlmsTxt(context, request, true), "text/plain; charset=utf-8");
+  if (format === "sitemap-md") {
+    return text(
+      docsEngine().renderDocsSitemapMarkdown(buildSitemapManifest(context, request), {
+        includeDescriptions: true
+      }),
+      "text/markdown; charset=utf-8"
+    );
+  }
+  if (format === "sitemap-xml" || format === "sitemap") {
+    const origin = new URL(request.url).origin;
+    return text(
+      docsEngine().renderDocsSitemapXml(buildSitemapManifest(context, request), {
+        baseUrl: origin,
+        includeLastmod: true
+      }),
+      "application/xml; charset=utf-8"
+    );
+  }
+  if (format === "robots") {
+    return text(
+      docsEngine().renderDocsRobotsTxt({
+        entry: context.docs.entry,
+        sitemap: context.docs.config.sitemap ?? true,
+        robots: context.docs.config.robots ?? true,
+        baseUrl: new URL(request.url).origin
+      }),
+      "text/plain; charset=utf-8"
+    );
+  }
+  if (format === "markdown" || url.pathname.endsWith(".md")) {
+    const pathParam = url.searchParams.get("path") || url.searchParams.get("slug");
+    const slug = normalizeDocsApiSlug(pathParam ?? pathTarget.slug ?? "", context.docs);
+    const page = loadFarmDocsPage(context.contentDir, context.docs, slug);
+    if (!page || context.isPathGuarded(page.href)) {
+      return text("Docs page not found\n", "text/plain; charset=utf-8", { status: 404 });
+    }
+    return text(
+      docsEngine().renderDocsMarkdownDocument(toFarmDocsMarkdownPage(page), {
+        origin: new URL(request.url).origin,
+        llms: getDocsLlmsOptions(context, request),
+        sitemap: context.docs.config.sitemap
+      }),
+      "text/markdown; charset=utf-8"
+    );
+  }
+  const query = url.searchParams.get("query") || url.searchParams.get("q") || "";
+  if (!query.trim()) return json([]);
+  return json(await searchDocs(context, request, query));
+}
+function createDocsAPI(options = {}, cloudIntegration) {
+  let contextPromise;
+  const getContext = () => {
+    contextPromise ?? (contextPromise = resolveAPIContext(options));
+    return contextPromise;
+  };
+  const integration = resolveDocsCloudIntegration(cloudIntegration);
+  return {
+    async GET(request) {
+      if (integration && isDocsCloudGetRequest(request)) {
+        return integration.docsCloud.handleRequest(request, integration.routeOptions);
+      }
+      return handleDocsAPIGet(request, await getContext());
+    },
+    async POST(request) {
+      if (integration && await isDocsCloudPostRequest(request)) {
+        return integration.docsCloud.handleRequest(request, integration.routeOptions);
+      }
+      return json(
+        {
+          error: "AI is not enabled for this Farm docs API route yet."
+        },
+        { status: 501 }
+      );
+    }
+  };
+}
+function createFarmDocsAPIHandler(options = {}, cloudIntegration) {
+  const handlers = createDocsAPI(options, cloudIntegration);
+  return async function handleFarmDocsAPIRequest(request) {
+    if (!isFarmDocsAPIRequest(request)) return null;
+    const method = request.method.toUpperCase();
+    if (method === "GET" || method === "HEAD") {
+      const response = await handlers.GET(request);
+      return method === "HEAD" ? omitHeadBody(response) : response;
+    }
+    if (method === "POST") {
+      return handlers.POST(request);
+    }
+    return json(
+      {
+        error: "Method Not Allowed"
+      },
+      {
+        status: 405,
+        headers: {
+          Allow: "GET, HEAD, POST"
+        }
+      }
+    );
+  };
+}
+
+export {
+  hasFarmDocsRuntimeAdapter,
+  assertFarmDocsAdapterServesNoGuardedPages,
+  compileFarmDocsAdapterEdgeManifest,
+  createFarmDocsAdapterHandler,
+  isFarmDocsAPIRequest,
+  createDocsAPI,
+  createFarmDocsAPIHandler
+};