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

package/dist/plugin.cjs

@@ -222,178 +222,9 @@ var init_request_context = __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_path.default.isAbsolute(configured) ? configured : import_path.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_path, import_url;
-var init_app_markdown = __esm({
-  "src/app-markdown.ts"() {
-    "use strict";
-    import_react = __toESM(require("react"));
-    import_promises = require("fs/promises");
-    import_path = __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: [],
@@ -401,7 +232,7 @@ function resolveMarkdownConfig(config) {
       includeMetadata: true
     };
   }
-  if (config === true) {
+  if (config === true || config === void 0) {
     return {
       enabled: true,
       expose: true,
@@ -409,7 +240,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),
@@ -418,11 +249,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 route = findExposedMarkdownRoute(config, targetPathname);
   if (!route && config.expose !== true) {
     return null;
@@ -437,7 +271,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;
   }
@@ -465,8 +302,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, {
@@ -552,11 +393,24 @@ function normalizeMarkdownRouteInput(input) {
   };
 }
 function normalizeMarkdownRoute(route) {
-  const withoutMarkdownExtension = route.endsWith(".md") ? route.slice(0, -3) : route;
+  const withoutMarkdownExtension = route.toLowerCase().endsWith(".md") ? route.slice(0, -3) : route;
   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 findExposedMarkdownRoute(config, pathname) {
   if (config.expose === true) {
     return null;
@@ -647,6 +501,7 @@ var init_markdown = __esm({
     __name(htmlToMarkdown, "htmlToMarkdown");
     __name(normalizeMarkdownRouteInput, "normalizeMarkdownRouteInput");
     __name(normalizeMarkdownRoute, "normalizeMarkdownRoute");
+    __name(requestAcceptsMarkdown, "requestAcceptsMarkdown");
     __name(findExposedMarkdownRoute, "findExposedMarkdownRoute");
     __name(routeMatches, "routeMatches");
     __name(isHtmlResponse, "isHtmlResponse");
@@ -660,6 +515,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_path.default.isAbsolute(configured) ? configured : import_path.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 headers = 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) {
+    headers.set("Vary", "Accept");
+  }
+  return new Response(options.request.method === "HEAD" ? null : source.source, {
+    status: 200,
+    headers
+  });
+}
+var import_react, import_promises, import_path, import_url;
+var init_app_markdown = __esm({
+  "src/app-markdown.ts"() {
+    "use strict";
+    import_react = __toESM(require("react"));
+    import_promises = require("fs/promises");
+    import_path = __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, {
@@ -812,26 +843,26 @@ async function prepareFarmWorkflowsForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs8 = await import("fs/promises");
-  const path22 = await import("path");
-  const generatedDir = path22.join(root, distDir, ".nitro", "farm-workflows");
+  const path23 = await import("path");
+  const generatedDir = path23.join(root, distDir, ".nitro", "farm-workflows");
   await fs8.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path22.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    const wrapperPath = path23.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
     await fs8.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path22.join(generatedDir, "http-handler.mjs");
+  const handlerPath = path23.join(generatedDir, "http-handler.mjs");
   await fs8.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(workflowConfig, workflows),
     "utf8"
   );
-  const manifestPath = path22.join(generatedDir, "manifest.json");
+  const manifestPath = path23.join(generatedDir, "manifest.json");
   await fs8.writeFile(
     manifestPath,
     JSON.stringify(
@@ -914,10 +945,10 @@ function resolveWorkflowDefinition(module2) {
 }
 async function findWorkflowFiles(root, dirs) {
   const fs8 = await import("fs/promises");
-  const path22 = await import("path");
+  const path23 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path22.isAbsolute(dir) ? dir : path22.join(root, dir);
+    const absoluteDir = path23.isAbsolute(dir) ? dir : path23.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
@@ -925,10 +956,10 @@ async function findWorkflowFiles(root, dirs) {
 }
 async function walkWorkflowDir(dir, files) {
   const fs8 = await import("fs/promises");
-  const path22 = await import("path");
+  const path23 = await import("path");
   const entries = await fs8.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path22.join(dir, entry.name);
+    const filePath = path23.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -948,12 +979,12 @@ function isWorkflowFile(fileName) {
 }
 async function loadWorkflowModule(filePath, root) {
   const fs8 = await import("fs/promises");
-  const path22 = await import("path");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const path23 = await import("path");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const { build } = await import("esbuild");
-  const outDir = path22.join(root, ".farm", ".workflow-loader");
+  const outDir = path23.join(root, ".farm", ".workflow-loader");
   await fs8.mkdir(outDir, { recursive: true });
-  const outfile = path22.join(
+  const outfile = path23.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -974,7 +1005,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 fs8.unlink(outfile).catch(() => void 0);
@@ -1236,7 +1267,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 path22 = normalizeCronPath(name, job.path);
+  const path23 = 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) {
@@ -1245,7 +1276,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path22,
+    path: path23,
     description: job.description?.trim() || void 0
   };
 }
@@ -1253,13 +1284,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 path22 = value.trim();
-  if (path22.startsWith("//") || path22.includes("?") || path22.includes("#")) {
+  const path23 = value.trim();
+  if (path23.startsWith("//") || path23.includes("?") || path23.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path22.length > 1 ? path22.replace(/\/+$/, "") : path22;
+  return path23.length > 1 ? path23.replace(/\/+$/, "") : path23;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -2116,7 +2147,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path22 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path23 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -2144,7 +2175,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path22,
+    path: path23,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -2183,11 +2214,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path22 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path22.startsWith("/") || path22.includes("?") || path22.includes("#")) {
+  const path23 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path23.startsWith("/") || path23.includes("?") || path23.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path22;
+  return path23;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -2536,9 +2567,9 @@ var init_integration_orm = __esm({
 });
 
 // src/integrations.ts
-function defineTypedIntegrationRoute(method, path22, input) {
+function defineTypedIntegrationRoute(method, path23, input) {
   return {
-    path: path22,
+    path: path23,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -2548,7 +2579,7 @@ function defineTypedIntegrationRoute(method, path22, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path22,
+      path: path23,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -2560,52 +2591,52 @@ function defineTypedIntegrationRoute(method, path22, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path22, input) {
+    get(path23, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path22,
+        path23,
         input
       );
     },
-    post(path22, input) {
+    post(path23, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path22,
+        path23,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path22, input) {
+    put(path23, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path22,
+        path23,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path22, input) {
-      return defineTypedIntegrationRoute("PATCH", path22, {
+    patch(path23, input) {
+      return defineTypedIntegrationRoute("PATCH", path23, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path22, input) {
-      return defineTypedIntegrationRoute("DELETE", path22, {
+    delete(path23, input) {
+      return defineTypedIntegrationRoute("DELETE", path23, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path22, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path22, input);
+    options(path23, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path23, input);
     },
-    head(path22, input) {
+    head(path23, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path22,
+        path23,
         input
       );
     }
@@ -2942,8 +2973,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path22) {
-  return (path22 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path23) {
+  return (path23 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -3632,8 +3663,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path22 = "/", secure = false) {
-  const normalizedPath = path22.startsWith("/") ? path22 : `/${path22}`;
+function createFarmDeploymentCookie(deploymentId, path23 = "/", secure = false) {
+  const normalizedPath = path23.startsWith("/") ? path23 : `/${path23}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -3826,6 +3857,69 @@ 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;
+}
+function normalizeBasePath(value) {
+  const route = (value || "/api/auth").trim();
+  const withLeadingSlash = route.startsWith("/") ? route : `/${route}`;
+  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(normalizeBasePath, "normalizeBasePath");
+    __name(validateFarmAuthConfig, "validateFarmAuthConfig");
+  }
+});
+
 // src/write-file-if-changed.ts
 function writeFileIfChanged(filePath, content) {
   try {
@@ -3945,11 +4039,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route);
         }
         const nestedStructure = {};
-        for (const [path22, routeList] of routeGroups) {
+        for (const [path23, routeList] of routeGroups) {
           const route = routeList[0];
           const importPath = this.getRouteImportPath(route, options.outFile);
           const routeName = this.pathToRouteName(route.path);
-          const cleanPath = path22 === "/api" ? "" : path22.replace(/^\/api\//, "");
+          const cleanPath = path23 === "/api" ? "" : path23.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -4008,8 +4102,8 @@ ${typeExports}
         const relativeImport = (0, import_path7.relative)((0, import_path7.dirname)(outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path22) {
-        return (path22 === "/api" ? "root" : path22.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path23) {
+        return (path23 === "/api" ? "root" : path23.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -4029,15 +4123,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path22) {
-        const cleanPath = path22.replace(/^\/api\//, "");
+      getBaseExportName(path23) {
+        const cleanPath = path23.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path22, method) {
-        const cleanPath = path22.replace(/^\/api\//, "");
+      getExportName(path23, method) {
+        const cleanPath = path23.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -4487,11 +4581,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 = [];
@@ -4500,7 +4594,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)) {
@@ -4518,7 +4612,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",
@@ -4560,7 +4654,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(
@@ -4583,14 +4677,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);
@@ -4604,21 +4698,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"]);
@@ -5056,8 +5150,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 {
@@ -5271,8 +5365,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 {
@@ -5312,38 +5406,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;
   }
 }
 
@@ -5930,9 +6016,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 {
   }
@@ -6072,13 +6158,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");
@@ -6102,9 +6188,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}`;
     }
@@ -6139,10 +6225,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;
@@ -6156,16 +6242,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 [];
@@ -6188,10 +6274,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);
@@ -6252,9 +6338,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 "";
@@ -6272,7 +6358,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;
@@ -7111,13 +7197,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 "";
@@ -7125,13 +7211,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)}`;
@@ -7247,7 +7333,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; }
@@ -7315,7 +7401,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; }
@@ -7325,13 +7411,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}
   `;
@@ -7450,13 +7534,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");
@@ -7734,18 +7818,18 @@ function sanitizeDocsConfig(config) {
   return cloneSerializable(config) || {};
 }
 async function findDocsConfigPath(rootDir, configPath) {
-  const { existsSync: existsSync13 } = await import("fs");
+  const { existsSync: existsSync14 } = 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 (!existsSync13(resolvedPath)) {
+    if (!existsSync14(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 (existsSync13(resolvedPath)) {
+    if (existsSync14(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -7753,7 +7837,7 @@ async function findDocsConfigPath(rootDir, configPath) {
 }
 async function loadDocsConfig(rootDir, configPath) {
   const fs8 = 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;
@@ -7782,7 +7866,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(
@@ -7880,6 +7964,7 @@ var init_config2 = __esm({
     init_devtools_config();
     init_image_config();
     init_config();
+    init_auth_config();
     init_config_entry();
     __name(getDeployTargetForPreset, "getDeployTargetForPreset");
     DOCS_CONFIG_FILENAMES = [
@@ -8668,8 +8753,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path22, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path22);
+        for (const [path23, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path23);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -8683,8 +8768,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path22) {
-        return path22.replace(/^\/api/, "");
+      convertToOpenAPIPath(path23) {
+        return path23.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -8846,8 +8931,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path22, method) {
-        const cleanPath = path22.replace(/^\/api\//, "");
+      generateSummary(path23, method) {
+        const cleanPath = path23.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;
@@ -8856,22 +8941,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path22, method) {
-        const cleanPath = path22.replace(/^\/api\//, "");
+      generateDescription(path23, method) {
+        const cleanPath = path23.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path22, method) {
-        const cleanPath = path22.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path23, method) {
+        const cleanPath = path23.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path22) {
-        const cleanPath = path22.replace(/^\/api\//, "");
+      generateTags(path23) {
+        const cleanPath = path23.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -8884,8 +8969,8 @@ var init_generator = __esm({
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
         const fs8 = require("fs");
-        const path22 = require("path");
-        const dir = path22.dirname(outputPath);
+        const path23 = require("path");
+        const dir = path23.dirname(outputPath);
         if (!fs8.existsSync(dir)) {
           fs8.mkdirSync(dir, { recursive: true });
         }
@@ -9305,7 +9390,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 || "/",
@@ -9354,11 +9439,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();
@@ -12169,7 +12254,7 @@ function normalizePositiveDuration(value, fallback, name) {
 }
 __name(normalizePositiveDuration, "normalizePositiveDuration");
 function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 __name(delay, "delay");
 function normalizeCacheOptionsTags(options) {
@@ -12305,25 +12390,25 @@ function defineRoutes(input) {
 }
 __name(defineRoutes, "defineRoutes");
 var routesBuilder = {
-  page(path22, options) {
+  page(path23, options) {
     return normalizeProgrammaticRoute({
       kind: "page",
-      path: path22,
+      path: path23,
       ...options
     });
   },
-  layout(path22, options) {
+  layout(path23, options) {
     return normalizeProgrammaticRoute({
       kind: "layout",
-      path: path22,
+      path: path23,
       ...options
     });
   },
-  api(path22, options) {
+  api(path23, options) {
     const { render, runtime, regions, maxDuration, ...methods } = options;
     return normalizeProgrammaticRoute({
       kind: "api",
-      path: path22,
+      path: path23,
       render,
       runtime,
       regions,
@@ -12359,7 +12444,7 @@ function getProgrammaticRouteSearchClientOptions(search) {
   return Object.keys(options).length > 0 ? options : void 0;
 }
 __name(getProgrammaticRouteSearchClientOptions, "getProgrammaticRouteSearchClientOptions");
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path22, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path23, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -12368,7 +12453,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path22, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path22
+    path: path23
   });
   return { search, canonicalPath };
 }
@@ -12551,7 +12636,7 @@ function createRouteModuleFromProgrammaticPage(route) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path22) => resolveProgrammaticRouteSearch(route.search, rawSearch, path22, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path23) => resolveProgrammaticRouteSearch(route.search, rawSearch, path23, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -13758,8 +13843,56 @@ var _RouteManager = class _RouteManager {
       "**/{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 route = parseRoutePath(file);
+      const pattern = this.createRoutePattern(route);
+      const group = canonicalPageGroups.get(pattern);
+      if (group) {
+        group.files.push(file);
+      } else {
+        canonicalPageGroups.set(pattern, {
+          route,
+          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]
@@ -15320,6 +15453,7 @@ __name(createTranslatorFromState, "createTranslatorFromState");
 _setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
 
 // src/server/renderer.ts
+init_response();
 var cachedClerkProvider = null;
 var importRuntimeModule = new Function("specifier", "return import(specifier);");
 function hasRequestHeader(req, name) {
@@ -16166,6 +16300,15 @@ var _ServerRenderer = class _ServerRenderer {
         });
       });
     } 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();
@@ -16466,7 +16609,7 @@ var _ServerRenderer = class _ServerRenderer {
     }
   }
   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();
@@ -16646,7 +16789,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                 route: observabilityRoute,
                 durationMs: Date.now() - streamStartTime
               });
-              resolve5();
+              resolve6();
             }
           });
           res.write(shell);
@@ -16657,7 +16800,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",
@@ -16672,7 +16815,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",
@@ -16830,6 +16973,7 @@ var ServerRenderer = _ServerRenderer;
 var import_path6 = __toESM(require("path"));
 init_devtools_config();
 init_config();
+init_auth_config();
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -16887,6 +17031,7 @@ var _FarmApp = class _FarmApp {
       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: [] },
@@ -16959,6 +17104,12 @@ function isResolvedI18nConfig(value) {
   return Boolean(value && typeof value === "object" && "enabled" in value);
 }
 __name(isResolvedI18nConfig, "isResolvedI18nConfig");
+function isResolvedAuthConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && "enabled" in value && "emailAndPassword" in value && "database" in value
+  );
+}
+__name(isResolvedAuthConfig, "isResolvedAuthConfig");
 
 // src/default-styles.ts
 var defaultGlobalCSS = `@import "tailwindcss";
@@ -17291,7 +17442,7 @@ var HMRManager = _HMRManager;
 
 // src/api/route-manager.ts
 var fs3 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 init_route_runtime();
 
 // src/api/runtime.ts
@@ -17624,7 +17775,7 @@ var _APIRouteManager = class _APIRouteManager {
   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);
@@ -17652,7 +17803,7 @@ var _APIRouteManager = class _APIRouteManager {
     }
     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") {
@@ -17666,8 +17817,8 @@ var _APIRouteManager = class _APIRouteManager {
    */
   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 = {};
@@ -17718,7 +17869,7 @@ var _APIRouteManager = class _APIRouteManager {
     }
   }
   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)))
     );
@@ -17744,11 +17895,11 @@ var _APIRouteManager = class _APIRouteManager {
   }
   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;
         }
@@ -17861,7 +18012,7 @@ var APIRouteManager = _APIRouteManager;
 
 // src/middleware/manager.ts
 var fs4 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 
 // src/middleware/context.ts
 function parseCookies(cookieHeader) {
@@ -18237,8 +18388,8 @@ var _MiddlewareManager = class _MiddlewareManager {
     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);
       }
     }
@@ -18249,7 +18400,7 @@ var _MiddlewareManager = class _MiddlewareManager {
   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;
       }
@@ -18601,7 +18752,7 @@ var import_path8 = require("path");
 init_type_generator();
 
 // src/routing/generate-route-types.ts
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var fs5 = __toESM(require("fs"));
 init_write_file_if_changed();
 function routeSegmentsToTsTypeLiteral(segments) {
@@ -18644,19 +18795,23 @@ function createRoutePattern(route) {
 __name(createRoutePattern, "createRoutePattern");
 var DEFAULT_OUT_FILE = "farm-routes.d.ts";
 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;
+}
+__name(generateRouteTypes, "generateRouteTypes");
+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,
@@ -18685,18 +18840,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;
@@ -18705,8 +18861,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;
   }
 }
 `;
@@ -18718,15 +18874,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;
 }
-__name(generateRouteTypes, "generateRouteTypes");
+__name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
 
 // src/env-types.ts
 var fs6 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 init_write_file_if_changed();
 var DEFAULT_OUT_FILE2 = "farm-env.d.ts";
 var CONFIG_FILENAMES = [
@@ -18748,20 +18902,27 @@ var CONFIG_FILENAMES = [
   "config.cjs"
 ];
 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;
+}
+__name(generateEnvTypes, "generateEnvTypes");
+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;
 }
-__name(generateEnvTypes, "generateEnvTypes");
+__name(createEnvTypeDeclarations, "createEnvTypeDeclarations");
 function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
   const imports = configPaths.map(
     (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
@@ -18817,11 +18978,11 @@ export {};
 __name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
 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_FILENAMES) {
-    const resolvedPath = path13.join(root, filename);
+    const resolvedPath = path14.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -18885,19 +19046,19 @@ export {};
 }
 __name(createEmptyEnvTypes, "createEmptyEnvTypes");
 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}`;
 }
 __name(toTypeImportPath, "toTypeImportPath");
 
 // src/image-types.ts
 var import_node_fs3 = require("fs");
-var import_node_path4 = __toESM(require("path"));
+var import_node_path5 = __toESM(require("path"));
 init_write_file_if_changed();
 var FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
 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;
 }
@@ -18926,14 +19087,14 @@ __name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
 
 // src/i18n/type-generator.ts
 var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 init_write_file_if_changed();
 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;
 }
@@ -18995,7 +19156,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,
@@ -19003,10 +19167,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);
@@ -19018,22 +19189,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,
@@ -19041,9 +19230,42 @@ 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;
 }
 __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+var 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"]
+];
+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);
+    }
+  }
+}
+__name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
 
 // src/vite.ts
 init_markdown();
@@ -19052,7 +19274,7 @@ init_response();
 init_integrations();
 init_devtools_config();
 var fs7 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 init_layers();
 
 // src/after.ts
@@ -19084,8 +19306,8 @@ __name(reportAfterError, "reportAfterError");
 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(),
@@ -19162,7 +19384,7 @@ init_image_config();
 
 // src/image-vite.ts
 var import_promises6 = require("fs/promises");
-var import_node_path6 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 var import_image_size2 = require("image-size");
 var FARM_IMAGE_ID_PREFIX = "\0farm:image:";
 var STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -19235,7 +19457,7 @@ var ALL_TYPE_ARTIFACTS = {
   routes: true,
   api: true,
   env: true,
-  images: true,
+  images: false,
   i18n: true
 };
 var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -19433,7 +19655,7 @@ function fileContainsProgrammaticPageRoute(file) {
 __name(fileContainsProgrammaticPageRoute, "fileContainsProgrammaticPageRoute");
 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 = [];
@@ -19453,7 +19675,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,
@@ -19533,7 +19755,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]
             }
           }
         } : {}
@@ -19558,9 +19780,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 });
         }
@@ -19582,10 +19804,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;
@@ -19595,7 +19817,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 {
@@ -19635,7 +19857,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))
@@ -19753,7 +19975,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();
@@ -19831,14 +20053,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"
             )
@@ -20002,12 +20224,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")
           });
@@ -20028,16 +20251,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);
                 });
               });
             }
@@ -20080,13 +20324,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);
                   });
                 });
               }
@@ -20192,13 +20436,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);
                     });
                   });
                 }
@@ -20255,13 +20499,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);
                     });
                   });
                 }
@@ -20981,8 +21225,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"));
@@ -21034,8 +21278,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}`);
@@ -21044,7 +21288,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(
@@ -21080,9 +21324,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);
         }
@@ -22125,6 +22369,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,