@farm.js/core 0.1.0-beta.5 → 0.1.0-beta.7

package/dist/index.cjs

@@ -673,13 +673,13 @@ function defineIntegrationAPI(api3) {
 }
 function operation(method, pathOrOptions, maybeOptions = {}) {
   const hasExplicitPath = typeof pathOrOptions === "string";
-  const path28 = hasExplicitPath ? pathOrOptions : "";
+  const path29 = hasExplicitPath ? pathOrOptions : "";
   const options = hasExplicitPath ? maybeOptions : {
     ...maybeOptions,
     ...pathOrOptions
   };
   return defineIntegrationAPIOperation({
-    path: path28,
+    path: path29,
     method,
     __pathless: !hasExplicitPath,
     ...options
@@ -691,26 +691,26 @@ function get(pathOrOptions, maybeOptions = {}) {
 function isOperation(value) {
   return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
 }
-function bindRoutePath(path28, api3) {
+function bindRoutePath(path29, api3) {
   const entries = Object.entries(api3).map(([key, value]) => {
     if (isOperation(value)) {
       return [
         key,
         {
           ...value,
-          path: path28,
+          path: path29,
           __pathless: false
         }
       ];
     }
     if (value && typeof value === "object") {
-      return [key, bindRoutePath(path28, value)];
+      return [key, bindRoutePath(path29, value)];
     }
     return [key, value];
   });
   return Object.fromEntries(entries);
 }
-function route(path28, definitionOrOperation, ...operations) {
+function route(path29, definitionOrOperation, ...operations) {
   if (isOperation(definitionOrOperation)) {
     const allOperations = [definitionOrOperation, ...operations];
     return Object.fromEntries(
@@ -718,13 +718,13 @@ function route(path28, definitionOrOperation, ...operations) {
         operation2.method.toLowerCase(),
         {
           ...operation2,
-          path: path28,
+          path: path29,
           __pathless: false
         }
       ])
     );
   }
-  return bindRoutePath(path28, definitionOrOperation);
+  return bindRoutePath(path29, definitionOrOperation);
 }
 function normalizeRouteSegment(segment) {
   if (!segment) {
@@ -745,8 +745,8 @@ function normalizeRouteSegment(segment) {
 function camelCaseRouteSegment(segment) {
   return segment.replace(/-([a-zA-Z0-9])/g, (_match, value) => value.toUpperCase());
 }
-function getRouteClientSegments(path28) {
-  const segments = path28.split("/").filter(Boolean);
+function getRouteClientSegments(path29) {
+  const segments = path29.split("/").filter(Boolean);
   if (segments.length === 0) {
     return ["index"];
   }
@@ -1156,9 +1156,9 @@ function getFarmIntegrationPluginServerRuntime(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
   return typeof value === "boolean" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path28, input) {
+function defineTypedIntegrationRoute(method, path29, input) {
   return {
-    path: path28,
+    path: path29,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -1168,7 +1168,7 @@ function defineTypedIntegrationRoute(method, path28, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path28,
+      path: path29,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -1180,52 +1180,52 @@ function defineTypedIntegrationRoute(method, path28, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path28, input) {
+    get(path29, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path28,
+        path29,
         input
       );
     },
-    post(path28, input) {
+    post(path29, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path28,
+        path29,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path28, input) {
+    put(path29, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path28,
+        path29,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path28, input) {
-      return defineTypedIntegrationRoute("PATCH", path28, {
+    patch(path29, input) {
+      return defineTypedIntegrationRoute("PATCH", path29, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path28, input) {
-      return defineTypedIntegrationRoute("DELETE", path28, {
+    delete(path29, input) {
+      return defineTypedIntegrationRoute("DELETE", path29, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path28, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path28, input);
+    options(path29, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path29, input);
     },
-    head(path28, input) {
+    head(path29, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path28,
+        path29,
         input
       );
     }
@@ -1515,8 +1515,8 @@ async function parseIntegrationConfigSchema(integration, schema, value) {
 function createIntegrationConfigValidationError(integration, error) {
   const issues = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues.map((issue) => {
     const normalizedPath = normalizeIntegrationValidationPath(issue.path);
-    const path28 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path28}${issue.message || "Invalid config"}`;
+    const path29 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path29}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -2201,8 +2201,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path28) {
-  return (path28 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path29) {
+  return (path29 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -2853,13 +2853,13 @@ function getRequestId(req) {
   return headerValue || String(Date.now());
 }
 async function readRequestBody(req) {
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
     req.on("end", () => {
-      resolve5(Buffer.concat(chunks));
+      resolve6(Buffer.concat(chunks));
     });
     req.on("error", reject);
   });
@@ -2965,178 +2965,9 @@ var init_integrations = __esm({
   }
 });
 
-// src/app-markdown.ts
-function resolveMdxConfig(config) {
-  return {
-    components: config?.components,
-    markdownRoutes: config?.markdownRoutes ?? true,
-    className: config?.className ?? "farm-markdown"
-  };
-}
-function isFarmMarkdownPageFile(filePath) {
-  return /(^|[/\\])page\.mdx?$/i.test(filePath);
-}
-function normalizeFarmMarkdownRoutePath(pathname) {
-  const withoutExtension = pathname.replace(/\.md$/i, "");
-  const normalized = withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
-  return normalized === "/index" ? "/" : normalized.replace(/\/+$/g, "") || "/";
-}
-function parseMarkdownFrontmatter(source) {
-  if (!source.startsWith("---")) {
-    return { frontmatter: {}, body: source };
-  }
-  const endIndex = source.indexOf("\n---", 3);
-  if (endIndex === -1) {
-    return { frontmatter: {}, body: source };
-  }
-  const frontmatterSource = source.slice(3, endIndex).trim();
-  const closingFenceEnd = endIndex + "\n---".length;
-  const bodyStart = source.slice(closingFenceEnd, closingFenceEnd + 2) === "\r\n" ? closingFenceEnd + 2 : source[closingFenceEnd] === "\n" ? closingFenceEnd + 1 : closingFenceEnd;
-  const body = source.slice(bodyStart);
-  const frontmatter = {};
-  for (const line of frontmatterSource.split(/\r?\n/)) {
-    const separator = line.indexOf(":");
-    if (separator === -1) continue;
-    const key = line.slice(0, separator).trim();
-    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
-    if (key && value) frontmatter[key] = value;
-  }
-  return { frontmatter, body };
-}
-function titleFromMarkdown(body, fallback) {
-  return body.match(/^#\s+(.+)$/m)?.[1]?.trim() || fallback;
-}
-function createMarkdownMetadata(source, filePath) {
-  const { frontmatter, body } = parseMarkdownFrontmatter(source);
-  const routeTitle = titleFromMarkdown(body);
-  const title = frontmatter.title || routeTitle;
-  const description = frontmatter.description;
-  if (!title && !description) {
-    return void 0;
-  }
-  return {
-    ...title ? { title } : {},
-    ...description ? { description } : {},
-    source: filePath
-  };
-}
-async function evaluateMdxSource(source, filePath) {
-  const [{ evaluate }, runtime, remarkGfmModule] = await Promise.all([
-    import("@mdx-js/mdx"),
-    import("react/jsx-runtime"),
-    import("remark-gfm")
-  ]);
-  const remarkGfm = remarkGfmModule.default;
-  return evaluate(source, {
-    ...runtime,
-    baseUrl: (0, import_url.pathToFileURL)(filePath),
-    remarkPlugins: [remarkGfm]
-  });
-}
-function createFarmMarkdownRouteModule(input) {
-  const { body } = parseMarkdownFrontmatter(input.source);
-  const components = input.components || {};
-  const className = input.config?.className || "farm-markdown";
-  let evaluatedPromise;
-  const loadContent = /* @__PURE__ */ __name(async () => {
-    evaluatedPromise ?? (evaluatedPromise = evaluateMdxSource(body, input.filePath));
-    return evaluatedPromise;
-  }, "loadContent");
-  async function FarmMarkdownPage(props) {
-    const evaluated = await loadContent();
-    const MDXContent = evaluated.default;
-    return import_react.default.createElement(
-      "article",
-      { className, "data-farm-markdown-page": "" },
-      import_react.default.createElement(MDXContent, {
-        ...props,
-        components: {
-          ...components,
-          ...props?.components
-        }
-      })
-    );
-  }
-  __name(FarmMarkdownPage, "FarmMarkdownPage");
-  return {
-    default: FarmMarkdownPage,
-    metadata: createMarkdownMetadata(input.source, input.filePath),
-    source: input.source
-  };
-}
-async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
-  const source = await (0, import_promises.readFile)(filePath, "utf8");
-  return createFarmMarkdownRouteModule({
-    source,
-    filePath,
-    components: options.components,
-    config: options.config
-  });
-}
-async function loadFarmMdxComponents(config, options) {
-  const configured = config?.components;
-  if (!configured) {
-    return {};
-  }
-  if (typeof configured !== "string") {
-    return configured;
-  }
-  const modulePath = import_path2.default.isAbsolute(configured) ? configured : import_path2.default.join(options.root, configured);
-  const mod = options.loadModule ? await options.loadModule(modulePath) : await import((0, import_url.pathToFileURL)(modulePath).href);
-  const maybeModule = mod;
-  return maybeModule.components || maybeModule.default || {};
-}
-async function createFarmMarkdownSourceResponse(options) {
-  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
-    return null;
-  }
-  if (options.config?.markdownRoutes === false) {
-    return null;
-  }
-  const url = new URL(options.request.url);
-  if (!url.pathname.endsWith(".md")) {
-    return null;
-  }
-  const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
-  const source = await options.resolveSource(targetPathname);
-  if (!source) {
-    return null;
-  }
-  return new Response(options.request.method === "HEAD" ? null : source.source, {
-    status: 200,
-    headers: {
-      "Content-Type": "text/markdown; charset=utf-8",
-      "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
-      "X-Farm-Markdown-Route": targetPathname,
-      "X-Farm-Markdown-Source": source.filePath
-    }
-  });
-}
-var import_react, import_promises, import_path2, import_url;
-var init_app_markdown = __esm({
-  "src/app-markdown.ts"() {
-    "use strict";
-    import_react = __toESM(require("react"));
-    import_promises = require("fs/promises");
-    import_path2 = __toESM(require("path"));
-    import_url = require("url");
-    __name(resolveMdxConfig, "resolveMdxConfig");
-    __name(isFarmMarkdownPageFile, "isFarmMarkdownPageFile");
-    __name(normalizeFarmMarkdownRoutePath, "normalizeFarmMarkdownRoutePath");
-    __name(parseMarkdownFrontmatter, "parseMarkdownFrontmatter");
-    __name(titleFromMarkdown, "titleFromMarkdown");
-    __name(createMarkdownMetadata, "createMarkdownMetadata");
-    __name(evaluateMdxSource, "evaluateMdxSource");
-    __name(createFarmMarkdownRouteModule, "createFarmMarkdownRouteModule");
-    __name(createFarmMarkdownRouteModuleFromFile, "createFarmMarkdownRouteModuleFromFile");
-    __name(loadFarmMdxComponents, "loadFarmMdxComponents");
-    __name(createFarmMarkdownSourceResponse, "createFarmMarkdownSourceResponse");
-  }
-});
-
 // src/markdown.ts
 function resolveMarkdownConfig(config) {
-  if (config === false || config === void 0) {
+  if (config === false) {
     return {
       enabled: false,
       expose: [],
@@ -3144,7 +2975,7 @@ function resolveMarkdownConfig(config) {
       includeMetadata: true
     };
   }
-  if (config === true) {
+  if (config === true || config === void 0) {
     return {
       enabled: true,
       expose: true,
@@ -3152,7 +2983,7 @@ function resolveMarkdownConfig(config) {
       includeMetadata: true
     };
   }
-  const exposeInput = config.expose ?? config.routes ?? [];
+  const exposeInput = config.expose ?? config.routes ?? true;
   const expose = exposeInput === true ? true : Array.isArray(exposeInput) ? exposeInput.map(normalizeMarkdownRouteInput) : [];
   return {
     enabled: config.enabled !== false && (expose === true || expose.length > 0),
@@ -3161,11 +2992,14 @@ function resolveMarkdownConfig(config) {
     includeMetadata: config.includeMetadata ?? true
   };
 }
-function resolveMarkdownMirrorTarget(config, pathname) {
-  if (!config?.enabled || !pathname.endsWith(".md")) {
+function resolveMarkdownMirrorTarget(config, pathname, options = {}) {
+  const hasMarkdownExtension = pathname.toLowerCase().endsWith(".md");
+  if (!config?.enabled || !hasMarkdownExtension && !requestAcceptsMarkdown(options.accept)) {
     return null;
   }
-  const targetPathname = normalizeMarkdownRoute(pathname.slice(0, -".md".length) || "/");
+  const targetPathname = normalizeMarkdownRoute(
+    hasMarkdownExtension ? pathname.slice(0, -".md".length) || "/" : pathname
+  );
   const route2 = findExposedMarkdownRoute(config, targetPathname);
   if (!route2 && config.expose !== true) {
     return null;
@@ -3180,7 +3014,10 @@ async function createMarkdownMirrorResponse(options) {
     return null;
   }
   const requestUrl = new URL(options.request.url);
-  const target = resolveMarkdownMirrorTarget(options.config, requestUrl.pathname);
+  const hasMarkdownExtension = requestUrl.pathname.toLowerCase().endsWith(".md");
+  const target = resolveMarkdownMirrorTarget(options.config, requestUrl.pathname, {
+    accept: options.request.headers.get("accept")
+  });
   if (!target) {
     return null;
   }
@@ -3208,8 +3045,12 @@ async function createMarkdownMirrorResponse(options) {
   });
   const headersOut = new Headers({
     "Content-Type": "text/markdown; charset=utf-8",
+    "Content-Location": target.pathname === "/" ? "/index.md" : `${target.pathname}.md`,
     "X-Farm-Markdown-Route": target.pathname
   });
+  if (!hasMarkdownExtension) {
+    headersOut.set("Vary", "Accept");
+  }
   const cache = target.route?.cache ?? options.config?.cache ?? false;
   headersOut.set("Cache-Control", createMarkdownCacheHeader(cache));
   return new Response(options.request.method === "HEAD" ? null : markdown, {
@@ -3217,6 +3058,26 @@ async function createMarkdownMirrorResponse(options) {
     headers: headersOut
   });
 }
+function applyMarkdownNegotiationHeaders(response, options) {
+  if (!isHtmlResponse(response)) {
+    return response;
+  }
+  const target = resolveMarkdownMirrorTarget(options.config, options.pathname, {
+    accept: "text/markdown"
+  });
+  if (!target) {
+    return response;
+  }
+  const alternatePath = getMarkdownAlternatePath(target.pathname);
+  const headers2 = new Headers(response.headers);
+  appendHeaderToken(headers2, "Vary", "Accept");
+  headers2.append("Link", `<${alternatePath}>; rel="alternate"; type="text/markdown"`);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headers2
+  });
+}
 function htmlToMarkdown(html, options = {}) {
   const title = options.title ?? extractHtmlTitle(html);
   let source = extractHtmlBody(html).replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, "").replace(/<!--[\s\S]*?-->/g, "");
@@ -3295,11 +3156,38 @@ function normalizeMarkdownRouteInput(input) {
   };
 }
 function normalizeMarkdownRoute(route2) {
-  const withoutMarkdownExtension = route2.endsWith(".md") ? route2.slice(0, -3) : route2;
+  const withoutMarkdownExtension = route2.toLowerCase().endsWith(".md") ? route2.slice(0, -3) : route2;
   const withSlash = withoutMarkdownExtension.startsWith("/") ? withoutMarkdownExtension : `/${withoutMarkdownExtension}`;
   const normalized = withSlash.replace(/\/+/g, "/").replace(/\/$/g, "");
   return normalized === "" || normalized === "/index" ? "/" : normalized;
 }
+function requestAcceptsMarkdown(accept) {
+  if (!accept) {
+    return false;
+  }
+  return accept.split(",").some((entry) => {
+    const [mediaType, ...parameters] = entry.trim().toLowerCase().split(";").map((part) => part.trim());
+    if (mediaType !== "text/markdown") {
+      return false;
+    }
+    const quality = parameters.find((parameter) => parameter.startsWith("q="));
+    return quality === void 0 || Number(quality.slice(2)) > 0;
+  });
+}
+function getMarkdownAlternatePath(pathname) {
+  return pathname === "/" ? "/index.md" : `${pathname}.md`;
+}
+function appendHeaderToken(headers2, name, token) {
+  const current = headers2.get(name);
+  if (!current) {
+    headers2.set(name, token);
+    return;
+  }
+  const tokens = current.split(",").map((value) => value.trim().toLowerCase());
+  if (!tokens.includes(token.toLowerCase())) {
+    headers2.set(name, `${current}, ${token}`);
+  }
+}
 function findExposedMarkdownRoute(config, pathname) {
   if (config.expose === true) {
     return null;
@@ -3387,9 +3275,13 @@ var init_markdown = __esm({
     __name(resolveMarkdownConfig, "resolveMarkdownConfig");
     __name(resolveMarkdownMirrorTarget, "resolveMarkdownMirrorTarget");
     __name(createMarkdownMirrorResponse, "createMarkdownMirrorResponse");
+    __name(applyMarkdownNegotiationHeaders, "applyMarkdownNegotiationHeaders");
     __name(htmlToMarkdown, "htmlToMarkdown");
     __name(normalizeMarkdownRouteInput, "normalizeMarkdownRouteInput");
     __name(normalizeMarkdownRoute, "normalizeMarkdownRoute");
+    __name(requestAcceptsMarkdown, "requestAcceptsMarkdown");
+    __name(getMarkdownAlternatePath, "getMarkdownAlternatePath");
+    __name(appendHeaderToken, "appendHeaderToken");
     __name(findExposedMarkdownRoute, "findExposedMarkdownRoute");
     __name(routeMatches, "routeMatches");
     __name(isHtmlResponse, "isHtmlResponse");
@@ -3403,6 +3295,182 @@ var init_markdown = __esm({
   }
 });
 
+// src/app-markdown.ts
+function resolveMdxConfig(config) {
+  return {
+    components: config?.components,
+    markdownRoutes: config?.markdownRoutes ?? true,
+    className: config?.className ?? "farm-markdown"
+  };
+}
+function isFarmMarkdownPageFile(filePath) {
+  return /(^|[/\\])page\.mdx?$/i.test(filePath);
+}
+function normalizeFarmMarkdownRoutePath(pathname) {
+  const withoutExtension = pathname.replace(/\.md$/i, "");
+  const normalized = withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
+  return normalized === "/index" ? "/" : normalized.replace(/\/+$/g, "") || "/";
+}
+function parseMarkdownFrontmatter(source) {
+  if (!source.startsWith("---")) {
+    return { frontmatter: {}, body: source };
+  }
+  const endIndex = source.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: source };
+  }
+  const frontmatterSource = source.slice(3, endIndex).trim();
+  const closingFenceEnd = endIndex + "\n---".length;
+  const bodyStart = source.slice(closingFenceEnd, closingFenceEnd + 2) === "\r\n" ? closingFenceEnd + 2 : source[closingFenceEnd] === "\n" ? closingFenceEnd + 1 : closingFenceEnd;
+  const body = source.slice(bodyStart);
+  const frontmatter = {};
+  for (const line of frontmatterSource.split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
+    if (key && value) frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function titleFromMarkdown(body, fallback) {
+  return body.match(/^#\s+(.+)$/m)?.[1]?.trim() || fallback;
+}
+function createMarkdownMetadata(source, filePath) {
+  const { frontmatter, body } = parseMarkdownFrontmatter(source);
+  const routeTitle = titleFromMarkdown(body);
+  const title = frontmatter.title || routeTitle;
+  const description = frontmatter.description;
+  if (!title && !description) {
+    return void 0;
+  }
+  return {
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    source: filePath
+  };
+}
+async function evaluateMdxSource(source, filePath) {
+  const [{ evaluate }, runtime, remarkGfmModule] = await Promise.all([
+    import("@mdx-js/mdx"),
+    import("react/jsx-runtime"),
+    import("remark-gfm")
+  ]);
+  const remarkGfm = remarkGfmModule.default;
+  return evaluate(source, {
+    ...runtime,
+    baseUrl: (0, import_url.pathToFileURL)(filePath),
+    remarkPlugins: [remarkGfm]
+  });
+}
+function createFarmMarkdownRouteModule(input) {
+  const { body } = parseMarkdownFrontmatter(input.source);
+  const components = input.components || {};
+  const className = input.config?.className || "farm-markdown";
+  let evaluatedPromise;
+  const loadContent = /* @__PURE__ */ __name(async () => {
+    evaluatedPromise ?? (evaluatedPromise = evaluateMdxSource(body, input.filePath));
+    return evaluatedPromise;
+  }, "loadContent");
+  async function FarmMarkdownPage(props) {
+    const evaluated = await loadContent();
+    const MDXContent = evaluated.default;
+    return import_react.default.createElement(
+      "article",
+      { className, "data-farm-markdown-page": "" },
+      import_react.default.createElement(MDXContent, {
+        ...props,
+        components: {
+          ...components,
+          ...props?.components
+        }
+      })
+    );
+  }
+  __name(FarmMarkdownPage, "FarmMarkdownPage");
+  return {
+    default: FarmMarkdownPage,
+    metadata: createMarkdownMetadata(input.source, input.filePath),
+    source: input.source
+  };
+}
+async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
+  const source = await (0, import_promises.readFile)(filePath, "utf8");
+  return createFarmMarkdownRouteModule({
+    source,
+    filePath,
+    components: options.components,
+    config: options.config
+  });
+}
+async function loadFarmMdxComponents(config, options) {
+  const configured = config?.components;
+  if (!configured) {
+    return {};
+  }
+  if (typeof configured !== "string") {
+    return configured;
+  }
+  const modulePath = import_path2.default.isAbsolute(configured) ? configured : import_path2.default.join(options.root, configured);
+  const mod = options.loadModule ? await options.loadModule(modulePath) : await import((0, import_url.pathToFileURL)(modulePath).href);
+  const maybeModule = mod;
+  return maybeModule.components || maybeModule.default || {};
+}
+async function createFarmMarkdownSourceResponse(options) {
+  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
+    return null;
+  }
+  if (options.config?.markdownRoutes === false) {
+    return null;
+  }
+  const url = new URL(options.request.url);
+  const hasMarkdownExtension = url.pathname.toLowerCase().endsWith(".md");
+  if (!hasMarkdownExtension && !requestAcceptsMarkdown(options.request.headers.get("accept"))) {
+    return null;
+  }
+  const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
+  const source = await options.resolveSource(targetPathname);
+  if (!source) {
+    return null;
+  }
+  const headers2 = new Headers({
+    "Content-Type": "text/markdown; charset=utf-8",
+    "Content-Location": targetPathname === "/" ? "/index.md" : `${targetPathname}.md`,
+    "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
+    "X-Farm-Markdown-Route": targetPathname,
+    "X-Farm-Markdown-Source": source.filePath
+  });
+  if (!hasMarkdownExtension) {
+    headers2.set("Vary", "Accept");
+  }
+  return new Response(options.request.method === "HEAD" ? null : source.source, {
+    status: 200,
+    headers: headers2
+  });
+}
+var import_react, import_promises, import_path2, import_url;
+var init_app_markdown = __esm({
+  "src/app-markdown.ts"() {
+    "use strict";
+    import_react = __toESM(require("react"));
+    import_promises = require("fs/promises");
+    import_path2 = __toESM(require("path"));
+    import_url = require("url");
+    init_markdown();
+    __name(resolveMdxConfig, "resolveMdxConfig");
+    __name(isFarmMarkdownPageFile, "isFarmMarkdownPageFile");
+    __name(normalizeFarmMarkdownRoutePath, "normalizeFarmMarkdownRoutePath");
+    __name(parseMarkdownFrontmatter, "parseMarkdownFrontmatter");
+    __name(titleFromMarkdown, "titleFromMarkdown");
+    __name(createMarkdownMetadata, "createMarkdownMetadata");
+    __name(evaluateMdxSource, "evaluateMdxSource");
+    __name(createFarmMarkdownRouteModule, "createFarmMarkdownRouteModule");
+    __name(createFarmMarkdownRouteModuleFromFile, "createFarmMarkdownRouteModuleFromFile");
+    __name(loadFarmMdxComponents, "loadFarmMdxComponents");
+    __name(createFarmMarkdownSourceResponse, "createFarmMarkdownSourceResponse");
+  }
+});
+
 // src/workflows.ts
 var workflows_exports = {};
 __export(workflows_exports, {
@@ -3555,26 +3623,26 @@ async function prepareFarmWorkflowsForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs9 = await import("fs/promises");
-  const path28 = await import("path");
-  const generatedDir = path28.join(root, distDir, ".nitro", "farm-workflows");
+  const path29 = await import("path");
+  const generatedDir = path29.join(root, distDir, ".nitro", "farm-workflows");
   await fs9.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path28.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    const wrapperPath = path29.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
     await fs9.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path28.join(generatedDir, "http-handler.mjs");
+  const handlerPath = path29.join(generatedDir, "http-handler.mjs");
   await fs9.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(workflowConfig, workflows),
     "utf8"
   );
-  const manifestPath = path28.join(generatedDir, "manifest.json");
+  const manifestPath = path29.join(generatedDir, "manifest.json");
   await fs9.writeFile(
     manifestPath,
     JSON.stringify(
@@ -3657,10 +3725,10 @@ function resolveWorkflowDefinition(module2) {
 }
 async function findWorkflowFiles(root, dirs) {
   const fs9 = await import("fs/promises");
-  const path28 = await import("path");
+  const path29 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path28.isAbsolute(dir) ? dir : path28.join(root, dir);
+    const absoluteDir = path29.isAbsolute(dir) ? dir : path29.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
@@ -3668,10 +3736,10 @@ async function findWorkflowFiles(root, dirs) {
 }
 async function walkWorkflowDir(dir, files) {
   const fs9 = await import("fs/promises");
-  const path28 = await import("path");
+  const path29 = await import("path");
   const entries = await fs9.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path28.join(dir, entry.name);
+    const filePath = path29.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -3691,12 +3759,12 @@ function isWorkflowFile(fileName) {
 }
 async function loadWorkflowModule(filePath, root) {
   const fs9 = await import("fs/promises");
-  const path28 = await import("path");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const path29 = await import("path");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const { build: build2 } = await import("esbuild");
-  const outDir = path28.join(root, ".farm", ".workflow-loader");
+  const outDir = path29.join(root, ".farm", ".workflow-loader");
   await fs9.mkdir(outDir, { recursive: true });
-  const outfile = path28.join(
+  const outfile = path29.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -3717,7 +3785,7 @@ async function loadWorkflowModule(filePath, root) {
   try {
     return await import(
       /* @vite-ignore */
-      `${pathToFileURL3(outfile).href}?t=${Date.now()}`
+      `${pathToFileURL4(outfile).href}?t=${Date.now()}`
     );
   } finally {
     await fs9.unlink(outfile).catch(() => void 0);
@@ -3975,9 +4043,9 @@ async function prepareFarmCronForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs9 = await import("fs/promises");
-  const path28 = await import("path");
-  const manifestPath = path28.join(root, distDir, FARM_CRON_MANIFEST);
-  const generatedDir = path28.join(root, distDir, ".nitro", "farm-cron");
+  const path29 = await import("path");
+  const manifestPath = path29.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path29.join(root, distDir, ".nitro", "farm-cron");
   if (!cron.enabled) {
     await Promise.all([
       fs9.rm(manifestPath, { force: true }),
@@ -3994,7 +4062,7 @@ async function prepareFarmCronForNitro(config) {
   const tasks = {};
   for (const job of cron.jobs) {
     const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = path28.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
+    const wrapperPath = path29.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
     await fs9.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
     tasks[taskName] = {
       handler: wrapperPath,
@@ -4002,7 +4070,7 @@ async function prepareFarmCronForNitro(config) {
     };
   }
   const manifest = createFarmCronManifest(cron);
-  await fs9.mkdir(path28.dirname(manifestPath), { recursive: true });
+  await fs9.mkdir(path29.dirname(manifestPath), { recursive: true });
   await fs9.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return {
@@ -4104,7 +4172,7 @@ function normalizeCronJob(name, job) {
   if (!job || typeof job !== "object" || Array.isArray(job)) {
     throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
   }
-  const path28 = normalizeCronPath(name, job.path);
+  const path29 = normalizeCronPath(name, job.path);
   const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
   const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name, value)))];
   if (schedule.length === 0) {
@@ -4113,7 +4181,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path28,
+    path: path29,
     description: job.description?.trim() || void 0
   };
 }
@@ -4121,13 +4189,13 @@ function normalizeCronPath(name, value) {
   if (typeof value !== "string" || !value.trim().startsWith("/")) {
     throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
   }
-  const path28 = value.trim();
-  if (path28.startsWith("//") || path28.includes("?") || path28.includes("#")) {
+  const path29 = value.trim();
+  if (path29.startsWith("//") || path29.includes("?") || path29.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path28.length > 1 ? path28.replace(/\/+$/, "") : path28;
+  return path29.length > 1 ? path29.replace(/\/+$/, "") : path29;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -5219,7 +5287,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path28 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path29 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -5247,7 +5315,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path28,
+    path: path29,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -5286,11 +5354,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path28 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path28.startsWith("/") || path28.includes("?") || path28.includes("#")) {
+  const path29 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path29.startsWith("/") || path29.includes("?") || path29.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path28;
+  return path29;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -6447,7 +6515,7 @@ function normalizePositiveDuration(value, fallback, name) {
   return Math.floor(value);
 }
 function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function normalizeCacheOptionsTags(options) {
   const tags = /* @__PURE__ */ new Set();
@@ -7031,7 +7099,7 @@ function getProgrammaticRouteSearchClientOptions(search) {
   if (search.temporary?.length) options.temporary = [...search.temporary];
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path28, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path29, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -7040,7 +7108,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path28, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path28
+    path: path29
   });
   return { search, canonicalPath };
 }
@@ -7119,8 +7187,8 @@ function normalizeComparableValue(value) {
   }
   return value;
 }
-function createRoute(path28, options) {
-  return routesBuilder.page(path28, options);
+function createRoute(path29, options) {
+  return routesBuilder.page(path29, options);
 }
 function isProgrammaticRoutesFileName(fileName) {
   const normalized = fileName.replace(/\\/g, "/");
@@ -7210,7 +7278,7 @@ function createRouteModuleFromProgrammaticPage(route2) {
     mod.__farmRouteData = route2.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route2, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path28) => resolveProgrammaticRouteSearch(route2.search, rawSearch, path28, route2.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path29) => resolveProgrammaticRouteSearch(route2.search, rawSearch, path29, route2.path).canonicalPath;
   }
   if (route2.pending || route2.error || route2.notFound) {
     mod.__farmRouteComponents = {
@@ -7608,25 +7676,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path28, options) {
+      page(path29, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path28,
+          path: path29,
           ...options
         });
       },
-      layout(path28, options) {
+      layout(path29, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path28,
+          path: path29,
           ...options
         });
       },
-      api(path28, options) {
+      api(path29, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path28,
+          path: path29,
           render,
           runtime,
           regions,
@@ -8588,8 +8656,56 @@ var init_route_manager = __esm({
           "**/{opengraph-image,twitter-image}.{ts,tsx,js,jsx,png,jpg,jpeg,gif,webp}",
           appDir
         );
+        const canonicalPageGroups = /* @__PURE__ */ new Map();
+        for (const file of pageFiles.filter((candidate) => parseRouteSlotFile(candidate) === null)) {
+          const route2 = parseRoutePath(file);
+          const pattern = this.createRoutePattern(route2);
+          const group = canonicalPageGroups.get(pattern);
+          if (group) {
+            group.files.push(file);
+          } else {
+            canonicalPageGroups.set(pattern, {
+              route: route2,
+              files: [file]
+            });
+          }
+        }
+        for (const [pattern, group] of canonicalPageGroups) {
+          const componentFiles = group.files.filter((file) => !isFarmMarkdownPageFile(file));
+          const markdownFiles = group.files.filter(isFarmMarkdownPageFile);
+          if (componentFiles.length > 1) {
+            throw new Error(
+              `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => import_path5.default.join(appDir, file)).join(" and ")}.`
+            );
+          }
+          if (markdownFiles.length > 1) {
+            throw new Error(
+              `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => import_path5.default.join(appDir, file)).join(" and ")}.`
+            );
+          }
+          const componentFile = componentFiles[0];
+          const markdownFile = markdownFiles[0];
+          const primaryFile = componentFile || markdownFile;
+          if (!primaryFile) continue;
+          const modulePath = import_path5.default.join(appDir, primaryFile);
+          const existing = this.routes.get(pattern);
+          if (existing?.sourceRoot === source.root) {
+            throw new Error(
+              `Duplicate page route "${pattern}". Found both ${existing.modulePath} and ${modulePath}.`
+            );
+          }
+          this.routes.set(pattern, {
+            route: group.route,
+            modulePath,
+            ...markdownFile ? {
+              markdownSourcePath: import_path5.default.join(appDir, markdownFile)
+            } : {},
+            pattern,
+            source: "file",
+            sourceRoot: source.root
+          });
+        }
         for (const [kind, files, target] of [
-          ["page", pageFiles.filter((file) => parseRouteSlotFile(file) === null), this.routes],
           ["layout", layoutFiles, this.layouts],
           ["loading", loadingFiles, this.loadings],
           ["error", errorFiles, this.errors]
@@ -9178,12 +9294,12 @@ function isFarmRouteActive(pattern, pathname, options = {}) {
 }
 function normalizeRouteInput(input, index) {
   const route2 = typeof input === "string" ? { path: input } : input;
-  const path28 = normalizePathname2(route2.path);
-  const segments = parseRoutePattern(path28);
+  const path29 = normalizePathname2(route2.path);
+  const segments = parseRoutePattern(path29);
   return {
     route: {
       ...route2,
-      path: path28
+      path: path29
     },
     segments,
     score: scoreSegments(segments),
@@ -9614,8 +9730,8 @@ function getControlledDeferred(id, controllers) {
   if (existing) return existing;
   let nativeResolve;
   let nativeReject;
-  const promise = new Promise((resolve5, reject) => {
-    nativeResolve = resolve5;
+  const promise = new Promise((resolve6, reject) => {
+    nativeResolve = resolve6;
     nativeReject = reject;
   });
   promise.status = "pending";
@@ -9820,8 +9936,8 @@ function createFarmDeploymentMismatchError(response, clientDeploymentId) {
     getFarmResponseDeploymentId(response) || "unknown"
   );
 }
-function createFarmDeploymentCookie(deploymentId, path28 = "/", secure = false) {
-  const normalizedPath = path28.startsWith("/") ? path28 : `/${path28}`;
+function createFarmDeploymentCookie(deploymentId, path29 = "/", secure = false) {
+  const normalizedPath = path29.startsWith("/") ? path29 : `/${path29}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -10001,11 +10117,11 @@ function readPageState() {
   if (!state || typeof state !== "object") return null;
   return state[FARM_PAGE_STATE_KEY] ?? null;
 }
-function createHistoryState(path28, pageState, currentState, interceptFrom) {
+function createHistoryState(path29, pageState, currentState, interceptFrom) {
   const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
   const nextState = {
     ...base,
-    path: path28,
+    path: path29,
     [FARM_PAGE_STATE_KEY]: pageState
   };
   if (interceptFrom === null) {
@@ -10015,9 +10131,9 @@ function createHistoryState(path28, pageState, currentState, interceptFrom) {
   }
   return nextState;
 }
-function getPageDataCacheKey(path28, interceptFrom) {
-  return interceptFrom ? `${path28}
-intercept:${interceptFrom}` : path28;
+function getPageDataCacheKey(path29, interceptFrom) {
+  return interceptFrom ? `${path29}
+intercept:${interceptFrom}` : path29;
 }
 function createNavigationLocation(url) {
   return {
@@ -10027,8 +10143,8 @@ function createNavigationLocation(url) {
     hash: url.hash
   };
 }
-function getScrollElementStorageKey(path28, key) {
-  return `farm-scroll-${path28}:${key}`;
+function getScrollElementStorageKey(path29, key) {
+  return `farm-scroll-${path29}:${key}`;
 }
 var FARM_PAGE_STATE_KEY, FARM_INTERCEPT_FROM_KEY, IDLE_NAVIGATION_STATE, routerInstance, _SPARouter, SPARouter;
 var init_spa_router = __esm({
@@ -10314,13 +10430,13 @@ var init_spa_router = __esm({
       /**
        * Fetch page data from cache or server
        */
-      async fetchPageData(path28, recover = true, interceptFrom) {
-        const cacheKey = getPageDataCacheKey(path28, interceptFrom);
+      async fetchPageData(path29, recover = true, interceptFrom) {
+        const cacheKey = getPageDataCacheKey(path29, interceptFrom);
         const cached = this.cache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
           return cached.data;
         }
-        const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path28)}`, {
+        const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path29)}`, {
           headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
             Accept: "application/x-farm-deferred+json, application/json",
             "X-Farm-SPA": "1",
@@ -10334,7 +10450,7 @@ var init_spa_router = __esm({
           );
           dispatchDeploymentMismatch(error);
           if (recover) {
-            window.location.assign(path28);
+            window.location.assign(path29);
           }
           throw error;
         }
@@ -10353,16 +10469,16 @@ var init_spa_router = __esm({
        */
       async handlePopState(event) {
         if (document.documentElement.dataset.farmDocsRuntime === "true") return;
-        const path28 = window.location.pathname + window.location.search;
+        const path29 = window.location.pathname + window.location.search;
         if (await this.shouldBlockNavigation({
-          from: event.state?.path || path28,
-          to: path28,
+          from: event.state?.path || path29,
+          to: path29,
           action: "pop"
         })) {
           return;
         }
         this.startNavigation({
-          from: event.state?.path || path28,
+          from: event.state?.path || path29,
           to: createNavigationLocation(new URL(window.location.href)),
           action: "pop"
         });
@@ -10374,7 +10490,7 @@ var init_spa_router = __esm({
             action: "pop"
           });
           const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
-          const pageData = await this.fetchPageData(path28, true, interceptFrom);
+          const pageData = await this.fetchPageData(path29, true, interceptFrom);
           if (clientNavigation) {
             await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
           }
@@ -10405,8 +10521,8 @@ var init_spa_router = __esm({
       /**
        * Check if URL is cached
        */
-      isCached(path28, interceptFrom) {
-        const cached = this.cache.get(getPageDataCacheKey(path28, interceptFrom));
+      isCached(path29, interceptFrom) {
+        const cached = this.cache.get(getPageDataCacheKey(path29, interceptFrom));
         return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
       }
       /**
@@ -10460,15 +10576,15 @@ var init_spa_router = __esm({
       /**
        * Save scroll position for a path
        */
-      saveScrollPosition(path28) {
+      saveScrollPosition(path29) {
         try {
           sessionStorage.setItem(
-            `farm-scroll-${path28}`,
+            `farm-scroll-${path29}`,
             JSON.stringify({ x: window.scrollX, y: window.scrollY })
           );
           for (const [key, element] of this.scrollElements) {
             sessionStorage.setItem(
-              getScrollElementStorageKey(path28, key),
+              getScrollElementStorageKey(path29, key),
               JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
             );
           }
@@ -10478,22 +10594,22 @@ var init_spa_router = __esm({
       /**
        * Restore scroll position for a path
        */
-      restoreScrollPosition(path28) {
+      restoreScrollPosition(path29) {
         try {
-          const saved = sessionStorage.getItem(`farm-scroll-${path28}`);
+          const saved = sessionStorage.getItem(`farm-scroll-${path29}`);
           if (saved) {
             const { x, y } = JSON.parse(saved);
             setTimeout(() => window.scrollTo(x, y), 0);
           }
           for (const [key, element] of this.scrollElements) {
-            this.restoreScrollElement(path28, key, element);
+            this.restoreScrollElement(path29, key, element);
           }
         } catch {
         }
       }
-      restoreScrollElement(path28, key, element) {
+      restoreScrollElement(path29, key, element) {
         try {
-          const saved = sessionStorage.getItem(getScrollElementStorageKey(path28, key));
+          const saved = sessionStorage.getItem(getScrollElementStorageKey(path29, key));
           if (!saved) return;
           const { x, y } = JSON.parse(saved);
           setTimeout(() => {
@@ -11844,6 +11960,7 @@ var init_renderer = __esm({
     init_server2();
     init_resolver();
     init_routing();
+    init_response();
     cachedClerkProvider = null;
     importRuntimeModule = new Function("specifier", "return import(specifier);");
     __name(hasRequestHeader, "hasRequestHeader");
@@ -12536,6 +12653,15 @@ var init_renderer = __esm({
             });
           });
         } catch (error) {
+          if (isWebResponse(error)) {
+            if (!res.headersSent && !res.writableEnded) {
+              await sendWebResponse(res, error);
+            } else if (!res.writableEnded) {
+              res.end();
+            }
+            completeRender(error.status, pathname);
+            return;
+          }
           if (isFarmRedirectError(error)) {
             const redirect3 = getFarmRedirectError(error);
             const snapshot = getFarmI18nClientSnapshot();
@@ -12836,7 +12962,7 @@ var init_renderer = __esm({
         }
       }
       async renderWithSSR(element, req, res, clearMiddlewareData, options = {}) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const streamStartTime = Date.now();
           const observabilityRoute = options.observabilityRoute || req.__FARM_ROUTE__ || req.url || "/";
           const deploymentId = this.getDeploymentId();
@@ -13016,7 +13142,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                     route: observabilityRoute,
                     durationMs: Date.now() - streamStartTime
                   });
-                  resolve5();
+                  resolve6();
                 }
               });
               res.write(shell);
@@ -13027,7 +13153,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
             },
             onShellError(error) {
               didError = true;
-              if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+              if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
                 logger.error(`SSR shell error: ${error}`);
                 emitFarmEvent({
                   type: "render.error",
@@ -13042,7 +13168,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
             },
             onError(error) {
               didError = true;
-              if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+              if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
                 logger.error(`SSR streaming error: ${error}`);
                 emitFarmEvent({
                   type: "render.error",
@@ -13222,6 +13348,96 @@ var init_devtools_config = __esm({
   }
 });
 
+// src/auth-config.ts
+function resolveFarmAuthConfig(input) {
+  const config = input === true ? {} : input && typeof input === "object" ? input : {};
+  const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
+  const resolved = {
+    enabled: input !== void 0 && input !== false && config.enabled !== false,
+    appName: config.appName,
+    basePath: normalizeBasePath(config.basePath),
+    emailAndPassword: {
+      enabled: config.emailAndPassword !== false,
+      requireEmailVerification: passwordConfig.requireEmailVerification ?? false,
+      minPasswordLength: passwordConfig.minPasswordLength ?? 8,
+      maxPasswordLength: passwordConfig.maxPasswordLength ?? 128
+    },
+    session: {
+      expiresIn: config.session?.expiresIn ?? 60 * 60 * 24 * 7,
+      updateAge: config.session?.updateAge ?? 60 * 60 * 24
+    },
+    database: {
+      url: config.database?.url,
+      path: config.database?.path || ".farm/auth.sqlite",
+      migrateInDevelopment: config.database?.migrateInDevelopment ?? true
+    }
+  };
+  validateFarmAuthConfig(resolved);
+  return resolved;
+}
+async function resolveFarmAuthIntegration(config, options) {
+  if (!config.enabled) return void 0;
+  const root = import_node_path4.default.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = (0, import_node_module2.createRequire)(import_node_path4.default.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+  } catch {
+    throw new Error(
+      "The `auth` config requires @farm.js/auth. Install it with `pnpm add @farm.js/auth` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    (0, import_node_url2.pathToFileURL)(modulePath).href
+  );
+  if (typeof runtime.createFarmAuthIntegration !== "function") {
+    throw new Error(
+      "The installed @farm.js/auth package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmAuthIntegration(config, {
+    ...options,
+    root
+  });
+}
+function normalizeBasePath(value) {
+  const route2 = (value || "/api/auth").trim();
+  const withLeadingSlash = route2.startsWith("/") ? route2 : `/${route2}`;
+  const normalized = withLeadingSlash.replace(/\/+/g, "/").replace(/\/+$/, "");
+  return normalized || "/api/auth";
+}
+function validateFarmAuthConfig(config) {
+  const { minPasswordLength, maxPasswordLength } = config.emailAndPassword;
+  if (!Number.isInteger(minPasswordLength) || minPasswordLength < 1) {
+    throw new Error("auth.emailAndPassword.minPasswordLength must be a positive integer.");
+  }
+  if (!Number.isInteger(maxPasswordLength) || maxPasswordLength < minPasswordLength) {
+    throw new Error(
+      "auth.emailAndPassword.maxPasswordLength must be an integer greater than or equal to minPasswordLength."
+    );
+  }
+  if (!Number.isInteger(config.session.expiresIn) || config.session.expiresIn < 1) {
+    throw new Error("auth.session.expiresIn must be a positive integer.");
+  }
+  if (!Number.isInteger(config.session.updateAge) || config.session.updateAge < 0) {
+    throw new Error("auth.session.updateAge must be a non-negative integer.");
+  }
+}
+var import_node_module2, import_node_path4, import_node_url2;
+var init_auth_config = __esm({
+  "src/auth-config.ts"() {
+    "use strict";
+    import_node_module2 = require("module");
+    import_node_path4 = __toESM(require("path"));
+    import_node_url2 = require("url");
+    __name(resolveFarmAuthConfig, "resolveFarmAuthConfig");
+    __name(resolveFarmAuthIntegration, "resolveFarmAuthIntegration");
+    __name(normalizeBasePath, "normalizeBasePath");
+    __name(validateFarmAuthConfig, "validateFarmAuthConfig");
+  }
+});
+
 // src/app.ts
 function isResolvedDocsConfig(value) {
   return !!value && typeof value === "object" && "enabled" in value && "entry" in value && "config" in value;
@@ -13229,6 +13445,11 @@ function isResolvedDocsConfig(value) {
 function isResolvedI18nConfig(value) {
   return Boolean(value && typeof value === "object" && "enabled" in value);
 }
+function isResolvedAuthConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && "enabled" in value && "emailAndPassword" in value && "database" in value
+  );
+}
 function createFarmApp(config, viteServer) {
   return new FarmApp(config, viteServer);
 }
@@ -13255,6 +13476,7 @@ var init_app = __esm({
     init_config();
     init_server2();
     init_cache();
+    init_auth_config();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -13309,6 +13531,7 @@ var init_app = __esm({
           deploy: config.deploy || {},
           storage: config.storage || {},
           cache: config.cache || {},
+          auth: isResolvedAuthConfig(config.auth) ? config.auth : resolveFarmAuthConfig(config.auth),
           integrations: config.integrations || {},
           plugins: config.plugins || [],
           migrations: config.migrations || { commands: [] },
@@ -13378,6 +13601,7 @@ var init_app = __esm({
     __name(_FarmApp, "FarmApp");
     FarmApp = _FarmApp;
     __name(isResolvedI18nConfig, "isResolvedI18nConfig");
+    __name(isResolvedAuthConfig, "isResolvedAuthConfig");
     __name(createFarmApp, "createFarmApp");
   }
 });
@@ -14090,15 +14314,15 @@ function isEndpointFailure(value) {
   return value instanceof EndpointFailure;
 }
 function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path28;
+  let path29;
   let options;
   let handler;
   if (typeof pathOrOptions === "string") {
-    path28 = pathOrOptions;
+    path29 = pathOrOptions;
     options = optionsOrHandler;
     handler = maybeHandler;
   } else {
-    path28 = "";
+    path29 = "";
     options = pathOrOptions;
     handler = optionsOrHandler;
   }
@@ -14125,13 +14349,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     ...betterCallOptions
   } = options;
   const endpoint2 = (0, import_better_call.createEndpoint)(
-    path28 || "/__farm_auto_path__",
+    path29 || "/__farm_auto_path__",
     betterCallOptions,
     wrappedHandler
   );
-  endpoint2.__path = path28 || void 0;
+  endpoint2.__path = path29 || void 0;
   endpoint2.__method = options.method || "GET";
-  endpoint2.__autoPath = !path28;
+  endpoint2.__autoPath = !path29;
   endpoint2.__handler = wrappedHandler;
   endpoint2.__farmInvoke = (ctx) => runEndpointMiddleware(middleware2, ctx, handler, fail, options.invalidates);
   endpoint2.__middleware = middleware2;
@@ -14669,12 +14893,12 @@ var init_runtime2 = __esm({
 });
 
 // src/api/route-manager.ts
-var fs3, path10, API_ROUTE_METHODS, _APIRouteManager, APIRouteManager;
+var fs3, path11, API_ROUTE_METHODS, _APIRouteManager, APIRouteManager;
 var init_route_manager2 = __esm({
   "src/api/route-manager.ts"() {
     "use strict";
     fs3 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    path11 = __toESM(require("path"));
     init_utils();
     init_routes();
     init_routes_server();
@@ -14705,7 +14929,7 @@ var init_route_manager2 = __esm({
       async discoverRoutes() {
         this.routes.clear();
         for (const appDir of this.appDirs) {
-          const apiDir = path10.join(appDir, "api");
+          const apiDir = path11.join(appDir, "api");
           let routeFiles = [];
           if (fs3.existsSync(apiDir)) {
             routeFiles = this.findRouteFiles(apiDir);
@@ -14733,7 +14957,7 @@ var init_route_manager2 = __esm({
         }
         const entries = fs3.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path10.join(dir, entry.name);
+          const fullPath = path11.join(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...this.findRouteFiles(fullPath));
           } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
@@ -14747,8 +14971,8 @@ var init_route_manager2 = __esm({
        */
       async loadRoute(filePath, appDir) {
         try {
-          const apiDir = path10.join(appDir, "api");
-          const relativePath2 = path10.relative(apiDir, path10.dirname(filePath));
+          const apiDir = path11.join(appDir, "api");
+          const relativePath2 = path11.relative(apiDir, path11.dirname(filePath));
           const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
           const routeModule = await this.loadModule(filePath);
           const endpoints = {};
@@ -14799,7 +15023,7 @@ var init_route_manager2 = __esm({
         }
       }
       async loadProgrammaticApiRoutes(appDir) {
-        const candidateRoots = [path10.dirname(appDir), appDir];
+        const candidateRoots = [path11.dirname(appDir), appDir];
         const routeFiles = Array.from(
           new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
         );
@@ -14825,11 +15049,11 @@ var init_route_manager2 = __esm({
       }
       findRootRoutesFile(appDir) {
         const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
-        const candidateDirs = [path10.dirname(appDir), appDir];
+        const candidateDirs = [path11.dirname(appDir), appDir];
         const seen = /* @__PURE__ */ new Set();
         for (const dir of candidateDirs) {
           for (const routeName of routeNames) {
-            const routesFile = path10.join(dir, routeName);
+            const routesFile = path11.join(dir, routeName);
             if (seen.has(routesFile)) {
               continue;
             }
@@ -15254,12 +15478,12 @@ var init_module = __esm({
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
-var fs4, path11, _MiddlewareManager, MiddlewareManager;
+var fs4, path12, _MiddlewareManager, MiddlewareManager;
 var init_manager = __esm({
   "src/middleware/manager.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    path12 = __toESM(require("path"));
     init_context();
     init_module();
     init_utils();
@@ -15339,8 +15563,8 @@ var init_manager = __esm({
         const entries = fs4.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-            const subPath = path11.join(dir, entry.name);
-            const subRoutePath = path11.posix.join(routePath, entry.name);
+            const subPath = path12.join(dir, entry.name);
+            const subRoutePath = path12.posix.join(routePath, entry.name);
             await this.discoverInDirectory(subPath, subRoutePath, discovered);
           }
         }
@@ -15351,7 +15575,7 @@ var init_manager = __esm({
       findMiddlewareFile(dir) {
         const extensions = [".ts", ".tsx", ".js", ".jsx"];
         for (const ext of extensions) {
-          const filePath = path11.join(dir, `middleware${ext}`);
+          const filePath = path12.join(dir, `middleware${ext}`);
           if (fs4.existsSync(filePath)) {
             return filePath;
           }
@@ -15818,11 +16042,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route2);
         }
         const nestedStructure = {};
-        for (const [path28, routeList] of routeGroups) {
+        for (const [path29, routeList] of routeGroups) {
           const route2 = routeList[0];
           const importPath = this.getRouteImportPath(route2, options.outFile);
           const routeName = this.pathToRouteName(route2.path);
-          const cleanPath = path28 === "/api" ? "" : path28.replace(/^\/api\//, "");
+          const cleanPath = path29 === "/api" ? "" : path29.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -15881,8 +16105,8 @@ ${typeExports}
         const relativeImport = (0, import_path7.relative)((0, import_path7.dirname)(outFile), route2.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path28) {
-        return (path28 === "/api" ? "root" : path28.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path29) {
+        return (path29 === "/api" ? "root" : path29.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -15902,15 +16126,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path28) {
-        const cleanPath = path28.replace(/^\/api\//, "");
+      getBaseExportName(path29) {
+        const cleanPath = path29.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path28, method) {
-        const cleanPath = path28.replace(/^\/api\//, "");
+      getExportName(path29, method) {
+        const cleanPath = path29.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -15972,19 +16196,22 @@ function createRoutePattern(route2) {
   }).join("/");
 }
 async function generateRouteTypes(options) {
-  const {
-    root,
-    srcDir = "src",
-    outFile = DEFAULT_OUT_FILE,
-    extraRoutes = [],
-    suppressLintOnLink = false
-  } = options;
+  const root = path13.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path13.isAbsolute(outFile) ? outFile : path13.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs5.mkdirSync(path13.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+async function createRouteTypeDeclarations(options, outPath) {
+  const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
-  const outPath = path12.join(root, srcDir, outFile);
   const patterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path12.join(source.root, source.srcDir, "app");
+    const appDir = path13.join(source.root, source.srcDir, "app");
     if (fs5.existsSync(appDir)) {
       const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
         cwd: appDir,
@@ -16013,18 +16240,19 @@ async function generateRouteTypes(options) {
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
   const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
   const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
+  const routeTypesImportPath = `./${path13.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const augmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 
 declare module "@farm.js/core" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
   // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
   const Link: typeof import("@farm.js/core/client").Link;
@@ -16033,8 +16261,8 @@ declare module "@farm.js/core" {
 // Internal declaration path used by @farm.js/core root type re-exports.
 declare module "@farm.js/core/dist/client.js" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 `;
@@ -16046,15 +16274,13 @@ declare module "@farm.js/core/dist/client.js" {
 export type RoutePath = ${routePathType};
 export type RoutePattern = ${routePatternType};${augmentationBlock}
 `;
-  fs5.mkdirSync(path12.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
-var path12, fs5, DEFAULT_OUT_FILE;
+var path13, fs5, DEFAULT_OUT_FILE;
 var init_generate_route_types = __esm({
   "src/routing/generate-route-types.ts"() {
     "use strict";
-    path12 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
     init_route_slots();
@@ -16066,23 +16292,30 @@ var init_generate_route_types = __esm({
     __name(createRoutePattern, "createRoutePattern");
     DEFAULT_OUT_FILE = "farm-routes.d.ts";
     __name(generateRouteTypes, "generateRouteTypes");
+    __name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
   }
 });
 
 // src/env-types.ts
 async function generateEnvTypes(options) {
-  const root = path13.resolve(options.root);
+  const root = path14.resolve(options.root);
   const srcDir = options.srcDir || "src";
-  const outPath = path13.join(root, srcDir, options.outFile || DEFAULT_OUT_FILE2);
+  const outFile = options.outFile || DEFAULT_OUT_FILE2;
+  const outPath = path14.isAbsolute(outFile) ? outFile : path14.join(root, srcDir, outFile);
+  const content = createEnvTypeDeclarations(options, outPath);
+  fs6.mkdirSync(path14.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+function createEnvTypeDeclarations(options, outPath) {
+  const root = path14.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
     ...(options.layerConfigPaths ?? []).filter((value) => fs6.existsSync(value)),
     ...configPath ? [configPath] : []
   ];
   const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
-  fs6.mkdirSync(path13.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
 function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
   const imports = configPaths.map(
@@ -16138,11 +16371,11 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path13.isAbsolute(configPath) ? configPath : path13.join(root, configPath);
+    const resolvedPath = path14.isAbsolute(configPath) ? configPath : path14.join(root, configPath);
     return fs6.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path13.join(root, filename);
+    const resolvedPath = path14.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -16203,15 +16436,15 @@ export {};
 `;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path13.relative(path13.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path14.relative(path14.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs6, path13, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
+var fs6, path14, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
 var init_env_types = __esm({
   "src/env-types.ts"() {
     "use strict";
     fs6 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
     init_write_file_if_changed();
     DEFAULT_OUT_FILE2 = "farm-env.d.ts";
     CONFIG_FILENAMES2 = [
@@ -16233,6 +16466,7 @@ var init_env_types = __esm({
       "config.cjs"
     ];
     __name(generateEnvTypes, "generateEnvTypes");
+    __name(createEnvTypeDeclarations, "createEnvTypeDeclarations");
     __name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
     __name(findConfigPath, "findConfigPath");
     __name(createConfigBackedEnvTypes, "createConfigBackedEnvTypes");
@@ -16243,8 +16477,8 @@ var init_env_types = __esm({
 
 // src/image-types.ts
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path4.default.resolve(options.root, options.outFile) : import_node_path4.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path5.default.resolve(options.root, options.outFile) : import_node_path5.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs3.mkdirSync)(import_node_path5.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -16268,12 +16502,12 @@ declare module "*?url" {
 }
 `;
 }
-var import_node_fs3, import_node_path4, FARM_STATIC_IMAGE_EXTENSIONS;
+var import_node_fs3, import_node_path5, FARM_STATIC_IMAGE_EXTENSIONS;
 var init_image_types = __esm({
   "src/image-types.ts"() {
     "use strict";
     import_node_fs3 = require("fs");
-    import_node_path4 = __toESM(require("path"));
+    import_node_path5 = __toESM(require("path"));
     init_write_file_if_changed();
     FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
     __name(generateFarmImageTypes, "generateFarmImageTypes");
@@ -16285,9 +16519,9 @@ var init_image_types = __esm({
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? (0, import_node_path5.resolve)(options.root, options.outFile) : (0, import_node_path5.join)((0, import_node_path5.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path6.resolve)(options.root, options.outFile) : (0, import_node_path6.join)((0, import_node_path6.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs4.mkdirSync)((0, import_node_path5.dirname)(outFile), { recursive: true });
+  (0, import_node_fs4.mkdirSync)((0, import_node_path6.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -16328,12 +16562,12 @@ function argumentType(kind) {
       return "string";
   }
 }
-var import_node_fs4, import_node_path5;
+var import_node_fs4, import_node_path6;
 var init_type_generator2 = __esm({
   "src/i18n/type-generator.ts"() {
     "use strict";
     import_node_fs4 = require("fs");
-    import_node_path5 = require("path");
+    import_node_path6 = require("path");
     init_catalog();
     init_write_file_if_changed();
     __name(generateFarmI18nTypes, "generateFarmI18nTypes");
@@ -16357,7 +16591,10 @@ async function generateFarmTypeArtifacts(options) {
   const result = {
     apiRoutes: []
   };
-  if (shouldGenerateRoutes) {
+  const unifiedTypesPath = (0, import_path8.join)(root, srcDir, "farm.d.ts");
+  const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
+  const unifiedSections = [];
+  if (shouldRefreshUnifiedTypes && !options.routeTypesOutFile) {
     const routeOptions = {
       root,
       srcDir,
@@ -16365,10 +16602,17 @@ async function generateFarmTypeArtifacts(options) {
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
     };
-    if (options.routeTypesOutFile) {
-      routeOptions.outFile = options.routeTypesOutFile;
-    }
-    result.routeTypesPath = await generateRouteTypes(routeOptions);
+    unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
+    result.routeTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateRoutes) {
+    result.routeTypesPath = await generateRouteTypes({
+      root,
+      srcDir,
+      outFile: options.routeTypesOutFile,
+      extraRoutes: options.extraRoutes || [],
+      suppressLintOnLink: options.suppressLintOnLink,
+      sourceRoots
+    });
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
@@ -16380,22 +16624,40 @@ async function generateFarmTypeArtifacts(options) {
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
-  if (shouldGenerateEnv) {
+  if (shouldRefreshUnifiedTypes && !options.envTypesOutFile) {
+    unifiedSections.push(
+      createEnvTypeDeclarations(
+        {
+          root,
+          srcDir,
+          configPath: options.configPath,
+          layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
+        },
+        unifiedTypesPath
+      )
+    );
+    result.envTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateEnv) {
     result.envTypesPath = await generateEnvTypes({
       root,
       srcDir,
       outFile: options.envTypesOutFile,
+      configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
     });
   }
-  if (shouldGenerateImages) {
+  if (shouldGenerateImages && options.imageTypesOutFile) {
     result.imageTypesPath = generateFarmImageTypes({
       root,
       srcDir,
       outFile: options.imageTypesOutFile
     });
   }
-  if (shouldGenerateI18n && options.i18nConfig) {
+  if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
+    const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+    unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
+    result.i18nTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateI18n && options.i18nConfig) {
     result.i18nTypesPath = await generateFarmI18nTypes({
       root,
       srcDir,
@@ -16403,9 +16665,35 @@ async function generateFarmTypeArtifacts(options) {
       outFile: options.i18nTypesOutFile
     });
   }
+  if (shouldRefreshUnifiedTypes) {
+    (0, import_fs4.mkdirSync)((0, import_path8.dirname)(unifiedTypesPath), { recursive: true });
+    writeFileIfChanged(
+      unifiedTypesPath,
+      `/**
+ * Generated by Farm.js. Do not edit.
+ * Contains project-specific route, environment, and internationalization types.
+ */
+
+import "@farm.js/core/image";
+
+${unifiedSections.join("\n")}`
+    );
+    result.typesPath = unifiedTypesPath;
+    removeLegacyTypeArtifacts(root, srcDir);
+  }
   return result;
 }
-var import_fs4, import_path8;
+function removeLegacyTypeArtifacts(root, srcDir) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path8.join)(root, srcDir, fileName);
+    if (!(0, import_fs4.existsSync)(filePath)) continue;
+    const source = (0, import_fs4.readFileSync)(filePath, "utf8");
+    if (source.includes(marker)) {
+      (0, import_fs4.unlinkSync)(filePath);
+    }
+  }
+}
+var import_fs4, import_path8, LEGACY_TYPE_ARTIFACTS;
 var init_type_artifacts = __esm({
   "src/type-artifacts.ts"() {
     "use strict";
@@ -16416,9 +16704,17 @@ var init_type_artifacts = __esm({
     init_env_types();
     init_image_types();
     init_type_generator2();
+    init_catalog();
     init_layers();
     init_write_file_if_changed();
     __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+    LEGACY_TYPE_ARTIFACTS = [
+      ["farm-routes.d.ts", "Auto-generated route types"],
+      ["farm-env.d.ts", "Auto-generated env types"],
+      ["farm-images.d.ts", "Generated by Farm.js"],
+      ["farm-i18n.d.ts", "Generated by Farm.js"]
+    ];
+    __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
   }
 });
 
@@ -16775,7 +17071,7 @@ var init_environment_vite = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.5";
+    version = "0.1.0-beta.7";
   }
 });
 
@@ -16812,8 +17108,8 @@ function reportAfterError(state, error) {
 function createAfterRequestState(reportError = defaultAfterErrorReporter) {
   let resolveResponseFinished;
   let responseFinished = false;
-  const responseFinishedPromise = new Promise((resolve5) => {
-    resolveResponseFinished = resolve5;
+  const responseFinishedPromise = new Promise((resolve6) => {
+    resolveResponseFinished = resolve6;
   });
   const state = {
     completion: Promise.resolve(),
@@ -16920,8 +17216,8 @@ function after(callback) {
     throw new Error("after() cannot schedule work after the request lifecycle has completed.");
   }
   let start;
-  const ready = new Promise((resolve5) => {
-    start = resolve5;
+  const ready = new Promise((resolve6) => {
+    start = resolve6;
   });
   const result = ready.then(callback);
   state.tasks.push({ result, start });
@@ -17046,12 +17342,12 @@ async function createBlurDataURL(bytes) {
     return void 0;
   }
 }
-var import_promises6, import_node_path6, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
+var import_promises6, import_node_path7, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
 var init_image_vite = __esm({
   "src/image-vite.ts"() {
     "use strict";
     import_promises6 = require("fs/promises");
-    import_node_path6 = __toESM(require("path"));
+    import_node_path7 = __toESM(require("path"));
     import_image_size2 = require("image-size");
     FARM_IMAGE_ID_PREFIX = "\0farm:image:";
     STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -17486,11 +17782,11 @@ function resolveExistingPath(filePath) {
   try {
     return (0, import_node_fs5.realpathSync)(filePath);
   } catch {
-    return import_node_path7.default.resolve(filePath);
+    return import_node_path8.default.resolve(filePath);
   }
 }
 function isDocsSourceFile(filePath) {
-  return DOCS_FILE_EXTENSIONS.has(import_node_path7.default.extname(filePath).toLowerCase());
+  return DOCS_FILE_EXTENSIONS.has(import_node_path8.default.extname(filePath).toLowerCase());
 }
 function discoverDocsSourceFiles(contentDir) {
   const files = [];
@@ -17499,7 +17795,7 @@ function discoverDocsSourceFiles(contentDir) {
       (a, b) => a.name.localeCompare(b.name)
     )) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path7.default.join(dir, entry.name);
+      const absolutePath = import_node_path8.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
       } else if (entry.isFile() && isDocsSourceFile(absolutePath)) {
@@ -17517,7 +17813,7 @@ function getGitLastModifiedDates(contentDir) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!gitRoot) return {};
-    const contentPathspec = normalizeRelativePath(import_node_path7.default.relative(gitRoot, contentDir)) || ".";
+    const contentPathspec = normalizeRelativePath(import_node_path8.default.relative(gitRoot, contentDir)) || ".";
     const contentPrefix = contentPathspec === "." ? "" : `${contentPathspec}/`;
     const history = (0, import_node_child_process.execFileSync)(
       "git",
@@ -17559,7 +17855,7 @@ function getGitLastModifiedDates(contentDir) {
   }
 }
 function readManifest(contentDir) {
-  const manifestPath = import_node_path7.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestPath = import_node_path8.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
   if (!(0, import_node_fs5.existsSync)(manifestPath)) return null;
   try {
     const parsed = JSON.parse(
@@ -17582,14 +17878,14 @@ function createFarmDocsLastModifiedManifest(contentDir, options = {}) {
   const fallbackDate = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
   const pages = {};
   for (const sourcePath of discoverDocsSourceFiles(resolvedContentDir)) {
-    const relativePath2 = normalizeRelativePath(import_node_path7.default.relative(resolvedContentDir, sourcePath));
+    const relativePath2 = normalizeRelativePath(import_node_path8.default.relative(resolvedContentDir, sourcePath));
     pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs5.statSync)(sourcePath).mtime.toISOString());
   }
   return { version: 1, pages };
 }
 function getLastModifiedManifest(contentDir) {
   const resolvedContentDir = resolveExistingPath(contentDir);
-  const manifestPath = import_node_path7.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestPath = import_node_path8.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
   const manifestStat = (0, import_node_fs5.existsSync)(manifestPath) ? (0, import_node_fs5.statSync)(manifestPath) : null;
   const signature = manifestStat ? `file:${manifestStat.mtimeMs}:${manifestStat.size}` : "generated";
   const cached = manifestCache.get(resolvedContentDir);
@@ -17603,21 +17899,21 @@ function resolveFarmDocsPageLastModified(contentDir, sourcePath, frontmatter) {
   if (configured) return configured;
   const resolvedContentDir = resolveExistingPath(contentDir);
   const resolvedSourcePath = resolveExistingPath(sourcePath);
-  const relativePath2 = normalizeRelativePath(import_node_path7.default.relative(resolvedContentDir, resolvedSourcePath));
-  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path7.default.isAbsolute(relativePath2);
+  const relativePath2 = normalizeRelativePath(import_node_path8.default.relative(resolvedContentDir, resolvedSourcePath));
+  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path8.default.isAbsolute(relativePath2);
   if (isInsideContentDir) {
     const generated = getLastModifiedManifest(resolvedContentDir).pages[relativePath2];
     if (generated) return generated;
   }
   return (0, import_node_fs5.statSync)(resolvedSourcePath).mtime.toISOString();
 }
-var import_node_child_process, import_node_fs5, import_node_path7, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
+var import_node_child_process, import_node_fs5, import_node_path8, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
 var init_last_modified = __esm({
   "src/docs/last-modified.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     import_node_fs5 = require("fs");
-    import_node_path7 = __toESM(require("path"));
+    import_node_path8 = __toESM(require("path"));
     FARM_DOCS_LAST_MODIFIED_MANIFEST = ".farm-docs-last-modified.json";
     COMMIT_MARKER = "__FARM_DOCS_COMMIT__";
     DOCS_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx"]);
@@ -18055,8 +18351,8 @@ code:not(pre code) {
 }
 
 .code-block-header {
-  min-height: 28px;
-  padding: 3px 7px 3px 9px;
+  min-height: 34px;
+  padding: 4px 8px 4px 10px;
 }
 
 .code-block-title {
@@ -18270,8 +18566,8 @@ code:not(pre code) {
   }
 
   .code-block-header {
-    min-height: 26px;
-    padding: 2px 6px 2px 8px;
+    min-height: 32px;
+    padding: 3px 7px 3px 9px;
   }
 
   .code-copy-floating {
@@ -18311,38 +18607,30 @@ code:not(pre code) {
 
 @media (max-width: 640px) {
   .code-block-header {
-    min-height: 22px;
-    padding: 1px 4px 1px 7px;
-  }
-
-  .code-block-title {
-    font-size: 9px;
-  }
-
-  .code-copy {
-    width: 20px;
-    height: 20px;
-  }
-
-  .code-copy svg {
-    width: 12px;
-    height: 12px;
+    min-height: 30px;
+    padding: 3px 6px 3px 8px;
   }
 
   .code-copy-floating {
-    top: 5px;
-    right: 5px;
+    top: 7px;
+    right: 7px;
   }
 
   #nd-docs-layout figure.shiki.code-block pre,
   .code-block pre {
-    padding: 10px !important;
-    font-size: 11px;
-    line-height: 1.55;
+    padding: 12px !important;
+    font-size: 12px;
+    line-height: 1.6;
+  }
+
+  #nd-docs-layout figure.shiki.code-block-plain pre,
+  .code-block-plain pre {
+    padding: 16px 44px 16px 14px !important;
+    line-height: 1.65;
   }
 
   .sh__line {
-    min-height: 1.55em;
+    min-height: 1.6em;
   }
 }
 
@@ -18929,9 +19217,9 @@ function isFarmDocsSearchEnabled(docs) {
 }
 function resolveFarmDocsSearchClientModule(root) {
   try {
-    const requireFromApp = (0, import_node_module2.createRequire)(import_node_path8.default.join(import_node_path8.default.resolve(root), "package.json"));
+    const requireFromApp = (0, import_node_module3.createRequire)(import_node_path9.default.join(import_node_path9.default.resolve(root), "package.json"));
     const themeEntry = requireFromApp.resolve("@farming-labs/theme");
-    const commandSearchModule = import_node_path8.default.join(import_node_path8.default.dirname(themeEntry), "docs-command-search.mjs");
+    const commandSearchModule = import_node_path9.default.join(import_node_path9.default.dirname(themeEntry), "docs-command-search.mjs");
     if ((0, import_node_fs6.existsSync)(commandSearchModule)) return commandSearchModule;
   } catch {
   }
@@ -19071,13 +19359,13 @@ async function mountFarmDocsSearch() {
 window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
 `;
 }
-var import_node_fs6, import_node_module2, import_node_path8;
+var import_node_fs6, import_node_module3, import_node_path9;
 var init_search_client = __esm({
   "src/docs/search-client.ts"() {
     "use strict";
     import_node_fs6 = require("fs");
-    import_node_module2 = require("module");
-    import_node_path8 = __toESM(require("path"));
+    import_node_module3 = require("module");
+    import_node_path9 = __toESM(require("path"));
     __name(isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
     __name(resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
     __name(generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
@@ -19101,9 +19389,9 @@ function resolveFarmDocsFavicon(docs, options) {
   if (typeof configuredFavicon === "string" && configuredFavicon.trim()) {
     return configuredFavicon.trim();
   }
-  const publicDir = import_node_path9.default.join(import_node_path9.default.resolve(options.root), "public");
+  const publicDir = import_node_path10.default.join(import_node_path10.default.resolve(options.root), "public");
   for (const fileName of FARM_DOCS_FAVICON_FILES) {
-    const faviconPath = import_node_path9.default.join(publicDir, fileName);
+    const faviconPath = import_node_path10.default.join(publicDir, fileName);
     if ((0, import_node_fs7.existsSync)(faviconPath) && (0, import_node_fs7.statSync)(faviconPath).isFile()) {
       return `/${fileName}`;
     }
@@ -19138,10 +19426,10 @@ function isSafeSegment(segment) {
   return segment !== ".." && !segment.includes("/") && !segment.includes("\\");
 }
 function resolveInside(root, target) {
-  const resolvedRoot = import_node_path9.default.resolve(root);
-  const resolvedTarget = import_node_path9.default.resolve(target);
-  const relative4 = import_node_path9.default.relative(resolvedRoot, resolvedTarget);
-  if (relative4 === "" || !relative4.startsWith("..") && !import_node_path9.default.isAbsolute(relative4)) {
+  const resolvedRoot = import_node_path10.default.resolve(root);
+  const resolvedTarget = import_node_path10.default.resolve(target);
+  const relative4 = import_node_path10.default.relative(resolvedRoot, resolvedTarget);
+  if (relative4 === "" || !relative4.startsWith("..") && !import_node_path10.default.isAbsolute(relative4)) {
     return resolvedTarget;
   }
   return null;
@@ -19155,16 +19443,16 @@ function isFarmDocsRequest(docs, request) {
   return pathname === entry || pathname === `${entry}.md` || pathname.startsWith(`${entry}/`);
 }
 function resolveFarmDocsContentDir(docs, options) {
-  const root = import_node_path9.default.resolve(options.root);
+  const root = import_node_path10.default.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const configuredContentDir = docs.contentDir || docs.config.contentDir;
   if (configuredContentDir) {
-    return import_node_path9.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path9.default.join(root, configuredContentDir);
+    return import_node_path10.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path10.default.join(root, configuredContentDir);
   }
   const entryDir = docs.config.entry || trimSlashes2(docs.entry) || "docs";
-  const appDocsDir = import_node_path9.default.join(root, srcDir, "app", entryDir);
+  const appDocsDir = import_node_path10.default.join(root, srcDir, "app", entryDir);
   if ((0, import_node_fs7.existsSync)(appDocsDir)) return appDocsDir;
-  return import_node_path9.default.join(root, entryDir);
+  return import_node_path10.default.join(root, entryDir);
 }
 function getFarmDocsRouteTypeEntries(docs) {
   if (!docs?.enabled) return [];
@@ -19187,10 +19475,10 @@ function getRequestSlug(docs, request) {
 function findDocsPageFile(contentDir, slug) {
   const segments = slug ? slug.split("/").filter(Boolean) : [];
   if (!segments.every(isSafeSegment)) return null;
-  const slugDir = import_node_path9.default.join(contentDir, ...segments);
-  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path9.default.join(contentDir, filename)) : [
-    ...DOCS_FILE_NAMES.map((filename) => import_node_path9.default.join(slugDir, filename)),
-    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path9.default.join(contentDir, `${slug}${extension}`))
+  const slugDir = import_node_path10.default.join(contentDir, ...segments);
+  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path10.default.join(contentDir, filename)) : [
+    ...DOCS_FILE_NAMES.map((filename) => import_node_path10.default.join(slugDir, filename)),
+    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path10.default.join(contentDir, `${slug}${extension}`))
   ];
   for (const candidate of candidates) {
     const safePath = resolveInside(contentDir, candidate);
@@ -19251,9 +19539,9 @@ function createDocsHref(entry, slug) {
   return normalizedSlug ? `${normalizedEntry}/${normalizedSlug}` : normalizedEntry;
 }
 function pathToSlug(contentDir, filePath) {
-  const relative4 = import_node_path9.default.relative(contentDir, filePath).replace(/\\/g, "/");
+  const relative4 = import_node_path10.default.relative(contentDir, filePath).replace(/\\/g, "/");
   if (relative4.startsWith("..")) return null;
-  const extension = import_node_path9.default.extname(relative4);
+  const extension = import_node_path10.default.extname(relative4);
   if (!DOCS_FILE_EXTENSIONS2.includes(extension)) return null;
   const withoutExtension = relative4.slice(0, -extension.length);
   if (withoutExtension === "page" || withoutExtension === "index") return "";
@@ -19271,7 +19559,7 @@ function discoverFarmDocsPages(contentDir, docs) {
   const visit = /* @__PURE__ */ __name((dir) => {
     for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path9.default.join(dir, entry.name);
+      const absolutePath = import_node_path10.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
         continue;
@@ -20110,13 +20398,13 @@ ${renderDocsHashRuntimeScript()}
 ${renderDocsPageActionsRuntimeScript()}`;
 }
 function readCssWithImports(filePath, seen = /* @__PURE__ */ new Set()) {
-  const resolved = import_node_path9.default.resolve(filePath);
+  const resolved = import_node_path10.default.resolve(filePath);
   if (seen.has(resolved)) return "";
   seen.add(resolved);
   const source = (0, import_node_fs7.readFileSync)(resolved, "utf8");
   return source.replace(/@import\s+["']([^"']+)["'];?/g, (_match, importPath) => {
     try {
-      const importedPath = importPath.startsWith(".") ? import_node_path9.default.resolve(import_node_path9.default.dirname(resolved), importPath) : (0, import_node_module3.createRequire)(resolved).resolve(importPath);
+      const importedPath = importPath.startsWith(".") ? import_node_path10.default.resolve(import_node_path10.default.dirname(resolved), importPath) : (0, import_node_module4.createRequire)(resolved).resolve(importPath);
       return readCssWithImports(importedPath, seen);
     } catch {
       return "";
@@ -20124,13 +20412,13 @@ function readCssWithImports(filePath, seen = /* @__PURE__ */ new Set()) {
   });
 }
 function resolvePixelBorderThemeCss(options) {
-  const cacheKey = import_node_path9.default.resolve(options.root);
+  const cacheKey = import_node_path10.default.resolve(options.root);
   const cached = themeCssCache.get(cacheKey);
   if (cached !== void 0) return cached;
   try {
-    const requireFromApp = (0, import_node_module3.createRequire)(import_node_path9.default.join(cacheKey, "package.json"));
+    const requireFromApp = (0, import_node_module4.createRequire)(import_node_path10.default.join(cacheKey, "package.json"));
     const themeCssPath = requireFromApp.resolve("@farming-labs/theme/pixel-border/css");
-    const requireFromTheme = (0, import_node_module3.createRequire)(themeCssPath);
+    const requireFromTheme = (0, import_node_module4.createRequire)(themeCssPath);
     const fumadocsCssPath = requireFromTheme.resolve("fumadocs-ui/style.css");
     const css = `${readCssWithImports(fumadocsCssPath)}
 ${readCssWithImports(themeCssPath)}`;
@@ -20246,7 +20534,7 @@ function renderFarmDocsBridgeCss(docs) {
     .sh-code { --sh-class: #e5c07b; --sh-identifier: #c8ccd4; --sh-string: #98c379; --sh-keyword: #c678dd; --sh-comment: #5c6370; --sh-property: #e06c75; --sh-sign: #c8ccd4; --sh-space: inherit; }
     .code-block { --fd-code-header-bg: color-mix(in srgb, var(--color-fd-foreground, #fff) 5%, var(--color-fd-background, #000)); --fd-code-body-bg: color-mix(in srgb, var(--color-fd-foreground, #fff) 8%, var(--color-fd-background, #000)); position: relative; width: 100%; min-width: 0; max-width: 100%; margin: 20px 0; overflow: hidden; border: 1px solid var(--color-fd-border, hsl(0 0% 15%)); background: var(--color-fd-background, hsl(0 0% 2%)); box-shadow: 3px 3px 0 0 var(--color-fd-border, hsl(0 0% 15%)); font-family: var(--fd-docs-font-mono); }
     #nd-docs-layout figure.shiki.code-block { box-shadow: 3px 3px 0 0 var(--color-fd-border, hsl(0 0% 15%)) !important; }
-    .code-block-header { display: flex; align-items: center; justify-content: space-between; gap: 10px; min-width: 0; min-height: 30px; border-bottom: 1px solid var(--color-fd-border, hsl(0 0% 15%)); background-color: var(--fd-code-header-bg); background-image: repeating-linear-gradient(-45deg, color-mix(in srgb, var(--color-fd-foreground, #fff) 7%, transparent), color-mix(in srgb, var(--color-fd-foreground, #fff) 7%, transparent) 1px, transparent 1px, transparent 6px); padding: 4px 8px 4px 10px; }
+    .code-block-header { display: flex; align-items: center; justify-content: space-between; gap: 10px; min-width: 0; min-height: 34px; border-bottom: 1px solid var(--color-fd-border, hsl(0 0% 15%)); background-color: var(--fd-code-header-bg); background-image: repeating-linear-gradient(-45deg, color-mix(in srgb, var(--color-fd-foreground, #fff) 4%, transparent), color-mix(in srgb, var(--color-fd-foreground, #fff) 4%, transparent) 1px, transparent 1px, transparent 6px); padding: 4px 8px 4px 10px; }
     .code-block-title { overflow: hidden; color: color-mix(in srgb, var(--color-fd-foreground, #fff) 50%, transparent); font-size: 10px; line-height: 1.2; text-overflow: ellipsis; text-transform: lowercase; white-space: nowrap; }
     .code-copy { display: inline-flex; align-items: center; justify-content: center; width: 22px; height: 22px; flex: 0 0 auto; border: 1px solid var(--color-fd-border, hsl(0 0% 15%)); background: color-mix(in srgb, var(--color-fd-background, #000) 80%, transparent); color: var(--color-fd-muted-foreground, hsl(0 0% 55%)); cursor: pointer; padding: 0; }
     .code-copy-floating { position: absolute; top: 8px; right: 8px; z-index: 2; opacity: 0.72; transition: opacity 150ms ease; }
@@ -20314,7 +20602,7 @@ function renderFarmDocsBridgeCss(docs) {
       .prose h2 { margin-top: 34px; padding-top: 22px; font-size: 23px; }
       .code-block { margin: 16px 0; box-shadow: 2px 2px 0 0 var(--color-fd-border, hsl(0 0% 15%)); }
       #nd-docs-layout figure.shiki.code-block { box-shadow: 2px 2px 0 0 var(--color-fd-border, hsl(0 0% 15%)) !important; }
-      .code-block-header { min-height: 26px; padding: 2px 6px 2px 8px; }
+      .code-block-header { min-height: 32px; padding: 3px 7px 3px 9px; }
       .code-copy-floating { top: 6px; right: 6px; }
       #nd-docs-layout figure.shiki.code-block pre, .code-block pre { padding: 12px 11px !important; font-size: 12px; line-height: 1.5; }
       .sh__line { min-height: 1.5em; }
@@ -20324,13 +20612,11 @@ function renderFarmDocsBridgeCss(docs) {
       .fd-page-footer .fd-last-updated-footer { margin-left: 0; }
     }
     @media (max-width: 640px) {
-      .code-block-header { min-height: 22px; padding: 1px 4px 1px 7px; }
-      .code-block-title { font-size: 9px; }
-      .code-copy { width: 20px; height: 20px; }
-      .code-copy svg { width: 12px; height: 12px; }
-      .code-copy-floating { top: 5px; right: 5px; }
-      #nd-docs-layout figure.shiki.code-block pre, .code-block pre { padding: 10px !important; font-size: 11px; line-height: 1.55; }
-      .sh__line { min-height: 1.55em; }
+      .code-block-header { min-height: 30px; padding: 3px 6px 3px 8px; }
+      .code-copy-floating { top: 7px; right: 7px; }
+      #nd-docs-layout figure.shiki.code-block pre, .code-block pre { padding: 12px !important; font-size: 12px; line-height: 1.6; }
+      #nd-docs-layout figure.shiki.code-block-plain pre, .code-block-plain pre { padding: 16px 44px 16px 14px !important; line-height: 1.65; }
+      .sh__line { min-height: 1.6em; }
     }
 ${farmDocsPixelBorderCss}
   `;
@@ -20449,13 +20735,13 @@ function createFarmDocsHandler(docs, options) {
     );
   }, "handleFarmDocsRequest");
 }
-var import_node_fs7, import_node_module3, import_node_path9, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, GEIST_SANS_FONT_URL, GEIST_MONO_FONT_URL, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER, themeCssCache;
+var import_node_fs7, import_node_module4, import_node_path10, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, GEIST_SANS_FONT_URL, GEIST_MONO_FONT_URL, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER, themeCssCache;
 var init_handler = __esm({
   "src/docs/handler.ts"() {
     "use strict";
     import_node_fs7 = require("fs");
-    import_node_module3 = require("module");
-    import_node_path9 = __toESM(require("path"));
+    import_node_module4 = require("module");
+    import_node_path10 = __toESM(require("path"));
     import_docs = require("@farming-labs/docs");
     import_marked = require("marked");
     import_sugar_high = require("sugar-high");
@@ -20790,18 +21076,18 @@ function sanitizeDocsConfig(config) {
   return cloneSerializable(config) || {};
 }
 async function findDocsConfigPath(rootDir, configPath) {
-  const { existsSync: existsSync14 } = await import("fs");
+  const { existsSync: existsSync15 } = await import("fs");
   const root = import_path9.default.resolve(rootDir || process.cwd());
   if (configPath) {
     const resolvedPath = import_path9.default.isAbsolute(configPath) ? configPath : import_path9.default.join(root, configPath);
-    if (!existsSync14(resolvedPath)) {
+    if (!existsSync15(resolvedPath)) {
       throw new Error(`Could not find docs config at ${configPath}.`);
     }
     return import_path9.default.resolve(resolvedPath);
   }
   for (const filename of DOCS_CONFIG_FILENAMES) {
     const resolvedPath = import_path9.default.join(root, filename);
-    if (existsSync14(resolvedPath)) {
+    if (existsSync15(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -20809,7 +21095,7 @@ async function findDocsConfigPath(rootDir, configPath) {
 }
 async function loadDocsConfig(rootDir, configPath) {
   const fs9 = await import("fs/promises");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const root = import_path9.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
@@ -20838,7 +21124,7 @@ async function loadDocsConfig(rootDir, configPath) {
       logLevel: "silent",
       sourcemap: "inline"
     });
-    const moduleUrl = pathToFileURL3(modulePath).href + `?t=${Date.now()}`;
+    const moduleUrl = pathToFileURL4(modulePath).href + `?t=${Date.now()}`;
     let importedConfig;
     try {
       importedConfig = await import(
@@ -20939,6 +21225,17 @@ async function resolveConfig(userConfig, mode) {
   const mdx = resolveMdxConfig(userConfig.mdx);
   const env2 = resolveEnv(userConfig.env, process.env);
   setEnv(env2);
+  const auth = resolveFarmAuthConfig(userConfig.auth);
+  if (auth.enabled && userConfig.integrations?.auth) {
+    throw new Error(
+      "Choose either the top-level `auth` config or `integrations.auth`; they cannot both own the auth route."
+    );
+  }
+  const nativeAuthIntegration = await resolveFarmAuthIntegration(auth, {
+    root,
+    mode
+  });
+  const integrations = nativeAuthIntegration ? { ...userConfig.integrations, auth: nativeAuthIntegration } : userConfig.integrations || {};
   const generateBuildId = userConfig.generateBuildId || (() => `build-${Date.now()}`);
   const deploymentId = normalizeFarmDeploymentId(
     userConfig.deploymentId || process.env.FARM_DEPLOYMENT_ID || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CF_PAGES_COMMIT_SHA || (mode === "production" ? await generateBuildId() : "development")
@@ -20963,14 +21260,15 @@ async function resolveConfig(userConfig, mode) {
     devtools: resolveFarmDevtoolsConfig(userConfig.devtools, mode),
     storage: userConfig.storage || {},
     cache: userConfig.cache || {},
+    auth,
     suppressLintOnLink: userConfig.suppressLintOnLink ?? false,
     experimental: {
       serverComponents: false,
       serverActions: false,
       ...userConfig.experimental
     },
-    plugins: [...resolveIntegrationPlugins(userConfig.integrations), ...userConfig.plugins || []],
-    integrations: userConfig.integrations || {},
+    plugins: [...resolveIntegrationPlugins(integrations), ...userConfig.plugins || []],
+    integrations,
     trailingSlash: userConfig.trailingSlash ?? false,
     redirects: /* @__PURE__ */ __name(() => [...redirects, ...routeRuleRedirects], "redirects"),
     rewrites: /* @__PURE__ */ __name(() => rewrites, "rewrites"),
@@ -21015,7 +21313,7 @@ async function resolveConfig(userConfig, mode) {
   return resolved;
 }
 async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
-  const { existsSync: existsSync14 } = await import("fs");
+  const { existsSync: existsSync15 } = await import("fs");
   const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
   const root = rootDir || process.cwd();
   const loadedEnv = loadEnv(mode, root, "");
@@ -21039,7 +21337,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
     try {
       const absolutePath = relativePath2.startsWith("/") ? relativePath2 : import_path9.default.join(root, relativePath2);
       const normalizedPath = import_path9.default.resolve(absolutePath);
-      if (!existsSync14(normalizedPath)) {
+      if (!existsSync15(normalizedPath)) {
         continue;
       }
       const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
@@ -21069,6 +21367,7 @@ var init_config2 = __esm({
     init_devtools_config();
     init_image_config();
     init_config();
+    init_auth_config();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(hasCustomFarmRouteContext, "hasCustomFarmRouteContext");
@@ -21867,8 +22166,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route2);
         }
-        for (const [path28, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path28);
+        for (const [path29, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path29);
           spec.paths[openAPIPath] = {};
           for (const route2 of routeList) {
             for (const method of route2.methods) {
@@ -21882,8 +22181,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path28) {
-        return path28.replace(/^\/api/, "");
+      convertToOpenAPIPath(path29) {
+        return path29.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -22045,8 +22344,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path28, method) {
-        const cleanPath = path28.replace(/^\/api\//, "");
+      generateSummary(path29, method) {
+        const cleanPath = path29.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         const lastPart = pathParts[pathParts.length - 1];
         const action = method === "GET" ? "Get" : method === "POST" ? "Create" : method === "PUT" ? "Update" : method === "DELETE" ? "Delete" : method === "PATCH" ? "Update" : method;
@@ -22055,22 +22354,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path28, method) {
-        const cleanPath = path28.replace(/^\/api\//, "");
+      generateDescription(path29, method) {
+        const cleanPath = path29.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path28, method) {
-        const cleanPath = path28.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path29, method) {
+        const cleanPath = path29.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path28) {
-        const cleanPath = path28.replace(/^\/api\//, "");
+      generateTags(path29) {
+        const cleanPath = path29.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -22083,8 +22382,8 @@ var init_generator = __esm({
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
         const fs9 = require("fs");
-        const path28 = require("path");
-        const dir = path28.dirname(outputPath);
+        const path29 = require("path");
+        const dir = path29.dirname(outputPath);
         if (!fs9.existsSync(dir)) {
           fs9.mkdirSync(dir, { recursive: true });
         }
@@ -22504,7 +22803,7 @@ async function createFarmDevtoolsSnapshot(input) {
     generatedAt: (input.now?.() || /* @__PURE__ */ new Date()).toISOString(),
     health: resolveHealth(diagnostics),
     project: {
-      name: import_node_path10.default.basename(import_node_path10.default.resolve(input.root)),
+      name: import_node_path11.default.basename(import_node_path11.default.resolve(input.root)),
       root: input.root,
       srcDir: input.srcDir,
       basePath: config.basePath || "/",
@@ -22553,11 +22852,11 @@ async function createFarmDevtoolsSnapshot(input) {
     diagnostics
   };
 }
-var import_node_path10;
+var import_node_path11;
 var init_devtools = __esm({
   "src/devtools.ts"() {
     "use strict";
-    import_node_path10 = __toESM(require("path"));
+    import_node_path11 = __toESM(require("path"));
     init_config2();
     init_cron();
     init_route_runtime();
@@ -24381,7 +24680,7 @@ function fileContainsProgrammaticPageRoute(file) {
 }
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path21.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path22.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -24401,7 +24700,7 @@ function rewriteEarlySsrRelativeImports(options) {
     const suffixIndex = source.value.search(/[?#]/);
     const sourcePath = suffixIndex === -1 ? source.value : source.value.slice(0, suffixIndex);
     const suffix = suffixIndex === -1 ? "" : source.value.slice(suffixIndex);
-    const resolvedPath = path21.resolve(path21.dirname(cleanId), sourcePath);
+    const resolvedPath = path22.resolve(path22.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -24477,7 +24776,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path21.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path22.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -24502,9 +24801,9 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path21.join(server.config.root, "src/app/globals.css");
+      const globalsCSSPath = path22.join(server.config.root, "src/app/globals.css");
       if (!fs7.existsSync(globalsCSSPath)) {
-        const appDir = path21.join(server.config.root, "src/app");
+        const appDir = path22.join(server.config.root, "src/app");
         if (!fs7.existsSync(appDir)) {
           fs7.mkdirSync(appDir, { recursive: true });
         }
@@ -24526,10 +24825,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path21.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path22.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path21.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path22.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -24539,7 +24838,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path21.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path22.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -24579,7 +24878,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path21.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path22.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -24697,7 +24996,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs7.existsSync(path21.isAbsolute(dir) ? dir : path21.join(farmConfig.root, dir))
+        (dir) => fs7.existsSync(path22.isAbsolute(dir) ? dir : path22.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -24775,14 +25074,14 @@ function farmPlugin(options = {}, initialPluginManager) {
         farmDocsDevRuntime ? [
           [
             "/assets/Geist-Variable-CrgPqtmy.woff2",
-            path21.join(
+            path22.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2"
             )
           ],
           [
             "/assets/GeistMono-Variable-BNLlm6Cd.woff2",
-            path21.join(
+            path22.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
             )
@@ -24946,12 +25245,13 @@ function farmPlugin(options = {}, initialPluginManager) {
             config: farmApp.getConfig().mdx,
             resolveSource: /* @__PURE__ */ __name(async (pathname2) => {
               const match = farmApp.getRouteManager().matchRoute(pathname2);
-              if (!match.route || !isFarmMarkdownPageFile(match.route.modulePath)) {
+              const sourcePath = match.route?.markdownSourcePath || (match.route && isFarmMarkdownPageFile(match.route.modulePath) ? match.route.modulePath : null);
+              if (!sourcePath) {
                 return null;
               }
               return {
-                source: await fs7.promises.readFile(match.route.modulePath, "utf8"),
-                filePath: match.route.modulePath
+                source: await fs7.promises.readFile(sourcePath, "utf8"),
+                filePath: sourcePath
               };
             }, "resolveSource")
           });
@@ -24972,16 +25272,37 @@ function farmPlugin(options = {}, initialPluginManager) {
             await sendWebResponse(res, markdownResponse);
             return;
           }
+          const markdownPageTarget = resolveMarkdownMirrorTarget(
+            farmApp.getConfig().md,
+            requestPathname,
+            {
+              accept: "text/markdown"
+            }
+          );
+          if (markdownPageTarget && farmApp.getRouteManager().matchRoute(markdownPageTarget.pathname).route) {
+            const vary = res.getHeader("Vary");
+            const varyValues = String(vary || "").split(",").map((value) => value.trim()).filter(Boolean);
+            if (!varyValues.some((value) => value.toLowerCase() === "accept")) {
+              res.setHeader("Vary", [...varyValues, "Accept"].join(", "));
+            }
+            const alternatePath = markdownPageTarget.pathname === "/" ? "/index.md" : `${markdownPageTarget.pathname}.md`;
+            const alternateLink = `<${alternatePath}>; rel="alternate"; type="text/markdown"`;
+            const currentLink = res.getHeader("Link");
+            res.setHeader(
+              "Link",
+              currentLink ? `${String(currentLink)}, ${alternateLink}` : alternateLink
+            );
+          }
           if (workflowHandler && (requestPathname === workflowConfig.route || requestPathname.startsWith(`${workflowConfig.route}/`))) {
             let workflowBody;
             if (requestMethod !== "GET" && requestMethod !== "HEAD") {
-              workflowBody = await new Promise((resolve5) => {
+              workflowBody = await new Promise((resolve6) => {
                 let data = "";
                 req.on("data", (chunk) => {
                   data += chunk;
                 });
                 req.on("end", () => {
-                  resolve5(data);
+                  resolve6(data);
                 });
               });
             }
@@ -25024,13 +25345,13 @@ function farmPlugin(options = {}, initialPluginManager) {
               }
               let body;
               if (req.method !== "GET" && req.method !== "HEAD") {
-                body = await new Promise((resolve5) => {
+                body = await new Promise((resolve6) => {
                   let data = "";
                   req.on("data", (chunk) => {
                     data += chunk;
                   });
                   req.on("end", () => {
-                    resolve5(data);
+                    resolve6(data);
                   });
                 });
               }
@@ -25136,13 +25457,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve5) => {
+                  body = await new Promise((resolve6) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve5(data);
+                      resolve6(data);
                     });
                   });
                 }
@@ -25199,13 +25520,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve5) => {
+                  body = await new Promise((resolve6) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve5(data);
+                      resolve6(data);
                     });
                   });
                 }
@@ -25925,8 +26246,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path21.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path21.join(outDir, "client");
+        const outDir = path22.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path22.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -25978,8 +26299,8 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page2.urlPath === "/" ? path21.join(clientDir, "index.html") : path21.join(clientDir, page2.urlPath + ".html");
-              fs7.mkdirSync(path21.dirname(outputPath), { recursive: true });
+              const outputPath = page2.urlPath === "/" ? path22.join(clientDir, "index.html") : path22.join(clientDir, page2.urlPath + ".html");
+              fs7.mkdirSync(path22.dirname(outputPath), { recursive: true });
               fs7.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
@@ -25988,7 +26309,7 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path21.join(outDir, "__ssg_manifest.json");
+        const manifestPath = path22.join(outDir, "__ssg_manifest.json");
         fs7.writeFileSync(
           manifestPath,
           JSON.stringify(
@@ -26024,9 +26345,9 @@ if (import.meta.hot) {
       }
       const currentFarmConfig = farmApp?.getConfig();
       const normalizedFile = file.replace(/\\/g, "/");
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path21.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path22.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path21.basename(file)}`);
+        logUpdate("PAGE", `updated ${path22.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -27063,6 +27384,7 @@ async function buildRouteComponentProps(pageModule, params, searchParams, path,
   const parsedSearch = parseClientRouteSchema(schemas?.search, searchParams, 'search');
 
   return {
+    ...(existingProps || {}),
     params: parsedParams,
     search: parsedSearch,
     searchParams: schemas ? Promise.resolve(parsedSearch) : parsedSearch,
@@ -27576,7 +27898,7 @@ function generateClientManifest(bundle) {
 }
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path21.resolve(config.root || process.cwd());
+  const appRoot = path22.resolve(config.root || process.cwd());
   if (config.extends?.length) {
     const { config: layeredConfig } = await Promise.resolve().then(() => (init_layers(), layers_exports)).then(
       ({ resolveFarmLayers: resolveFarmLayers2 }) => resolveFarmLayers2(config, {
@@ -27762,7 +28084,7 @@ async function defineConfig2(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path21.resolve(appRoot, "src"),
+        "@": path22.resolve(appRoot, "src"),
         // Nitro internals that should not be resolved in browser
         "supports-color": "data:text/javascript,export default false; export const supportsColor = false; export const stdout = false; export const stderr = false;",
         "@poppinss/dumper": "data:text/javascript,export default {};",
@@ -27779,7 +28101,7 @@ async function defineConfig2(config = {}) {
     }
   };
 }
-var fs7, path21, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
+var fs7, path22, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
 var init_vite = __esm({
   "src/vite.ts"() {
     "use strict";
@@ -27800,7 +28122,7 @@ var init_vite = __esm({
     init_route_context();
     init_devtools_config();
     fs7 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    path22 = __toESM(require("path"));
     init_layers();
     init_environment_vite();
     init_version();
@@ -27816,7 +28138,7 @@ var init_vite = __esm({
       routes: true,
       api: true,
       env: true,
-      images: true,
+      images: false,
       i18n: true
     };
     createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -29233,6 +29555,7 @@ __export(src_exports, {
   applyFarmCacheInvalidations: () => applyFarmCacheInvalidations,
   applyFarmCronVercelCrons: () => applyFarmCronVercelCrons,
   applyFarmWorkflowVercelCrons: () => applyFarmWorkflowVercelCrons,
+  applyMarkdownNegotiationHeaders: () => applyMarkdownNegotiationHeaders,
   applyProductionMiddlewareHeaders: () => applyProductionMiddlewareHeaders,
   asArrayOf: () => asArrayOf,
   asBoolean: () => asBoolean,
@@ -29259,6 +29582,7 @@ __export(src_exports, {
   createDocsAPI: () => createDocsAPI,
   createEndpoint: () => createEndpoint,
   createEnvPlugin: () => createEnvPlugin,
+  createEnvTypeDeclarations: () => createEnvTypeDeclarations,
   createFarmApp: () => createFarmApp,
   createFarmCacheKey: () => createFarmCacheKey,
   createFarmCronCloudflareConfig: () => createFarmCronCloudflareConfig,
@@ -29484,6 +29808,7 @@ __export(src_exports, {
   redirect: () => redirect2,
   redisStorage: () => redisStorage,
   replaceState: () => replaceState,
+  requestAcceptsMarkdown: () => requestAcceptsMarkdown,
   resetFarmObservability: () => resetFarmObservability,
   resolveAppPath: () => resolveAppPath,
   resolveConfig: () => resolveConfig,
@@ -30745,8 +31070,8 @@ function createAPIClient(options = {}) {
   const inflightState = /* @__PURE__ */ new Map();
   const routeMeta = /* @__PURE__ */ new WeakMap();
   let requestCounter = 0;
-  const fetchClient = /* @__PURE__ */ __name(async (path28, requestOptions = {}) => {
-    const url = new URL(path28, baseURL);
+  const fetchClient = /* @__PURE__ */ __name(async (path29, requestOptions = {}) => {
+    const url = new URL(path29, baseURL);
     if (requestOptions.query) {
       Object.entries(requestOptions.query).forEach(([key, value]) => {
         if (value !== void 0 && value !== null) {
@@ -30781,7 +31106,7 @@ function createAPIClient(options = {}) {
     }
     return { response, data };
   }, "fetchClient");
-  const request = /* @__PURE__ */ __name(async (path28, method, input = {}, clientOptions) => {
+  const request = /* @__PURE__ */ __name(async (path29, method, input = {}, clientOptions) => {
     const methodUpper = method.toUpperCase();
     const requestId = `${Date.now()}-${++requestCounter}`;
     const cacheOptions = clientOptions?.cache ? {
@@ -30790,7 +31115,7 @@ function createAPIClient(options = {}) {
     } : void 0;
     const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
     const cacheKey = normalizeFarmClientCacheKey(
-      configuredCacheKey ?? buildCacheKey(methodUpper, path28, input, baseURL)
+      configuredCacheKey ?? buildCacheKey(methodUpper, path29, input, baseURL)
     );
     const now2 = Date.now();
     const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
@@ -30872,13 +31197,13 @@ function createAPIClient(options = {}) {
             requestId,
             method: methodUpper,
             key: cacheKey,
-            path: path28,
+            path: path29,
             input,
             attempt,
             timestamp: Date.now()
           });
           try {
-            const { response, data } = await fetchClient(path28, {
+            const { response, data } = await fetchClient(path29, {
               ...input,
               method: methodUpper
             });
@@ -30887,7 +31212,7 @@ function createAPIClient(options = {}) {
               requestId,
               method: methodUpper,
               key: cacheKey,
-              path: path28,
+              path: path29,
               input,
               attempt,
               timestamp: Date.now(),
@@ -30910,7 +31235,7 @@ function createAPIClient(options = {}) {
               requestId,
               method: methodUpper,
               key: cacheKey,
-              path: path28,
+              path: path29,
               input,
               attempt,
               timestamp: Date.now(),
@@ -30925,7 +31250,7 @@ function createAPIClient(options = {}) {
           attempt += 1;
           const delay2 = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
           if (delay2 > 0) {
-            await new Promise((resolve5) => setTimeout(resolve5, delay2));
+            await new Promise((resolve6) => setTimeout(resolve6, delay2));
           }
         }
       })();
@@ -31015,17 +31340,17 @@ function createAPIClient(options = {}) {
   );
 }
 __name(createAPIClient, "createAPIClient");
-function createNestedProxy(path28, client, routeMeta, baseURL, sameOrigin, rootAliases) {
+function createNestedProxy(path29, client, routeMeta, baseURL, sameOrigin, rootAliases) {
   const target = /* @__PURE__ */ __name(() => {
   }, "target");
   const proxy = new Proxy(target, {
     // When accessing a property (api.hello)
     get(_target, prop) {
       if (prop === FARM_API_ROUTE_REF_SYMBOL) {
-        return path28.length > 0;
+        return path29.length > 0;
       }
       if (prop === FARM_API_ROUTE_META_SYMBOL) {
-        const metadata = resolveRouteMeta({ path: path28, baseURL });
+        const metadata = resolveRouteMeta({ path: path29, baseURL });
         return Object.freeze({
           path: metadata.routePath,
           method: metadata.method,
@@ -31033,14 +31358,14 @@ function createNestedProxy(path28, client, routeMeta, baseURL, sameOrigin, rootA
           sameOrigin
         });
       }
-      if (path28.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
+      if (path29.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
         return rootAliases[prop];
       }
       if (typeof prop !== "string") {
         return Reflect.get(_target, prop);
       }
       return createNestedProxy(
-        [...path28, prop],
+        [...path29, prop],
         client,
         routeMeta,
         baseURL,
@@ -31050,21 +31375,21 @@ function createNestedProxy(path28, client, routeMeta, baseURL, sameOrigin, rootA
     },
     // When calling as a function
     apply(_target, _thisArg, args) {
-      const lastPart = path28[path28.length - 1];
+      const lastPart = path29[path29.length - 1];
       const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
       if (httpMethods.includes(lastPart)) {
-        const routePath = "/api/" + path28.slice(0, -1).join("/");
+        const routePath = "/api/" + path29.slice(0, -1).join("/");
         const method = lastPart.toUpperCase();
         const [options, clientOptions] = args;
         return client(routePath, method, options, clientOptions);
       } else {
-        const routePath = "/api/" + path28.join("/");
+        const routePath = "/api/" + path29.join("/");
         const [options, clientOptions] = args;
         return client(routePath, options?.method || "GET", options, clientOptions);
       }
     }
   });
-  routeMeta.set(proxy, { path: [...path28], baseURL });
+  routeMeta.set(proxy, { path: [...path29], baseURL });
   return proxy;
 }
 __name(createNestedProxy, "createNestedProxy");
@@ -31104,9 +31429,9 @@ function createServerAPIClient(endpoints, options = {}) {
   return endpoints;
 }
 __name(createServerAPIClient, "createServerAPIClient");
-function buildCacheKey(method, path28, input, baseURL) {
+function buildCacheKey(method, path29, input, baseURL) {
   const keyInput = input && typeof input === "object" ? { query: input.query, body: input.body } : input;
-  const url = new URL(path28, baseURL);
+  const url = new URL(path29, baseURL);
   return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
 }
 __name(buildCacheKey, "buildCacheKey");
@@ -31335,7 +31660,7 @@ function farmApiPlugin(options = {}) {
     configureServer(server) {
       const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
         const fs9 = await import("fs");
-        const path28 = await import("path");
+        const path29 = await import("path");
         if (!fs9.existsSync(apiDir)) {
           log("No api directory found");
           return;
@@ -31345,7 +31670,7 @@ function farmApiPlugin(options = {}) {
           if (!fs9.existsSync(dir)) return files;
           const entries = fs9.readdirSync(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path28.join(dir, entry.name);
+            const fullPath = path29.join(dir, entry.name);
             if (entry.isDirectory()) {
               files.push(...findRouteFiles(fullPath));
             } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
@@ -31358,7 +31683,7 @@ function farmApiPlugin(options = {}) {
         apiRoutesCache.clear();
         for (const filePath of routeFiles) {
           try {
-            const relativePath2 = path28.relative(apiDir, path28.dirname(filePath));
+            const relativePath2 = path29.relative(apiDir, path29.dirname(filePath));
             const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
             const routeModule = await server.ssrLoadModule(filePath);
             const endpoints = {};
@@ -31385,11 +31710,11 @@ function farmApiPlugin(options = {}) {
       }, "discoverFileRoutes");
       const discoverRootRoutes = /* @__PURE__ */ __name(async () => {
         const fs9 = await import("fs");
-        const path28 = await import("path");
+        const path29 = await import("path");
         const routesFiles = [
-          path28.join(server.config.root, srcDir, "routes.ts"),
-          path28.join(server.config.root, srcDir, "routes.tsx"),
-          path28.join(server.config.root, srcDir, "routes.js")
+          path29.join(server.config.root, srcDir, "routes.ts"),
+          path29.join(server.config.root, srcDir, "routes.tsx"),
+          path29.join(server.config.root, srcDir, "routes.js")
         ];
         for (const routesFile of routesFiles) {
           if (fs9.existsSync(routesFile)) {
@@ -31412,8 +31737,8 @@ function farmApiPlugin(options = {}) {
         }
       }, "discoverRootRoutes");
       const discoverProgrammaticRoutes = /* @__PURE__ */ __name(async () => {
-        const path28 = await import("path");
-        const srcRoot = path28.join(server.config.root, srcDir);
+        const path29 = await import("path");
+        const srcRoot = path29.join(server.config.root, srcDir);
         const routeFiles = findProgrammaticRouteFilesInDir(srcRoot);
         for (const routeFile of routeFiles) {
           try {
@@ -31437,8 +31762,8 @@ function farmApiPlugin(options = {}) {
         }
       }, "discoverProgrammaticRoutes");
       const initializeDiscovery = /* @__PURE__ */ __name(async () => {
-        const path28 = await import("path");
-        const apiDir = path28.join(server.config.root, srcDir, "api");
+        const path29 = await import("path");
+        const apiDir = path29.join(server.config.root, srcDir, "api");
         log(`Discovering API routes in: ${apiDir}`);
         await discoverFileRoutes(apiDir);
         await discoverRootRoutes();
@@ -31493,13 +31818,13 @@ function farmApiPlugin(options = {}) {
               }
               let body;
               if (method !== "GET" && method !== "HEAD") {
-                body = await new Promise((resolve5) => {
+                body = await new Promise((resolve6) => {
                   let data = "";
                   req.on("data", (chunk) => {
                     data += chunk;
                   });
                   req.on("end", () => {
-                    resolve5(data);
+                    resolve6(data);
                   });
                 });
               }
@@ -31606,9 +31931,9 @@ function farmApiPlugin(options = {}) {
           }
         } else {
           try {
-            const path28 = await import("path");
-            const apiDir = path28.join(server.config.root, srcDir, "api");
-            const relativePath2 = path28.relative(apiDir, path28.dirname(file));
+            const path29 = await import("path");
+            const apiDir = path29.join(server.config.root, srcDir, "api");
+            const relativePath2 = path29.relative(apiDir, path29.dirname(file));
             const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
             const routeModule = await server.ssrLoadModule(file);
             const endpoints = {};
@@ -31994,8 +32319,8 @@ var _MiddlewareChainImpl = class _MiddlewareChainImpl {
   /**
    * Set the base path for this middleware chain (called by manager when loading)
    */
-  setBasePath(path28) {
-    this.basePath = path28 === "/" ? "/" : path28.endsWith("/") ? path28.slice(0, -1) : path28;
+  setBasePath(path29) {
+    this.basePath = path29 === "/" ? "/" : path29.endsWith("/") ? path29.slice(0, -1) : path29;
   }
   use(fn) {
     this.handlers.push(fn);
@@ -32816,11 +33141,11 @@ __name(applyProductionMiddlewareHeaders, "applyProductionMiddlewareHeaders");
 
 // src/middleware/vite-plugin.ts
 var import_node_fs8 = __toESM(require("fs"));
-var import_node_path11 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 init_manager();
 function getMiddlewareAppDirectory(root, srcDir) {
-  const sourceDirectory = import_node_path11.default.join(root, srcDir);
-  const appDirectory = import_node_path11.default.join(sourceDirectory, "app");
+  const sourceDirectory = import_node_path12.default.join(root, srcDir);
+  const appDirectory = import_node_path12.default.join(sourceDirectory, "app");
   return import_node_fs8.default.existsSync(appDirectory) ? appDirectory : sourceDirectory;
 }
 __name(getMiddlewareAppDirectory, "getMiddlewareAppDirectory");
@@ -32866,7 +33191,7 @@ function farmMiddlewarePlugin(options = {}) {
       };
     },
     async handleHotUpdate({ file, server, modules }) {
-      if (!/^middleware\.[tj]sx?$/.test(import_node_path11.default.basename(file))) {
+      if (!/^middleware\.[tj]sx?$/.test(import_node_path12.default.basename(file))) {
         return;
       }
       for (const module2 of modules) {
@@ -34398,10 +34723,14 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     const routeRuntimeManifestResultPromise = Promise.allSettled([routeRuntimeManifestPromise]);
     const pageRoutes = [];
     for (const [pattern, entry] of routeManager.getRoutes()) {
+      const markdownSourcePath = entry.markdownSourcePath || (isFarmMarkdownPageFile(entry.modulePath) ? entry.modulePath : void 0);
       pageRoutes.push({
         pattern,
         modulePath: entry.modulePath,
-        ...isFarmMarkdownPageFile(entry.modulePath) ? { source: (0, import_fs5.readFileSync)(entry.modulePath, "utf8") } : {}
+        ...markdownSourcePath ? {
+          source: (0, import_fs5.readFileSync)(markdownSourcePath, "utf8"),
+          markdownSourcePath
+        } : {}
       });
     }
     const routeSlots = Array.from(
@@ -36312,15 +36641,13 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   });
   const pageImports = [];
   const pageRegistrations = [];
-  const hasMarkdownPages = pageRoutes.some(
-    (route2) => route2.source !== void 0 || isFarmMarkdownPageFile(route2.modulePath)
-  );
+  const hasMarkdownPages = pageRoutes.some((route2) => route2.source !== void 0);
   const orderedPageRoutes = pageRoutes.map((route2, index) => ({ route: route2, index })).sort(
     (left, right) => routePatternSpecificity(right.route.pattern) - routePatternSpecificity(left.route.pattern) || left.index - right.index
   ).map(({ route: route2 }) => route2);
   orderedPageRoutes.forEach((route2, index) => {
     const varName = `pageRoute${index}`;
-    if (route2.source !== void 0 || isFarmMarkdownPageFile(route2.modulePath)) {
+    if (isFarmMarkdownPageFile(route2.modulePath)) {
       pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route2.pattern)},
@@ -36332,7 +36659,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
     }),
     markdownSource: {
       source: ${JSON.stringify(route2.source ?? "")},
-      filePath: ${JSON.stringify(route2.modulePath)},
+      filePath: ${JSON.stringify(route2.markdownSourcePath ?? route2.modulePath)},
     },
   }`);
       return;
@@ -36344,6 +36671,10 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
     pattern: ${JSON.stringify(route2.pattern)},
     module: ${varName},
     shouldHydrate: ${JSON.stringify(shouldHydrate)},
+    ${route2.source !== void 0 ? `markdownSource: {
+      source: ${JSON.stringify(route2.source)},
+      filePath: ${JSON.stringify(route2.markdownSourcePath)},
+    },` : ""}
   }`);
   });
   const layoutImports = [];
@@ -36449,7 +36780,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   const docsRuntimeImport = config.docs?.enabled ? `import { existsSync as farmDocsExistsSync } from "node:fs";
 import { dirname as farmDocsDirname, join as farmDocsJoin } from "node:path";
 import { fileURLToPath as farmDocsFileURLToPath } from "node:url";` : "";
-  const markdownHandlerImport = config.md?.enabled ? `import { createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
+  const markdownHandlerImport = config.md?.enabled ? `import { applyMarkdownNegotiationHeaders, createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
   const appMarkdownImport = hasMarkdownPages ? `import { createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse } from "@farm.js/core/app-markdown";` : "const createFarmMarkdownSourceResponse = null;";
   const mdxComponentsPath = typeof config.mdx?.components === "string" ? import_path12.default.isAbsolute(config.mdx.components) ? config.mdx.components : import_path12.default.join(config.root, config.mdx.components) : null;
   const mdxComponentsImport = mdxComponentsPath ? `import * as FarmMdxComponentsModule from "${mdxComponentsPath.replace(/\\/g, "/")}";` : "";
@@ -36699,10 +37030,12 @@ function serializeFarmInlineValue(value) {
     .replace(/\\u2029/g, "\\\\u2029");
 }
 
-function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots) {
+function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots, pageProps) {
   const integrationManifest = ${hasRuntimeIntegrationConfig ? "getRegisteredIntegrationAPIManifest()" : "{}"};
   const serializedRouteSlots = serializeFarmInlineValue(selectedRouteSlots || []);
-  let source = 'window.__FARM_INTEGRATION_API_MANIFEST__=' +
+  const serializedPageProps = serializeFarmInlineValue(pageProps || {});
+  let source = 'window.__FARM_PROPS__=' + serializedPageProps +
+    ';window.__FARM_INTEGRATION_API_MANIFEST__=' +
     serializeFarmInlineValue(integrationManifest) +
     ';window.__FARM_ROUTE_SLOTS__=' + serializedRouteSlots + ';';
   if (typeof canonicalPath === "string" && canonicalPath.startsWith("/")) {
@@ -37753,7 +38086,7 @@ async function getCachedPPRShell(cacheKey) {
  * Main request handler - created at runtime with bundled routes
  */
 async function handleFarmRequest(request) {
-  ${config.i18n.enabled ? `return _runWithFarmI18nRequest(
+  const response = await ${config.i18n.enabled ? `_runWithFarmI18nRequest(
     farmI18nRuntime,
     request,
     async function(farmLocaleResolution) {
@@ -37772,7 +38105,15 @@ async function handleFarmRequest(request) {
       const response = await handleFarmRequestInContext(request, farmLocaleResolution);
       return applyFarmI18nResponse(response, farmLocaleResolution);
     }
-  );` : "return handleFarmRequestInContext(request, null);"}
+  )` : "handleFarmRequestInContext(request, null)"};
+  ${config.md?.enabled ? `const pathname = getFarmRoutePathname(new URL(request.url).pathname);
+  if (matchPageRoute(pathname)) {
+    return applyMarkdownNegotiationHeaders(response, {
+      config: farmMarkdownConfig,
+      pathname,
+    });
+  }` : ""}
+  return response;
 }
 
 async function handleFarmRequestInContext(
@@ -38134,6 +38475,23 @@ async function handleFarmRequestInContext(
             return { ...slot, props: slotProps };
           }),
         );
+        const clientMiddleware = middlewareData?.size
+          ? { data: Object.fromEntries(middlewareData) }
+          : undefined;
+        const clientPageProps = {
+          params: pageProps.params,
+          search: pageProps.search ?? searchParamsObj,
+          searchParams: pageProps.search ?? searchParamsObj,
+          ...("data" in pageProps ? { data: pageProps.data } : {}),
+          ...(pageProps.__farmCanonicalPath
+            ? { __farmCanonicalPath: pageProps.__farmCanonicalPath }
+            : {}),
+          ...(pageProps.__farmRoutePropsResolved
+            ? { __farmRoutePropsResolved: true }
+            : {}),
+          path: pathname,
+          ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
+        };
         const routeSlotPayload = renderedRouteSlots.map(function(slot) {
           return {
             name: slot.name,
@@ -38148,6 +38506,7 @@ async function handleFarmRequestInContext(
               searchParams: slot.props.search || searchParamsObj,
               ...("data" in slot.props ? { data: slot.props.data } : {}),
               path: pathname,
+              ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
             },
           };
         });
@@ -38303,7 +38662,8 @@ async function handleFarmRequestInContext(
           const streamSuffix = '</div>\\n' +
             '  ' + renderFarmClientBootstrapScript(
               pageProps.__farmCanonicalPath,
-              routeSlotPayload
+              routeSlotPayload,
+              clientPageProps
             ) + '\\n' +
             '  <script type="module" src="/farm-client.js"></script>\\n' +
             '</body>\\n</html>';
@@ -38363,7 +38723,8 @@ async function handleFarmRequestInContext(
               /<\\/body>/i,
               '  ' + renderFarmClientBootstrapScript(
                 pageProps.__farmCanonicalPath,
-                routeSlotPayload
+                routeSlotPayload,
+                clientPageProps
               ) + '\\n' +
                 '  <script type="module" src="/farm-client.js"></script>\\n</body>',
             );
@@ -38385,7 +38746,7 @@ async function handleFarmRequestInContext(
 </head>
 <body>
   <div id="root">\${html}</div>
-  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload)}
+  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload, clientPageProps)}
   <script type="module" src="/farm-client.js"></script>
 </body>
 </html>\`;
@@ -41117,10 +41478,10 @@ var _FarmClientPluginManager = class _FarmClientPluginManager {
     if (session.signal.aborted) return Promise.resolve();
     const clientWindow = this.options.window;
     const schedule = clientWindow?.requestAnimationFrame ? (callback) => clientWindow.requestAnimationFrame(() => clientWindow.requestAnimationFrame(callback)) : (callback) => setTimeout(callback, 0);
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       schedule(() => {
         if (session.signal.aborted || this.closed) {
-          resolve5();
+          resolve6();
           return;
         }
         void this.runHook(
@@ -41134,7 +41495,7 @@ var _FarmClientPluginManager = class _FarmClientPluginManager {
           if (this.currentNavigation?.session === session) {
             this.currentNavigation = void 0;
           }
-          resolve5();
+          resolve6();
         });
       });
     });
@@ -41504,6 +41865,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   applyFarmCacheInvalidations,
   applyFarmCronVercelCrons,
   applyFarmWorkflowVercelCrons,
+  applyMarkdownNegotiationHeaders,
   applyProductionMiddlewareHeaders,
   asArrayOf,
   asBoolean,
@@ -41530,6 +41892,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   createDocsAPI,
   createEndpoint,
   createEnvPlugin,
+  createEnvTypeDeclarations,
   createFarmApp,
   createFarmCacheKey,
   createFarmCronCloudflareConfig,
@@ -41755,6 +42118,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   redirect,
   redisStorage,
   replaceState,
+  requestAcceptsMarkdown,
   resetFarmObservability,
   resolveAppPath,
   resolveConfig,