@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-LSZAVSGY.mjs

@@ -0,0 +1,1101 @@
+import {
+  FARM_DEFAULT_MCP_TOOLS
+} from "./chunk-UH6QN5NL.mjs";
+import {
+  DEFAULT_ERROR_STYLES
+} from "./chunk-XAXTTBUT.mjs";
+import {
+  serializeFarmLlmsTxt
+} from "./chunk-DTSROJ5J.mjs";
+import {
+  emitFarmAgentRead
+} from "./chunk-MVL2RAJW.mjs";
+import {
+  resolveFarmThemeConfig
+} from "./chunk-AELACLOB.mjs";
+import {
+  omitFarmResponseBody
+} from "./chunk-5WI2S4CO.mjs";
+import {
+  _listFarmMCPCatalogs,
+  _listFarmRegisteredMCPServers
+} from "./chunk-ZLAT2CWY.mjs";
+import {
+  createFarmWeakETag,
+  matchesFarmIfNoneMatch
+} from "./chunk-ZMMBIVQM.mjs";
+import {
+  resolveFarmAPIServerBasePath,
+  resolveFarmAPIServerRoutePath
+} from "./chunk-BTHHUD7Q.mjs";
+import {
+  FARM_VERSION
+} from "./chunk-OO7GXVSR.mjs";
+import {
+  localizeFarmPathname
+} from "./chunk-L3KT7IXV.mjs";
+import {
+  applyFarmBasePath
+} from "./chunk-4RB44K6Z.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/routing/route-groups.ts
+function isRouteGroupSegment(part) {
+  return part.startsWith("(") && part.endsWith(")");
+}
+__name(isRouteGroupSegment, "isRouteGroupSegment");
+function formatRouteSegment(segment) {
+  if (!segment.isDynamic) return segment.segment;
+  if (segment.isCatchAll) {
+    return segment.isOptional ? `[[...${segment.segment}]]` : `[...${segment.segment}]`;
+  }
+  return `[${segment.segment}]`;
+}
+__name(formatRouteSegment, "formatRouteSegment");
+function createRouteDirectoryPattern(route) {
+  const parts = route.filePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  parts.pop();
+  if (parts.length === 0) return "/";
+  let segmentIndex = 0;
+  const directory = parts.map((part) => {
+    if (isRouteGroupSegment(part)) return part;
+    const segment = route.segments[segmentIndex++];
+    return segment ? formatRouteSegment(segment) : part;
+  });
+  return `/${directory.join("/")}`;
+}
+__name(createRouteDirectoryPattern, "createRouteDirectoryPattern");
+function stripRouteGroups(pattern) {
+  if (!pattern.includes("(")) return pattern;
+  const parts = pattern.split("/").filter((part) => part && !isRouteGroupSegment(part));
+  return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+}
+__name(stripRouteGroups, "stripRouteGroups");
+function getRouteGroupScope(pattern) {
+  if (!pattern.includes("(")) return null;
+  const parts = pattern.split("/");
+  for (let index = parts.length - 1; index > 0; index--) {
+    if (isRouteGroupSegment(parts[index])) return parts.slice(0, index + 1).join("/");
+  }
+  return null;
+}
+__name(getRouteGroupScope, "getRouteGroupScope");
+function isInRouteGroupScope(directory, scope) {
+  if (scope === null) return true;
+  if (typeof directory !== "string") return false;
+  return directory === scope || directory.startsWith(`${scope}/`);
+}
+__name(isInRouteGroupScope, "isInRouteGroupScope");
+function getRouteDirectoryDepth(pattern) {
+  return pattern.split("/").filter(Boolean).length;
+}
+__name(getRouteDirectoryDepth, "getRouteDirectoryDepth");
+function routeBoundaryCoversDirectory(boundaryPattern, directory) {
+  const boundaryUrl = stripRouteGroups(boundaryPattern);
+  const routeUrl = stripRouteGroups(directory);
+  return (boundaryUrl === "/" || routeUrl === boundaryUrl || routeUrl.startsWith(`${boundaryUrl.replace(/\/$/, "")}/`)) && isInRouteGroupScope(directory, getRouteGroupScope(boundaryPattern));
+}
+__name(routeBoundaryCoversDirectory, "routeBoundaryCoversDirectory");
+
+// src/server/full-document.ts
+var CONTENTS_WRAPPER = /^<div\b[^>]*style="display\s*:\s*contents"[^>]*>/i;
+var HOISTED_HEAD_ELEMENT = /^(?:<(?:meta|link|base)\b[^>]*>|<title\b[^>]*>[\s\S]*?<\/title>|<script\b[^>]*\basync\b[^>]*><\/script>|<style\b[^>]*\bdata-precedence\b[^>]*>[\s\S]*?<\/style>)/i;
+function peelDocumentPrefix(markup) {
+  let inner = markup.replace(/^\s+/, "");
+  let hoisted = "";
+  let match;
+  while (match = CONTENTS_WRAPPER.exec(inner) ?? HOISTED_HEAD_ELEMENT.exec(inner)) {
+    if (!/^<div/i.test(match[0])) hoisted += match[0];
+    inner = inner.slice(match[0].length).replace(/^\s+/, "");
+  }
+  return { inner, hoisted };
+}
+__name(peelDocumentPrefix, "peelDocumentPrefix");
+function restoreHoistedHead(document, hoisted) {
+  if (!hoisted) return document;
+  if (/<head[\s>]/i.test(document)) {
+    return document.replace(/<head\b[^>]*>/i, (open) => open + hoisted);
+  }
+  return document.replace(/<html\b[^>]*>/i, (open) => `${open}<head>${hoisted}</head>`);
+}
+__name(restoreHoistedHead, "restoreHoistedHead");
+function extractFarmFullDocument(markup) {
+  const { inner, hoisted } = peelDocumentPrefix(markup);
+  if (!/^<!doctype/i.test(inner) && !/^<html[\s>]/i.test(inner)) return null;
+  const start = markup.search(/<!doctype|<html[\s>]/i);
+  const lower = markup.toLowerCase();
+  let closeIndex = lower.lastIndexOf("</html>");
+  if (lower.length !== markup.length) {
+    closeIndex = -1;
+    const closing = /<\/html>/gi;
+    let match;
+    while (match = closing.exec(markup)) closeIndex = match.index;
+  }
+  if (start < 0 || closeIndex < 0) return null;
+  const closeEnd = closeIndex + "</html>".length;
+  let document = markup.slice(start, closeEnd);
+  const streamedTail = markup.slice(closeEnd).replace(/^(?:\s*<\/div>)+/i, "").trim();
+  if (streamedTail) {
+    document = document.replace(/<\/body>/i, () => `${streamedTail}</body>`);
+  }
+  return restoreHoistedHead(document, hoisted);
+}
+__name(extractFarmFullDocument, "extractFarmFullDocument");
+function classifyFarmDocumentPrefix(markup) {
+  const { inner } = peelDocumentPrefix(markup);
+  if (/^<!doctype/i.test(inner) || /^<html[\s>]/i.test(inner)) return "document";
+  return inner === "" ? "pending" : "fragment";
+}
+__name(classifyFarmDocumentPrefix, "classifyFarmDocumentPrefix");
+function ensureFarmDocumentHead(markup) {
+  if (/<head[\s>]/i.test(markup)) return markup;
+  return markup.replace(/<html([^>]*)>/i, (_match, attributes) => {
+    return `<html${attributes}><head></head>`;
+  });
+}
+__name(ensureFarmDocumentHead, "ensureFarmDocumentHead");
+function ensureFarmDocumentRoot(markup) {
+  if (/<body\b[^>]*>\s*<div\b[^>]*\sid=["']root["']/i.test(markup)) return markup;
+  return markup.replace(
+    /<body\b([^>]*)>/i,
+    (_match, attributes) => `<body${attributes}><div id="root">`
+  ).replace(/<\/body>/i, () => "</div></body>");
+}
+__name(ensureFarmDocumentRoot, "ensureFarmDocumentRoot");
+function hasFarmDocumentIcon(markup) {
+  return /<link\b[^>]*\brel=["']?(?:shortcut )?icon\b/i.test(markup);
+}
+__name(hasFarmDocumentIcon, "hasFarmDocumentIcon");
+function removeFarmDocumentTitles(markup) {
+  return markup.replace(/<title\b[^>]*>[\s\S]*?<\/title>\s*/gi, "");
+}
+__name(removeFarmDocumentTitles, "removeFarmDocumentTitles");
+function ensureFarmDocumentMeta(markup, viewport = "") {
+  const head = /<head\b[^>]*>([\s\S]*?)<\/head>/i.exec(markup)?.[1] ?? "";
+  const hasNamedMeta = /* @__PURE__ */ __name((name) => new RegExp(`<meta\\b[^>]*\\bname=["']?${name}(?=["'\\s/>])`, "i").test(head), "hasNamedMeta");
+  const tags = [
+    /<meta\b[^>]*\bcharset\s*=/i.test(head) ? "" : '<meta charset="utf-8">',
+    ...(viewport.match(/<meta\b[^>]*>/gi) ?? []).filter((tag) => {
+      const name = /\bname="([\w-]+)"/.exec(tag)?.[1];
+      return !name || !hasNamedMeta(name);
+    })
+  ].filter(Boolean);
+  if (tags.length === 0) return markup;
+  return markup.replace(/<head\b[^>]*>/i, (open) => `${open}${tags.join("")}`);
+}
+__name(ensureFarmDocumentMeta, "ensureFarmDocumentMeta");
+function composeFarmFullDocument(documentHtml, assets) {
+  let html = ensureFarmDocumentMeta(ensureFarmDocumentHead(documentHtml), assets.viewport);
+  if (assets.htmlAttributes) {
+    html = html.replace(/<html\b([^>]*)>/i, (_match, attrs) => {
+      let nextAttributes = attrs;
+      for (const name of assets.replaceHtmlAttributes ?? []) {
+        const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        nextAttributes = nextAttributes.replace(
+          new RegExp("\\s+" + escapedName + `=(?:"[^"]*"|'[^']*'|[^\\s>]+)`, "gi"),
+          ""
+        );
+      }
+      return `<html${nextAttributes}${assets.htmlAttributes}>`;
+    });
+  }
+  html = ensureFarmDocumentRoot(html);
+  const headAssets = [
+    assets.fallbackIcon && !hasFarmDocumentIcon(html) ? '<link rel="icon" href="data:,">' : "",
+    assets.headAssets
+  ].filter(Boolean).join("\n  ");
+  if (headAssets) {
+    html = html.replace(/<\/head>/i, () => `  ${headAssets}
+</head>`);
+  }
+  if (assets.bodyFooter) {
+    html = html.replace(/<\/body>/i, () => `  ${assets.bodyFooter}
+</body>`);
+  }
+  return /^\s*<!doctype/i.test(html) ? html : `<!DOCTYPE html>
+${html}`;
+}
+__name(composeFarmFullDocument, "composeFarmFullDocument");
+
+// src/i18n/alternates.ts
+function renderFarmLocaleAlternateLinks(pathname, config, options = {}) {
+  if (config.routing === "none") return "";
+  const base = resolveAlternateBase(options);
+  const link = /* @__PURE__ */ __name((hreflang, locale) => `<link rel="alternate" hreflang="${escapeHtmlAttribute(hreflang)}" href="${escapeHtmlAttribute(
+    resolveAlternateHref(localizeFarmPathname(pathname, locale, config), base)
+  )}">`, "link");
+  const links = config.locales.map((locale) => link(locale, locale));
+  links.push(link("x-default", config.defaultLocale));
+  return links.join("");
+}
+__name(renderFarmLocaleAlternateLinks, "renderFarmLocaleAlternateLinks");
+function resolveAlternateBase(options) {
+  for (const candidate of [options.metadataBase, options.origin]) {
+    if (typeof candidate !== "string" && !(candidate instanceof URL)) continue;
+    try {
+      const url = new URL(candidate);
+      if (url.protocol === "http:" || url.protocol === "https:") return url;
+    } catch {
+    }
+  }
+  return void 0;
+}
+__name(resolveAlternateBase, "resolveAlternateBase");
+function resolveAlternateHref(pathname, base) {
+  if (!base) return pathname;
+  return new URL(pathname.replace(/^[/\\]+/, "/"), base).href;
+}
+__name(resolveAlternateHref, "resolveAlternateHref");
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeHtmlAttribute, "escapeHtmlAttribute");
+
+// src/navigation/late-navigation-recovery.ts
+var PAGE_CONTAINER_ID = "__farm_page__";
+var TEMPLATE_ID = "__farm_late_not_found__";
+function serializeForInlineScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(serializeForInlineScript, "serializeForInlineScript");
+function isLateRedirectTarget(url) {
+  try {
+    const protocol = new URL(url, "https://farm.invalid").protocol;
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+__name(isLateRedirectTarget, "isLateRedirectTarget");
+function createLateRedirectRecovery(url) {
+  if (!isLateRedirectTarget(url)) return "";
+  return `<script>window.location.replace(${serializeForInlineScript(url)})</script>`;
+}
+__name(createLateRedirectRecovery, "createLateRedirectRecovery");
+function createLateNotFoundRecovery(content) {
+  return `<template id="${TEMPLATE_ID}">${content}</template><script>(function(){var t=document.getElementById("${TEMPLATE_ID}");var p=document.getElementById("${PAGE_CONTAINER_ID}");if(t&&p){p.replaceChildren(t.content.cloneNode(true));}if(t)t.remove();document.documentElement.dataset.farmLateNotFound="true";var m=document.createElement("meta");m.name="robots";m.content="noindex";document.head.appendChild(m);})();</script>`;
+}
+__name(createLateNotFoundRecovery, "createLateNotFoundRecovery");
+
+// src/metadata-route.ts
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+__name(isResponse, "isResponse");
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+__name(isRecord, "isRecord");
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+__name(resolveCacheControl, "resolveCacheControl");
+function escapeXml(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+__name(escapeXml, "escapeXml");
+function serializeSitemap(value) {
+  if (!Array.isArray(value)) {
+    throw new TypeError("sitemap.ts must return an array or a Response");
+  }
+  const entries = value.map((candidate, index) => {
+    if (!isRecord(candidate) || typeof candidate.url !== "string" || !candidate.url) {
+      throw new TypeError(`sitemap.ts entry ${index} must include a non-empty url`);
+    }
+    return candidate;
+  });
+  const hasLanguageAlternates = entries.some(
+    (entry) => entry.alternates?.languages && Object.keys(entry.alternates.languages).length > 0
+  );
+  const namespace = hasLanguageAlternates ? ' xmlns:xhtml="http://www.w3.org/1999/xhtml"' : "";
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${namespace}>`
+  ];
+  for (const entry of entries) {
+    lines.push("  <url>", `    <loc>${escapeXml(entry.url)}</loc>`);
+    if (entry.lastModified !== void 0) {
+      const lastModified = entry.lastModified instanceof Date ? entry.lastModified.toISOString() : entry.lastModified;
+      lines.push(`    <lastmod>${escapeXml(lastModified)}</lastmod>`);
+    }
+    if (entry.changeFrequency) {
+      lines.push(`    <changefreq>${escapeXml(entry.changeFrequency)}</changefreq>`);
+    }
+    if (entry.priority !== void 0) {
+      lines.push(`    <priority>${escapeXml(entry.priority)}</priority>`);
+    }
+    for (const [language, href] of Object.entries(entry.alternates?.languages || {})) {
+      lines.push(
+        `    <xhtml:link rel="alternate" hreflang="${escapeXml(language)}" href="${escapeXml(href)}" />`
+      );
+    }
+    lines.push("  </url>");
+  }
+  lines.push("</urlset>");
+  return `${lines.join("\n")}
+`;
+}
+__name(serializeSitemap, "serializeSitemap");
+function toArray(value) {
+  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
+__name(toArray, "toArray");
+function serializeRobots(value) {
+  if (!isRecord(value)) {
+    throw new TypeError("robots.ts must return a robots object or a Response");
+  }
+  const robots = value;
+  const rules = toArray(robots.rules);
+  if (rules.length === 0) {
+    throw new TypeError("robots.ts must return at least one rule");
+  }
+  const sections = rules.map((rule, index) => {
+    if (!isRecord(rule)) {
+      throw new TypeError(`robots.ts rule ${index} must be an object`);
+    }
+    const userAgents = toArray(rule.userAgent).filter(
+      (userAgent) => typeof userAgent === "string" && Boolean(userAgent)
+    );
+    if (userAgents.length === 0) {
+      throw new TypeError(`robots.ts rule ${index} must include a userAgent`);
+    }
+    const lines = userAgents.map((userAgent) => `User-agent: ${userAgent}`);
+    for (const allow of toArray(rule.allow)) lines.push(`Allow: ${allow}`);
+    for (const disallow of toArray(rule.disallow)) lines.push(`Disallow: ${disallow}`);
+    if (rule.crawlDelay !== void 0) lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+    return lines.join("\n");
+  });
+  const globalLines = [
+    ...toArray(robots.sitemap).map((sitemap) => `Sitemap: ${sitemap}`),
+    ...robots.host ? [`Host: ${robots.host}`] : []
+  ];
+  return `${[...sections, ...globalLines.length ? [globalLines.join("\n")] : []].join("\n\n")}
+`;
+}
+__name(serializeRobots, "serializeRobots");
+function serializeManifest(value) {
+  if (!isRecord(value)) {
+    throw new TypeError("manifest.ts must return a manifest object or a Response");
+  }
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+__name(serializeManifest, "serializeManifest");
+function createFarmMetadataRouteResponse(kind, value, routeModule = {}, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if ((kind === "llms" || kind === "llms-full") && options.request) {
+    emitFarmAgentRead(options.request, kind, isResponse(value) ? value.status : 200);
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? omitFarmResponseBody(value) : value;
+  }
+  const body = kind === "sitemap" ? serializeSitemap(value) : kind === "robots" ? serializeRobots(value) : kind === "llms" || kind === "llms-full" ? serializeFarmLlmsTxt(value) : serializeManifest(value);
+  const contentType = kind === "sitemap" ? "application/xml; charset=utf-8" : kind === "robots" || kind === "llms" || kind === "llms-full" ? "text/plain; charset=utf-8" : "application/manifest+json; charset=utf-8";
+  return new Response(method === "HEAD" ? null : body, {
+    headers: {
+      "Content-Type": contentType,
+      "Cache-Control": resolveCacheControl(routeModule.revalidate),
+      "X-Content-Type-Options": "nosniff"
+    }
+  });
+}
+__name(createFarmMetadataRouteResponse, "createFarmMetadataRouteResponse");
+
+// src/ai-catalog.ts
+var FARM_AI_CATALOG_PATH = "/.well-known/ai-catalog.json";
+var FARM_ARD_PATH = "/.well-known/ard.json";
+var FARM_MCP_SERVER_CARD_SUFFIX = "/server-card";
+var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
+var SERVER_CARD_TYPE = "application/mcp-server-card+json";
+var AI_CATALOG_TYPE = "application/ai-catalog+json";
+var CARD_DESCRIPTION_MAX = 100;
+var REVERSE_DNS_NAME = /^[a-zA-Z0-9.-]+\/[a-zA-Z0-9._-]+$/;
+function listFarmMCPServerSources(input) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const { server, details } of _listFarmMCPCatalogs()) {
+    const endpoint = resolveFarmAPIServerRoutePath(server.path, input.apiServerBasePath);
+    if (sources.has(endpoint)) continue;
+    sources.set(endpoint, {
+      ...server,
+      protocolVersions: details?.protocolVersions,
+      endpoint,
+      local: true
+    });
+  }
+  for (const server of _listFarmRegisteredMCPServers()) {
+    const endpoint = server.path ? applyFarmBasePath(server.path, input.basePath) : server.url;
+    if (sources.has(endpoint)) continue;
+    sources.set(endpoint, { ...server, endpoint, local: Boolean(server.path) });
+  }
+  if (sources.size === 0 && input.defaultMCP) {
+    const server = input.defaultMCP();
+    if (server) {
+      const endpoint = applyFarmBasePath(server.path, input.basePath);
+      sources.set(endpoint, { ...server, endpoint, local: true });
+    }
+  }
+  return [...sources.values()];
+}
+__name(listFarmMCPServerSources, "listFarmMCPServerSources");
+function serverCardLocation(endpoint) {
+  return `${endpoint.replace(/\/$/, "")}${FARM_MCP_SERVER_CARD_SUFFIX}`;
+}
+__name(serverCardLocation, "serverCardLocation");
+function listFarmMCPServerCards(origin, input = {}) {
+  const host = new URL(origin).hostname;
+  return listFarmMCPServerSources(input).map((server) => {
+    const endpointUrl = server.local ? `${origin}${server.endpoint}` : server.endpoint;
+    const cardPath = server.local ? serverCardLocation(server.endpoint) : void 0;
+    const slug = cardSlug(server.name);
+    const description = truncate(server.description?.trim() || `MCP server for ${host}`);
+    const card = {
+      $schema: SERVER_CARD_SCHEMA,
+      // The card's name is reverse-DNS; a plain server name is namespaced by the host.
+      name: REVERSE_DNS_NAME.test(server.name) ? server.name : `${cardNamespace(host)}/${slug}`,
+      version: server.version,
+      description,
+      ...server.title ? { title: server.title } : {},
+      websiteUrl: `${origin}${applyFarmBasePath("/", input.basePath).replace(/(.)\/$/, "$1")}`,
+      remotes: [
+        {
+          type: "streamable-http",
+          url: endpointUrl,
+          ...server.protocolVersions?.length ? { supportedProtocolVersions: [...server.protocolVersions] } : {}
+        }
+      ]
+    };
+    return {
+      ...cardPath ? { cardPath } : {},
+      card,
+      entry: {
+        identifier: `urn:air:${host}:mcp:${slug}`,
+        type: SERVER_CARD_TYPE,
+        url: cardPath ? `${origin}${cardPath}` : serverCardLocation(endpointUrl),
+        displayName: server.title ?? server.name,
+        description,
+        version: server.version
+      }
+    };
+  });
+}
+__name(listFarmMCPServerCards, "listFarmMCPServerCards");
+function listFarmMCPLlmsTxtLinks(origin, input = {}) {
+  const servers = listFarmMCPServerCards(origin, input);
+  if (!servers.length) return [];
+  return [
+    ...servers.map(({ card, entry }) => ({
+      title: entry.displayName,
+      url: card.remotes[0].url,
+      description: `${card.description} (Streamable HTTP MCP endpoint; server card at ${entry.url})`
+    })),
+    {
+      title: "AI catalog",
+      url: `${origin}${applyFarmBasePath(FARM_AI_CATALOG_PATH, input.basePath)}`,
+      description: "MCP server cards for this site"
+    }
+  ];
+}
+__name(listFarmMCPLlmsTxtLinks, "listFarmMCPLlmsTxtLinks");
+function createFarmAiCatalogResponse(request, input = {}, requestUrl) {
+  let url;
+  try {
+    url = requestUrl ?? new URL(request.url);
+  } catch {
+    return null;
+  }
+  const { pathname } = url;
+  if (!pathname.endsWith(FARM_MCP_SERVER_CARD_SUFFIX) && !pathname.includes("/.well-known/")) {
+    return null;
+  }
+  const ard = pathname === applyFarmBasePath(FARM_ARD_PATH, input.basePath);
+  const catalogPath = ard || pathname === applyFarmBasePath(FARM_AI_CATALOG_PATH, input.basePath);
+  if (!catalogPath && !pathname.endsWith(FARM_MCP_SERVER_CARD_SUFFIX)) return null;
+  const servers = listFarmMCPServerCards(url.origin, input);
+  const card = catalogPath ? void 0 : servers.find((server) => server.cardPath === pathname);
+  if (!servers.length || !catalogPath && !card) return null;
+  const method = request.method.toUpperCase();
+  if (method === "OPTIONS") return new Response(null, { status: 204, headers: corsHeaders() });
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response("Method Not Allowed", {
+      status: 405,
+      headers: { ...corsHeaders(), Allow: "GET, HEAD, OPTIONS", "Content-Type": "text/plain" }
+    });
+  }
+  const body = JSON.stringify(
+    card ? card.card : { specVersion: "1.0", entries: servers.map(({ entry }) => entry) }
+  );
+  const etag = createFarmWeakETag(body);
+  const headers = {
+    ...corsHeaders(),
+    "Content-Type": card ? `${SERVER_CARD_TYPE}; charset=utf-8` : ard ? "application/json; charset=utf-8" : `${AI_CATALOG_TYPE}; charset=utf-8`,
+    // The body names the request's origin, so caches revalidate rather than reuse it.
+    "Cache-Control": "public, max-age=0, must-revalidate",
+    ETag: etag,
+    "X-Content-Type-Options": "nosniff"
+  };
+  if (matchesFarmIfNoneMatch(request.headers.get("if-none-match"), etag)) {
+    return new Response(null, { status: 304, headers });
+  }
+  emitFarmAgentRead(request, card ? "mcp-server-card" : "ai-catalog", 200);
+  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
+}
+__name(createFarmAiCatalogResponse, "createFarmAiCatalogResponse");
+function corsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, If-None-Match",
+    "Access-Control-Expose-Headers": "ETag"
+  };
+}
+__name(corsHeaders, "corsHeaders");
+function cardNamespace(host) {
+  if (host.includes(":") || /^\d+(?:\.\d+){3}$/.test(host)) return "local";
+  return host.split(".").reverse().join(".");
+}
+__name(cardNamespace, "cardNamespace");
+function cardSlug(name) {
+  const last = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+  return last.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "mcp";
+}
+__name(cardSlug, "cardSlug");
+function truncate(text) {
+  return text.length <= CARD_DESCRIPTION_MAX ? text : `${text.slice(0, CARD_DESCRIPTION_MAX - 1).trimEnd()}\u2026`;
+}
+__name(truncate, "truncate");
+
+// src/components/error-page.ts
+var ERROR_STATUS_TEXT = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Content Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  418: "I'm a Teapot",
+  422: "Unprocessable Content",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+var ERROR_TITLES = {
+  400: "This request could not be completed",
+  401: "Authentication is required",
+  403: "You do not have access to this page",
+  404: "This page could not be found",
+  405: "This request method is not supported",
+  408: "The request took too long",
+  409: "The request conflicts with the current state",
+  410: "This resource is no longer available",
+  413: "The request is too large",
+  422: "The request could not be processed",
+  429: "Too many requests were sent",
+  500: "Something went wrong",
+  501: "This operation is not implemented",
+  502: "An upstream service returned an invalid response",
+  503: "The service is temporarily unavailable",
+  504: "An upstream service took too long to respond"
+};
+var ERROR_PUBLIC_MESSAGES = {
+  400: "Check the request details, then try again.",
+  401: "Sign in and try this request again.",
+  403: "Use an account with the required permissions or return home.",
+  404: "Check the address or return to the home page.",
+  405: "Use a supported request method and try again.",
+  408: "Try the request again in a moment.",
+  409: "Refresh the page, review the latest state, and try again.",
+  410: "Return home to continue browsing.",
+  413: "Reduce the request size and try again.",
+  422: "Review the request data and try again.",
+  429: "Wait a moment before trying again.",
+  500: "The application ran into an unexpected problem. Try again in a moment.",
+  501: "This operation is not available yet.",
+  502: "Try again after the upstream service recovers.",
+  503: "Try again in a moment.",
+  504: "Try again after the upstream service recovers."
+};
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+__name(escapeHtml, "escapeHtml");
+function serializeJsonForHtml(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(serializeJsonForHtml, "serializeJsonForHtml");
+function normalizeErrorStatus(status) {
+  const value = typeof status === "string" && status.trim() ? Number(status) : status;
+  return typeof value === "number" && Number.isInteger(value) && value >= 400 && value <= 599 ? value : void 0;
+}
+__name(normalizeErrorStatus, "normalizeErrorStatus");
+function resolveDefaultErrorStatus(error) {
+  if (error && typeof error === "object") {
+    const candidate = error;
+    return normalizeErrorStatus(candidate.status) ?? normalizeErrorStatus(candidate.statusCode) ?? 500;
+  }
+  return 500;
+}
+__name(resolveDefaultErrorStatus, "resolveDefaultErrorStatus");
+function getDefaultErrorStatusText(statusCode) {
+  return ERROR_STATUS_TEXT[statusCode] || (statusCode >= 500 ? "Server Error" : "Request Error");
+}
+__name(getDefaultErrorStatusText, "getDefaultErrorStatusText");
+function getDefaultErrorTitle(statusCode) {
+  return ERROR_TITLES[statusCode] || (statusCode >= 500 ? "The server could not complete the request" : "The request could not be completed");
+}
+__name(getDefaultErrorTitle, "getDefaultErrorTitle");
+function getDefaultErrorPublicMessage(statusCode) {
+  return ERROR_PUBLIC_MESSAGES[statusCode] || "Try again or return to the home page.";
+}
+__name(getDefaultErrorPublicMessage, "getDefaultErrorPublicMessage");
+function createSourceFrameMarkup(sourceFrame) {
+  if (!sourceFrame) {
+    return `<p class="farm-default-error__details-empty">Source location is unavailable. Copy the debug report to inspect the filtered stack trace.</p>`;
+  }
+  const lines = sourceFrame.lines.map(
+    (line) => `<span class="farm-default-error__source-line${line.highlight ? " farm-default-error__source-line--active" : ""}"><span class="farm-default-error__source-gutter">${line.highlight ? "&gt;" : "&nbsp;"} ${line.number}</span><span class="farm-default-error__source-text">${escapeHtml(line.content || " ")}</span></span>`
+  ).join("\n");
+  return `<div class="farm-default-error__source"><p class="farm-default-error__source-path">${escapeHtml(sourceFrame.file)}:${sourceFrame.line}:${sourceFrame.column}</p><pre class="farm-default-error__source-code" tabindex="0"><code>${lines}</code></pre></div>`;
+}
+__name(createSourceFrameMarkup, "createSourceFrameMarkup");
+function createDebugReport(options) {
+  const statusText = options.statusText || getDefaultErrorStatusText(options.statusCode);
+  const sourceFrame = options.sourceFrame;
+  const source = sourceFrame ? [
+    `\`${sourceFrame.file}:${sourceFrame.line}:${sourceFrame.column}\``,
+    "",
+    "```text",
+    ...sourceFrame.lines.map(
+      (line) => `${line.highlight ? ">" : " "} ${String(line.number).padStart(4, " ")} | ${line.content}`
+    ),
+    "```"
+  ].join("\n") : "Source frame unavailable.";
+  return [
+    "# Farm.js debug report",
+    "",
+    "## Error",
+    `- Status: ${options.statusCode} ${statusText}`,
+    `- Name: ${options.errorName || "Error"}`,
+    `- Message: ${options.message || getDefaultErrorPublicMessage(options.statusCode)}`,
+    `- Request: ${(options.method || "GET").toUpperCase()} ${options.requestPath || "/"}`,
+    "",
+    "## Runtime",
+    `- Farm.js: ${options.farmVersion || "unknown"}`,
+    `- Node.js: ${options.nodeVersion || "unknown"}`,
+    `- Mode: ${options.mode || "development"}`,
+    "",
+    "## Source",
+    source,
+    "",
+    "## Filtered stack",
+    "```text",
+    options.stack || "Stack trace unavailable.",
+    "```"
+  ].join("\n");
+}
+__name(createDebugReport, "createDebugReport");
+var ERROR_PAGE_SCRIPT = `<script>(function(){var root=document.querySelector("[data-farm-default-error]");if(!root)return;var retry=root.querySelector("[data-farm-error-retry]");var back=root.querySelector("[data-farm-error-back]");if(retry)retry.addEventListener("click",function(){window.location.reload()});if(back)back.addEventListener("click",function(){if(window.history.length>1){window.history.back()}else{window.location.assign("/")}})})();</script>`;
+var ERROR_COPY_SCRIPT = `<script>(function(){var root=document.querySelector("[data-farm-default-error]");var copy=root&&root.querySelector("[data-farm-error-copy]");var report=document.getElementById("farm-default-error-report");if(!copy||!report)return;copy.addEventListener("click",async function(){var value="";try{value=JSON.parse(report.textContent||'""')}catch(_error){value=report.textContent||""}try{if(navigator.clipboard&&window.isSecureContext){await navigator.clipboard.writeText(value)}else{var area=document.createElement("textarea");area.value=value;area.setAttribute("readonly","");area.style.position="fixed";area.style.opacity="0";document.body.appendChild(area);area.select();document.execCommand("copy");area.remove()}var label=copy.querySelector("[data-farm-error-copy-label]");var status=copy.querySelector("[data-farm-error-copy-status]");if(label)label.textContent="COPIED";if(status)status.textContent="Debug report copied";window.setTimeout(function(){if(label)label.textContent="COPY DEBUG REPORT";if(status)status.textContent=""},1800)}catch(_error){var status=copy.querySelector("[data-farm-error-copy-status]");if(status)status.textContent="Unable to copy the debug report"}})})();</script>`;
+var ERROR_DOCS_ICON = `<svg class="farm-default-error__docs-icon" viewBox="0 0 16 16" fill="none" aria-hidden="true" focusable="false"><path d="M2.75 2.75h3.5A1.75 1.75 0 0 1 8 4.5v8.75a1.75 1.75 0 0 0-1.75-1.75h-3.5v-8.75Z"/><path d="M13.25 2.75h-3.5A1.75 1.75 0 0 0 8 4.5v8.75a1.75 1.75 0 0 1 1.75-1.75h3.5v-8.75Z"/></svg>`;
+function createDefaultErrorMarkup(options = {}) {
+  const statusCode = normalizeErrorStatus(options.statusCode) ?? 500;
+  const statusText = options.statusText || getDefaultErrorStatusText(statusCode);
+  const development = options.development === true;
+  const title = getDefaultErrorTitle(statusCode);
+  const message = development && options.message ? options.message : getDefaultErrorPublicMessage(statusCode);
+  const requestPath = options.requestPath || "/";
+  const method = (options.method || "GET").toUpperCase();
+  const isServerError = statusCode >= 500;
+  const details = development ? `<section class="farm-default-error__details" aria-labelledby="farm-default-error-details-title"><div class="farm-default-error__details-header"><h2 id="farm-default-error-details-title" class="farm-default-error__details-title">Technical details</h2></div>${createSourceFrameMarkup(options.sourceFrame)}<p class="farm-default-error__meta">Farm.js v${escapeHtml(options.farmVersion || "unknown")} \xB7 ${escapeHtml(options.mode || "development")} \xB7 Node.js ${escapeHtml(options.nodeVersion || "unknown")}</p></section>` : "";
+  const report = development ? `<script id="farm-default-error-report" type="application/json">${serializeJsonForHtml(createDebugReport({ ...options, statusCode, statusText, requestPath, method }))}</script>${ERROR_COPY_SCRIPT}` : "";
+  const primaryAction = isServerError ? `<button class="farm-default-error__action farm-default-error__action--primary" type="button" data-farm-error-retry>TRY AGAIN</button>` : `<button class="farm-default-error__action farm-default-error__action--primary" type="button" data-farm-error-back>GO BACK</button>`;
+  const debugAction = development ? `<span class="farm-default-error__footer-divider" aria-hidden="true">/</span><button class="farm-default-error__footer-action" type="button" data-farm-error-copy><span data-farm-error-copy-label>COPY DEBUG REPORT</span><span class="farm-default-error__sr-only" aria-live="polite" data-farm-error-copy-status></span></button>` : "";
+  return `<style>${DEFAULT_ERROR_STYLES}</style><main class="farm-default-error${development ? " farm-default-error--development" : ""}" data-farm-default-error role="alert" aria-labelledby="farm-default-error-title" aria-describedby="farm-default-error-description"><div class="farm-default-error__frame"><div class="farm-default-error__brand" aria-hidden="true"><span>FARM.JS</span><span class="farm-default-error__brand-divider">/</span><span>ERROR</span></div><div class="farm-default-error__content"><p class="farm-default-error__status"><span class="farm-default-error__status-mark" aria-hidden="true"></span><span>${statusCode}</span><span class="farm-default-error__status-divider" aria-hidden="true">/</span><span>${escapeHtml(statusText)}</span></p><header class="farm-default-error__summary"><h1 id="farm-default-error-title" class="farm-default-error__title">${escapeHtml(title)}</h1><p id="farm-default-error-description" class="farm-default-error__message">${escapeHtml(message)}</p></header><div class="farm-default-error__actions">${primaryAction}<a class="farm-default-error__action" href="/">RETURN HOME</a></div><section class="farm-default-error__panel" aria-label="Error information"><div class="farm-default-error__row"><span class="farm-default-error__label">Request</span><span class="farm-default-error__value">${escapeHtml(method)} ${escapeHtml(requestPath)}</span></div><div class="farm-default-error__row"><span class="farm-default-error__label">Status</span><span class="farm-default-error__value">${statusCode} ${escapeHtml(statusText)}</span></div>${details}</section></div><footer class="farm-default-error__footer"><a class="farm-default-error__footer-action" href="https://farmjs.dev/docs" target="_blank" rel="noopener noreferrer">${ERROR_DOCS_ICON}<span>VIEW DOCUMENTATION</span></a>${debugAction}</footer></div>${report}${ERROR_PAGE_SCRIPT}</main>`;
+}
+__name(createDefaultErrorMarkup, "createDefaultErrorMarkup");
+
+// src/theme/server-runtime.ts
+var THEME_SCRIPT_ID = "farm-theme-script";
+var THEME_STYLE_ID = "farm-theme-style";
+function createFarmThemeDocumentParts(input, basePath = "/", serverTheme) {
+  const config = resolveFarmThemeConfig(input, basePath);
+  if (!config.enabled) return { attributes: "", head: "" };
+  const hydrationTheme = serverTheme ?? config.default;
+  const initialTheme = hydrationTheme === "system" ? "light" : hydrationTheme;
+  const script = createFarmThemeBootstrapScript(config, hydrationTheme);
+  return {
+    attributes: ` data-theme="${initialTheme}"`,
+    head: `<style id="${THEME_STYLE_ID}">:root[data-theme="light"]{color-scheme:light}:root[data-theme="dark"]{color-scheme:dark}</style><script id="${THEME_SCRIPT_ID}">${script}</script>`
+  };
+}
+__name(createFarmThemeDocumentParts, "createFarmThemeDocumentParts");
+function createFarmThemeBootstrapScript(config, serverTheme = config.default) {
+  return `(function(config,serverTheme){
+var isTheme=function(value){return value==="light"||value==="dark"||value==="system";};
+var decode=function(value){try{return decodeURIComponent(value);}catch(_error){return value;}};
+var readCookie=function(){var entries=document.cookie.split(";");for(var index=0;index<entries.length;index++){var entry=entries[index];var separator=entry.indexOf("=");if(separator<0)continue;if(decode(entry.slice(0,separator).trim())===config.storageKey)return decode(entry.slice(separator+1).trim());}};
+var media=window.matchMedia("(prefers-color-scheme: dark)");
+var resolveTheme=function(theme){return theme==="system"?(media.matches?"dark":"light"):theme;};
+var storedTheme=readCookie();
+var preference=isTheme(storedTheme)?storedTheme:config.default;
+var serverSnapshot={theme:serverTheme,resolvedTheme:serverTheme==="system"?undefined:serverTheme,mounted:false};
+var apply=function(){var resolvedTheme=resolveTheme(preference);document.documentElement.dataset.theme=resolvedTheme;var snapshot={theme:preference,resolvedTheme:resolvedTheme,mounted:true};if(window.__FARM_THEME__)window.__FARM_THEME__.snapshot=snapshot;return snapshot;};
+var emit=function(){var snapshot=apply();window.dispatchEvent(new CustomEvent("farm:themechange",{detail:snapshot}));};
+var persist=function(theme){var secure=window.location.protocol==="https:"?"; Secure":"";document.cookie=encodeURIComponent(config.storageKey)+"="+encodeURIComponent(theme)+"; Path="+config.cookiePath+"; Max-Age=31536000; SameSite=Lax"+secure;try{localStorage.setItem(config.storageKey,theme);}catch(_error){}};
+var setTheme=function(theme){if(!isTheme(theme))throw new TypeError("Unknown FARMJS theme: "+String(theme));preference=theme;persist(theme);emit();};
+var initialSnapshot={theme:preference,resolvedTheme:resolveTheme(preference),mounted:true};
+window.__FARM_THEME__={config:config,serverSnapshot:serverSnapshot,snapshot:initialSnapshot,setTheme:setTheme};
+document.documentElement.dataset.theme=initialSnapshot.resolvedTheme;
+var handleSystemChange=function(){if(preference==="system")emit();};
+if(typeof media.addEventListener==="function")media.addEventListener("change",handleSystemChange);else if(typeof media.addListener==="function")media.addListener(handleSystemChange);
+window.addEventListener("storage",function(event){if(event.key!==config.storageKey||!isTheme(event.newValue))return;preference=event.newValue;persist(preference);emit();});
+})(${serializeInlineValue(config)},${serializeInlineValue(serverTheme)});`;
+}
+__name(createFarmThemeBootstrapScript, "createFarmThemeBootstrapScript");
+function applyFarmThemeDocument(html, input, basePath = "/", serverTheme) {
+  const parts = createFarmThemeDocumentParts(input, basePath, serverTheme);
+  if (!parts.head) return html;
+  let output = html.replace(/<html([^>]*)>/i, (_match, attributes) => {
+    const nextAttributes = attributes.replace(/\sdata-theme=(?:"[^"]*"|'[^']*'|[^\s>]+)/i, "");
+    return `<html${nextAttributes}${parts.attributes}>`;
+  });
+  if (!output.includes(`id="${THEME_SCRIPT_ID}"`)) {
+    output = output.replace(/<head([^>]*)>/i, `<head$1>${parts.head}`);
+  }
+  return output;
+}
+__name(applyFarmThemeDocument, "applyFarmThemeDocument");
+function serializeInlineValue(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(serializeInlineValue, "serializeInlineValue");
+
+// src/api-catalog.ts
+var FARM_API_CATALOG_PATH = "/.well-known/api-catalog";
+var API_CATALOG_CONTENT_TYPE = 'application/linkset+json; profile="https://www.rfc-editor.org/info/rfc9727"';
+function resolveFarmApiCatalogInput(config) {
+  const mcp = config.mcp && config.mcp.enabled !== false ? config.mcp : void 0;
+  return {
+    basePath: config.basePath,
+    apiBaseURL: config.openapi?.servers?.[0]?.url ?? config.api.baseURL,
+    openapi: config.openapi?.enabled ? { specRoute: config.openapi.specRoute, route: config.openapi.route } : void 0,
+    mcpPath: mcp ? resolveFarmAPIServerRoutePath(
+      mcp.path ?? "/api/mcp",
+      resolveFarmAPIServerBasePath(config.api)
+    ) : void 0
+  };
+}
+__name(resolveFarmApiCatalogInput, "resolveFarmApiCatalogInput");
+function createFarmApiCatalog(input) {
+  const appPath = /* @__PURE__ */ __name((path) => applyFarmBasePath(path, input.basePath), "appPath");
+  const items = [];
+  const contexts = [];
+  const specRoute = input.openapi?.specRoute;
+  const reference = input.openapi?.route;
+  if (specRoute || reference) {
+    const api = { anchor: input.apiBaseURL };
+    if (specRoute) {
+      api["service-desc"] = [
+        { href: appPath(specRoute), type: "application/vnd.oai.openapi+json" }
+      ];
+    }
+    if (reference) api["service-doc"] = [{ href: appPath(reference), type: "text/html" }];
+    items.push({ href: input.apiBaseURL });
+    contexts.push(api);
+  }
+  if (input.mcpPath) items.push({ href: input.mcpPath });
+  return {
+    linkset: [{ anchor: appPath(FARM_API_CATALOG_PATH), item: items }, ...contexts]
+  };
+}
+__name(createFarmApiCatalog, "createFarmApiCatalog");
+function createFarmApiCatalogResponse(method, input, request) {
+  const upperMethod = method.toUpperCase();
+  if (upperMethod !== "GET" && upperMethod !== "HEAD") {
+    return new Response("Method Not Allowed", {
+      status: 405,
+      headers: { Allow: "GET, HEAD", "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (request) emitFarmAgentRead(request, "api-catalog", 200);
+  const catalog = createFarmApiCatalog(input);
+  return new Response(upperMethod === "HEAD" ? null : JSON.stringify(catalog), {
+    status: 200,
+    headers: {
+      "Content-Type": API_CATALOG_CONTENT_TYPE,
+      "Cache-Control": "public, max-age=0, must-revalidate",
+      Link: `<${catalog.linkset[0].anchor}>; rel="api-catalog"`,
+      "X-Content-Type-Options": "nosniff"
+    }
+  });
+}
+__name(createFarmApiCatalogResponse, "createFarmApiCatalogResponse");
+
+// src/app-manifest.ts
+var FARM_APP_MANIFEST_PATH = "/.well-known/farmjs.json";
+var FARM_APP_MANIFEST_LEGACY_PATH = "/.well-known/farmjs";
+function isFarmAppManifestPath(pathname) {
+  return pathname === FARM_APP_MANIFEST_PATH || pathname === FARM_APP_MANIFEST_LEGACY_PATH;
+}
+__name(isFarmAppManifestPath, "isFarmAppManifestPath");
+var FARM_INFRA_SIGNATURE_HEADER = "farmjs-infra-signature";
+var SIGNED_PURPOSE = "farmjs-manifest-v1";
+var SIGNATURE_WINDOW_SECONDS = 300;
+function resolveFarmAppManifestInput(config, extra) {
+  const llms = config.agent?.llmsTxt;
+  const plugins = (config.plugins ?? []).map(({ name }) => name);
+  const webmcp = plugins.includes("farm:webmcp");
+  return {
+    renderer: config.renderer?.name ?? "react",
+    basePath: config.basePath || "/",
+    build: extra.build,
+    packages: extra.packages,
+    webmcp: { enabled: webmcp, tools: webmcp ? extra.webmcpTools ?? [] : [] },
+    integrations: Object.entries(config.integrations ?? {}).flatMap(([key, integration]) => {
+      const category = integration?.category ?? integration?.slot;
+      return integration && category && integration.type ? [{ key, category, type: integration.type }] : [];
+    }),
+    agent: {
+      apiCatalog: config.agent?.apiCatalog ? "/.well-known/api-catalog" : null,
+      llmsTxt: llms === true || typeof llms === "object" && llms !== null && llms.enabled !== false,
+      openapi: config.openapi?.enabled && config.openapi.specRoute ? config.openapi.specRoute : null
+    },
+    plugins,
+    analytics: config.analytics !== false
+  };
+}
+__name(resolveFarmAppManifestInput, "resolveFarmAppManifestInput");
+var SOURCES = {
+  endpoint: "endpoint",
+  standalone: "defineTool",
+  serverFunction: "serverFunction"
+};
+function createFarmAppManifest(input, { full = false } = {}) {
+  const manifest = {
+    schemaVersion: 1,
+    app: {
+      farm: FARM_VERSION,
+      renderer: input.renderer,
+      basePath: input.basePath,
+      build: input.build
+    },
+    packages: input.packages,
+    mcp: {
+      servers: _listFarmMCPCatalogs().map(({ server, tools, details }) => {
+        const listed = full || details?.public === true;
+        return {
+          name: server.name,
+          version: server.version,
+          path: server.path,
+          authorization: details?.public === true ? "none" : "required",
+          resources: listed ? [...details?.resources ?? []] : [],
+          prompts: listed ? [...details?.prompts ?? []] : [],
+          tools: (listed ? tools : []).map((tool) => {
+            const schemas = details?.schemas?.[tool.name];
+            const hints = Object.fromEntries(
+              ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"].filter((hint) => typeof tool[hint] === "boolean").map((hint) => [hint, tool[hint]])
+            );
+            return {
+              name: tool.name,
+              ...tool.title ? { title: tool.title } : {},
+              ...tool.description ? { description: tool.description } : {},
+              source: SOURCES[tool.kind],
+              // MCP clients never see the route behind a tool; only Infra's view names it.
+              ...full && tool.kind === "endpoint" ? { method: tool.method, path: tool.path } : {},
+              ...hints,
+              ...schemas ? { inputSchema: schemas.input } : {},
+              ...schemas?.output ? { outputSchema: schemas.output } : {}
+            };
+          })
+        };
+      })
+    },
+    webmcp: input.webmcp,
+    integrations: input.integrations,
+    agent: input.agent,
+    plugins: input.plugins
+  };
+  manifest.mcp.servers.push(...listDefaultServer(input));
+  return manifest;
+}
+__name(createFarmAppManifest, "createFarmAppManifest");
+function listDefaultServer(input) {
+  const server = input.defaultMCP?.();
+  if (!server) return [];
+  return [
+    {
+      name: server.name,
+      version: server.version,
+      path: server.path,
+      authorization: "none",
+      resources: [],
+      prompts: [],
+      tools: FARM_DEFAULT_MCP_TOOLS.map((tool) => ({
+        name: tool.name,
+        title: tool.title,
+        description: tool.description,
+        // Standalone tools with no endpoint behind them, like defineTool's.
+        source: "defineTool",
+        ...tool.annotations,
+        inputSchema: tool.inputSchema,
+        ..."outputSchema" in tool ? { outputSchema: tool.outputSchema } : {}
+      }))
+    }
+  ];
+}
+__name(listDefaultServer, "listDefaultServer");
+var encoder = new TextEncoder();
+var hex = /* @__PURE__ */ __name((bytes) => [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join(""), "hex");
+async function sha256Hex(value) {
+  return hex(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
+}
+__name(sha256Hex, "sha256Hex");
+async function hmacHex(secret, message) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return hex(await crypto.subtle.sign("HMAC", key, encoder.encode(message)));
+}
+__name(hmacHex, "hmacHex");
+function sameHex(a, b) {
+  if (a.length !== b.length) return false;
+  let difference = 0;
+  for (let index = 0; index < a.length; index++)
+    difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  return difference === 0;
+}
+__name(sameHex, "sameHex");
+async function verifyFarmInfraManifestSignature(header, key, now = Date.now()) {
+  if (!header || header.length > 2048) return false;
+  const parts = header.split(",").map((part) => part.trim());
+  const timestamp = Number(
+    /^t=(\d{1,12})$/.exec(parts.find((part) => part.startsWith("t=")) ?? "")?.[1]
+  );
+  if (!Number.isSafeInteger(timestamp)) return false;
+  if (Math.abs(now / 1e3 - timestamp) > SIGNATURE_WINDOW_SECONDS) return false;
+  const signatures = parts.filter((part) => part.startsWith("v1=")).map((part) => part.slice(3)).filter((value) => /^[0-9a-f]{64}$/.test(value));
+  if (!signatures.length || signatures.length > 8) return false;
+  const expected = await hmacHex(await sha256Hex(key), `${SIGNED_PURPOSE}
+${timestamp}`);
+  return signatures.some((signature) => sameHex(signature, expected));
+}
+__name(verifyFarmInfraManifestSignature, "verifyFarmInfraManifestSignature");
+function processEnv() {
+  return globalThis.process?.env ?? {};
+}
+__name(processEnv, "processEnv");
+var CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET, HEAD, OPTIONS",
+  "access-control-allow-headers": `If-None-Match, ${FARM_INFRA_SIGNATURE_HEADER}`,
+  "access-control-expose-headers": "ETag"
+};
+async function createFarmAppManifestResponse(request, input, options = {}) {
+  const method = request.method.toUpperCase();
+  if (method === "OPTIONS") return new Response(null, { status: 204, headers: CORS_HEADERS });
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response("Method Not Allowed", {
+      status: 405,
+      headers: { ...CORS_HEADERS, allow: "GET, HEAD, OPTIONS", "content-type": "text/plain" }
+    });
+  }
+  const signature = request.headers.get(FARM_INFRA_SIGNATURE_HEADER);
+  const key = input.analytics ? (options.env ?? processEnv()).FARMJS_API_KEY?.trim() : void 0;
+  const full = Boolean(
+    signature && key && await verifyFarmInfraManifestSignature(signature, key)
+  );
+  const body = JSON.stringify(createFarmAppManifest(input, { full }));
+  const etag = createFarmWeakETag(body);
+  const headers = {
+    ...CORS_HEADERS,
+    "content-type": "application/json; charset=utf-8",
+    // The full view is for Infra alone; shared caches keep the two views apart.
+    "cache-control": full ? "private, no-store" : "public, max-age=0, must-revalidate",
+    vary: FARM_INFRA_SIGNATURE_HEADER,
+    etag,
+    "x-content-type-options": "nosniff"
+  };
+  if (!full && matchesFarmIfNoneMatch(request.headers.get("if-none-match"), etag)) {
+    return new Response(null, { status: 304, headers });
+  }
+  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
+}
+__name(createFarmAppManifestResponse, "createFarmAppManifestResponse");
+
+export {
+  formatRouteSegment,
+  createRouteDirectoryPattern,
+  stripRouteGroups,
+  getRouteGroupScope,
+  isInRouteGroupScope,
+  getRouteDirectoryDepth,
+  routeBoundaryCoversDirectory,
+  HOISTED_HEAD_ELEMENT,
+  extractFarmFullDocument,
+  classifyFarmDocumentPrefix,
+  removeFarmDocumentTitles,
+  ensureFarmDocumentMeta,
+  composeFarmFullDocument,
+  renderFarmLocaleAlternateLinks,
+  createLateRedirectRecovery,
+  createLateNotFoundRecovery,
+  createFarmMetadataRouteResponse,
+  listFarmMCPLlmsTxtLinks,
+  createFarmAiCatalogResponse,
+  resolveDefaultErrorStatus,
+  getDefaultErrorStatusText,
+  createDefaultErrorMarkup,
+  createFarmThemeDocumentParts,
+  applyFarmThemeDocument,
+  FARM_API_CATALOG_PATH,
+  resolveFarmApiCatalogInput,
+  createFarmApiCatalogResponse,
+  FARM_APP_MANIFEST_PATH,
+  FARM_APP_MANIFEST_LEGACY_PATH,
+  isFarmAppManifestPath,
+  FARM_INFRA_SIGNATURE_HEADER,
+  resolveFarmAppManifestInput,
+  createFarmAppManifestResponse
+};