@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/server.cjs

@@ -31,178 +31,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// 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: [],
@@ -210,7 +41,7 @@ function resolveMarkdownConfig(config) {
       includeMetadata: true
     };
   }
-  if (config === true) {
+  if (config === true || config === void 0) {
     return {
       enabled: true,
       expose: true,
@@ -218,7 +49,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),
@@ -227,11 +58,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;
@@ -246,7 +80,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;
   }
@@ -274,8 +111,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, {
@@ -361,11 +202,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;
@@ -456,6 +310,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");
@@ -469,6 +324,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, {
@@ -621,26 +652,26 @@ async function prepareFarmWorkflowsForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs9 = await import("fs/promises");
-  const path23 = await import("path");
-  const generatedDir = path23.join(root, distDir, ".nitro", "farm-workflows");
+  const path24 = await import("path");
+  const generatedDir = path24.join(root, distDir, ".nitro", "farm-workflows");
   await fs9.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path23.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    const wrapperPath = path24.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
     await fs9.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path23.join(generatedDir, "http-handler.mjs");
+  const handlerPath = path24.join(generatedDir, "http-handler.mjs");
   await fs9.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(workflowConfig, workflows),
     "utf8"
   );
-  const manifestPath = path23.join(generatedDir, "manifest.json");
+  const manifestPath = path24.join(generatedDir, "manifest.json");
   await fs9.writeFile(
     manifestPath,
     JSON.stringify(
@@ -723,10 +754,10 @@ function resolveWorkflowDefinition(module2) {
 }
 async function findWorkflowFiles(root, dirs) {
   const fs9 = await import("fs/promises");
-  const path23 = await import("path");
+  const path24 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path23.isAbsolute(dir) ? dir : path23.join(root, dir);
+    const absoluteDir = path24.isAbsolute(dir) ? dir : path24.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
@@ -734,10 +765,10 @@ async function findWorkflowFiles(root, dirs) {
 }
 async function walkWorkflowDir(dir, files) {
   const fs9 = await import("fs/promises");
-  const path23 = await import("path");
+  const path24 = await import("path");
   const entries = await fs9.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path23.join(dir, entry.name);
+    const filePath = path24.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -757,12 +788,12 @@ function isWorkflowFile(fileName) {
 }
 async function loadWorkflowModule(filePath, root) {
   const fs9 = await import("fs/promises");
-  const path23 = await import("path");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const path24 = await import("path");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const { build } = await import("esbuild");
-  const outDir = path23.join(root, ".farm", ".workflow-loader");
+  const outDir = path24.join(root, ".farm", ".workflow-loader");
   await fs9.mkdir(outDir, { recursive: true });
-  const outfile = path23.join(
+  const outfile = path24.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -783,7 +814,7 @@ async function loadWorkflowModule(filePath, root) {
   try {
     return await import(
       /* @vite-ignore */
-      `${pathToFileURL3(outfile).href}?t=${Date.now()}`
+      `${pathToFileURL4(outfile).href}?t=${Date.now()}`
     );
   } finally {
     await fs9.unlink(outfile).catch(() => void 0);
@@ -1045,7 +1076,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 path23 = normalizeCronPath(name, job.path);
+  const path24 = 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) {
@@ -1054,7 +1085,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path23,
+    path: path24,
     description: job.description?.trim() || void 0
   };
 }
@@ -1062,13 +1093,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 path23 = value.trim();
-  if (path23.startsWith("//") || path23.includes("?") || path23.includes("#")) {
+  const path24 = value.trim();
+  if (path24.startsWith("//") || path24.includes("?") || path24.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path23.length > 1 ? path23.replace(/\/+$/, "") : path23;
+  return path24.length > 1 ? path24.replace(/\/+$/, "") : path24;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -2333,7 +2364,7 @@ var init_server_action_security = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path23 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path24 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -2361,7 +2392,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path23,
+    path: path24,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -2400,11 +2431,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path23 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path23.startsWith("/") || path23.includes("?") || path23.includes("#")) {
+  const path24 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path24.startsWith("/") || path24.includes("?") || path24.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path23;
+  return path24;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -3243,9 +3274,9 @@ var init_integration_orm = __esm({
 });
 
 // src/integrations.ts
-function defineTypedIntegrationRoute(method, path23, input) {
+function defineTypedIntegrationRoute(method, path24, input) {
   return {
-    path: path23,
+    path: path24,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -3255,7 +3286,7 @@ function defineTypedIntegrationRoute(method, path23, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path23,
+      path: path24,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -3267,52 +3298,52 @@ function defineTypedIntegrationRoute(method, path23, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path23, input) {
+    get(path24, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path23,
+        path24,
         input
       );
     },
-    post(path23, input) {
+    post(path24, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path23,
+        path24,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path23, input) {
+    put(path24, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path23,
+        path24,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path23, input) {
-      return defineTypedIntegrationRoute("PATCH", path23, {
+    patch(path24, input) {
+      return defineTypedIntegrationRoute("PATCH", path24, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path23, input) {
-      return defineTypedIntegrationRoute("DELETE", path23, {
+    delete(path24, input) {
+      return defineTypedIntegrationRoute("DELETE", path24, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path23, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path23, input);
+    options(path24, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path24, input);
     },
-    head(path23, input) {
+    head(path24, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path23,
+        path24,
         input
       );
     }
@@ -3529,8 +3560,8 @@ async function parseIntegrationConfigSchema(integration, schema, value) {
 function createIntegrationConfigValidationError(integration, error) {
   const issues = Array.isArray(error.issues) && error.issues.length > 0 ? error.issues.map((issue) => {
     const normalizedPath = normalizeIntegrationValidationPath(issue.path);
-    const path23 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path23}${issue.message || "Invalid config"}`;
+    const path24 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path24}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -4215,8 +4246,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path23) {
-  return (path23 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path24) {
+  return (path24 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -4867,13 +4898,13 @@ function getRequestId(req) {
   return headerValue || String(Date.now());
 }
 async function readRequestBody(req) {
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve6, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
     req.on("end", () => {
-      resolve5(Buffer.concat(chunks));
+      resolve6(Buffer.concat(chunks));
     });
     req.on("error", reject);
   });
@@ -5009,8 +5040,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path23 = "/", secure = false) {
-  const normalizedPath = path23.startsWith("/") ? path23 : `/${path23}`;
+function createFarmDeploymentCookie(deploymentId, path24 = "/", secure = false) {
+  const normalizedPath = path24.startsWith("/") ? path24 : `/${path24}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -5204,6 +5235,96 @@ var init_devtools_config = __esm({
   }
 });
 
+// src/auth-config.ts
+function resolveFarmAuthConfig(input) {
+  const config = input === true ? {} : input && typeof input === "object" ? input : {};
+  const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
+  const resolved = {
+    enabled: input !== void 0 && input !== false && config.enabled !== false,
+    appName: config.appName,
+    basePath: normalizeBasePath(config.basePath),
+    emailAndPassword: {
+      enabled: config.emailAndPassword !== false,
+      requireEmailVerification: passwordConfig.requireEmailVerification ?? false,
+      minPasswordLength: passwordConfig.minPasswordLength ?? 8,
+      maxPasswordLength: passwordConfig.maxPasswordLength ?? 128
+    },
+    session: {
+      expiresIn: config.session?.expiresIn ?? 60 * 60 * 24 * 7,
+      updateAge: config.session?.updateAge ?? 60 * 60 * 24
+    },
+    database: {
+      url: config.database?.url,
+      path: config.database?.path || ".farm/auth.sqlite",
+      migrateInDevelopment: config.database?.migrateInDevelopment ?? true
+    }
+  };
+  validateFarmAuthConfig(resolved);
+  return resolved;
+}
+async function resolveFarmAuthIntegration(config, options) {
+  if (!config.enabled) return void 0;
+  const root = import_node_path4.default.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = (0, import_node_module2.createRequire)(import_node_path4.default.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+  } catch {
+    throw new Error(
+      "The `auth` config requires @farm.js/auth. Install it with `pnpm add @farm.js/auth` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    (0, import_node_url2.pathToFileURL)(modulePath).href
+  );
+  if (typeof runtime.createFarmAuthIntegration !== "function") {
+    throw new Error(
+      "The installed @farm.js/auth package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmAuthIntegration(config, {
+    ...options,
+    root
+  });
+}
+function normalizeBasePath(value) {
+  const 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(resolveFarmAuthIntegration, "resolveFarmAuthIntegration");
+    __name(normalizeBasePath, "normalizeBasePath");
+    __name(validateFarmAuthConfig, "validateFarmAuthConfig");
+  }
+});
+
 // src/write-file-if-changed.ts
 function writeFileIfChanged(filePath, content) {
   try {
@@ -5323,11 +5444,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route);
         }
         const nestedStructure = {};
-        for (const [path23, routeList] of routeGroups) {
+        for (const [path24, routeList] of routeGroups) {
           const route = routeList[0];
           const importPath = this.getRouteImportPath(route, options.outFile);
           const routeName = this.pathToRouteName(route.path);
-          const cleanPath = path23 === "/api" ? "" : path23.replace(/^\/api\//, "");
+          const cleanPath = path24 === "/api" ? "" : path24.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -5386,8 +5507,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(path23) {
-        return (path23 === "/api" ? "root" : path23.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path24) {
+        return (path24 === "/api" ? "root" : path24.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -5407,15 +5528,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path23) {
-        const cleanPath = path23.replace(/^\/api\//, "");
+      getBaseExportName(path24) {
+        const cleanPath = path24.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path23, method) {
-        const cleanPath = path23.replace(/^\/api\//, "");
+      getExportName(path24, method) {
+        const cleanPath = path24.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -5865,11 +5986,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 = [];
@@ -5878,7 +5999,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)) {
@@ -5896,7 +6017,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",
@@ -5938,7 +6059,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(
@@ -5961,14 +6082,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);
@@ -5982,21 +6103,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"]);
@@ -6434,8 +6555,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 {
@@ -6649,8 +6770,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 {
@@ -6690,38 +6811,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;
   }
 }
 
@@ -7308,9 +7421,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 {
   }
@@ -7450,13 +7563,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");
@@ -7480,9 +7593,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}`;
     }
@@ -7517,10 +7630,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;
@@ -7534,16 +7647,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 [];
@@ -7566,10 +7679,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);
@@ -7630,9 +7743,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 "";
@@ -7650,7 +7763,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;
@@ -8489,13 +8602,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 "";
@@ -8503,13 +8616,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)}`;
@@ -8625,7 +8738,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; }
@@ -8693,7 +8806,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; }
@@ -8703,13 +8816,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}
   `;
@@ -8828,13 +8939,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");
@@ -9319,18 +9430,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;
     }
   }
@@ -9338,7 +9449,7 @@ async function findDocsConfigPath(rootDir, configPath) {
 }
 async function loadDocsConfig(rootDir, configPath) {
   const fs9 = await import("fs/promises");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const root = import_path9.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
@@ -9367,7 +9478,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(
@@ -9468,6 +9579,17 @@ async function resolveConfig(userConfig, mode) {
   const mdx = resolveMdxConfig(userConfig.mdx);
   const env2 = resolveEnv(userConfig.env, process.env);
   setEnv(env2);
+  const auth = resolveFarmAuthConfig(userConfig.auth);
+  if (auth.enabled && userConfig.integrations?.auth) {
+    throw new Error(
+      "Choose either the top-level `auth` config or `integrations.auth`; they cannot both own the auth route."
+    );
+  }
+  const nativeAuthIntegration = await resolveFarmAuthIntegration(auth, {
+    root,
+    mode
+  });
+  const integrations = nativeAuthIntegration ? { ...userConfig.integrations, auth: nativeAuthIntegration } : userConfig.integrations || {};
   const generateBuildId = userConfig.generateBuildId || (() => `build-${Date.now()}`);
   const deploymentId = normalizeFarmDeploymentId(
     userConfig.deploymentId || process.env.FARM_DEPLOYMENT_ID || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CF_PAGES_COMMIT_SHA || (mode === "production" ? await generateBuildId() : "development")
@@ -9492,14 +9614,15 @@ async function resolveConfig(userConfig, mode) {
     devtools: resolveFarmDevtoolsConfig(userConfig.devtools, mode),
     storage: userConfig.storage || {},
     cache: userConfig.cache || {},
+    auth,
     suppressLintOnLink: userConfig.suppressLintOnLink ?? false,
     experimental: {
       serverComponents: false,
       serverActions: false,
       ...userConfig.experimental
     },
-    plugins: [...resolveIntegrationPlugins(userConfig.integrations), ...userConfig.plugins || []],
-    integrations: userConfig.integrations || {},
+    plugins: [...resolveIntegrationPlugins(integrations), ...userConfig.plugins || []],
+    integrations,
     trailingSlash: userConfig.trailingSlash ?? false,
     redirects: /* @__PURE__ */ __name(() => [...redirects, ...routeRuleRedirects], "redirects"),
     rewrites: /* @__PURE__ */ __name(() => rewrites, "rewrites"),
@@ -9544,7 +9667,7 @@ async function resolveConfig(userConfig, mode) {
   return resolved;
 }
 async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
-  const { existsSync: existsSync13 } = await import("fs");
+  const { existsSync: existsSync14 } = await import("fs");
   const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
   const root = rootDir || process.cwd();
   const loadedEnv = loadEnv(mode, root, "");
@@ -9568,7 +9691,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
     try {
       const absolutePath = relativePath2.startsWith("/") ? relativePath2 : import_path9.default.join(root, relativePath2);
       const normalizedPath = import_path9.default.resolve(absolutePath);
-      if (!existsSync13(normalizedPath)) {
+      if (!existsSync14(normalizedPath)) {
         continue;
       }
       const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
@@ -9598,6 +9721,7 @@ var init_config2 = __esm({
     init_devtools_config();
     init_image_config();
     init_config();
+    init_auth_config();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(normalizeDeployTarget, "normalizeDeployTarget");
@@ -10394,8 +10518,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path23, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path23);
+        for (const [path24, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path24);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -10409,8 +10533,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path23) {
-        return path23.replace(/^\/api/, "");
+      convertToOpenAPIPath(path24) {
+        return path24.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -10572,8 +10696,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path23, method) {
-        const cleanPath = path23.replace(/^\/api\//, "");
+      generateSummary(path24, method) {
+        const cleanPath = path24.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;
@@ -10582,22 +10706,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path23, method) {
-        const cleanPath = path23.replace(/^\/api\//, "");
+      generateDescription(path24, method) {
+        const cleanPath = path24.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path23, method) {
-        const cleanPath = path23.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path24, method) {
+        const cleanPath = path24.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path23) {
-        const cleanPath = path23.replace(/^\/api\//, "");
+      generateTags(path24) {
+        const cleanPath = path24.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -10610,8 +10734,8 @@ var init_generator = __esm({
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
         const fs9 = require("fs");
-        const path23 = require("path");
-        const dir = path23.dirname(outputPath);
+        const path24 = require("path");
+        const dir = path24.dirname(outputPath);
         if (!fs9.existsSync(dir)) {
           fs9.mkdirSync(dir, { recursive: true });
         }
@@ -11031,7 +11155,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 || "/",
@@ -11080,11 +11204,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();
@@ -14144,7 +14268,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) {
@@ -14295,25 +14419,25 @@ function defineRoutes(input) {
 }
 __name(defineRoutes, "defineRoutes");
 var routesBuilder = {
-  page(path23, options) {
+  page(path24, options) {
     return normalizeProgrammaticRoute({
       kind: "page",
-      path: path23,
+      path: path24,
       ...options
     });
   },
-  layout(path23, options) {
+  layout(path24, options) {
     return normalizeProgrammaticRoute({
       kind: "layout",
-      path: path23,
+      path: path24,
       ...options
     });
   },
-  api(path23, options) {
+  api(path24, options) {
     const { render, runtime, regions, maxDuration, ...methods } = options;
     return normalizeProgrammaticRoute({
       kind: "api",
-      path: path23,
+      path: path24,
       render,
       runtime,
       regions,
@@ -14349,7 +14473,7 @@ function getProgrammaticRouteSearchClientOptions(search) {
   return Object.keys(options).length > 0 ? options : void 0;
 }
 __name(getProgrammaticRouteSearchClientOptions, "getProgrammaticRouteSearchClientOptions");
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path23, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path24, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -14358,7 +14482,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path23, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path23
+    path: path24
   });
   return { search, canonicalPath };
 }
@@ -14541,7 +14665,7 @@ function createRouteModuleFromProgrammaticPage(route) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path23) => resolveProgrammaticRouteSearch(route.search, rawSearch, path23, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path24) => resolveProgrammaticRouteSearch(route.search, rawSearch, path24, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -15748,8 +15872,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]
@@ -17324,6 +17496,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) {
@@ -18170,6 +18343,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();
@@ -18470,7 +18652,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();
@@ -18650,7 +18832,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                 route: observabilityRoute,
                 durationMs: Date.now() - streamStartTime
               });
-              resolve5();
+              resolve6();
             }
           });
           res.write(shell);
@@ -18661,7 +18843,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",
@@ -18676,7 +18858,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",
@@ -18834,6 +19016,7 @@ var ServerRenderer = _ServerRenderer;
 var import_path6 = __toESM(require("path"));
 init_devtools_config();
 init_config();
+init_auth_config();
 var defaultDocsConfig = {
   enabled: false,
   entry: "/docs",
@@ -18891,6 +19074,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: [] },
@@ -18963,6 +19147,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");
 function createFarmApp(config, viteServer) {
   return new FarmApp(config, viteServer);
 }
@@ -19299,7 +19489,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
@@ -19632,7 +19822,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);
@@ -19660,7 +19850,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") {
@@ -19674,8 +19864,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 = {};
@@ -19726,7 +19916,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)))
     );
@@ -19752,11 +19942,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;
         }
@@ -19869,7 +20059,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) {
@@ -20245,8 +20435,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);
       }
     }
@@ -20257,7 +20447,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;
       }
@@ -20609,7 +20799,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) {
@@ -20652,19 +20842,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,
@@ -20693,18 +20887,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;
@@ -20713,8 +20908,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;
   }
 }
 `;
@@ -20726,15 +20921,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_FILENAMES2 = [
@@ -20756,20 +20949,27 @@ var CONFIG_FILENAMES2 = [
   "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))};`
@@ -20825,11 +21025,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_FILENAMES2) {
-    const resolvedPath = path13.join(root, filename);
+    const resolvedPath = path14.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -20893,19 +21093,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;
 }
@@ -20934,14 +21134,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;
 }
@@ -21003,7 +21203,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,
@@ -21011,10 +21214,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);
@@ -21026,22 +21236,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,
@@ -21049,9 +21277,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();
@@ -21060,7 +21321,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/environment-vite.ts
@@ -21407,7 +21668,7 @@ function transformError(id, message) {
 __name(transformError, "transformError");
 
 // package.json
-var version = "0.1.0-beta.5";
+var version = "0.1.0-beta.8";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -21441,8 +21702,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(),
@@ -21554,8 +21815,8 @@ function after(callback) {
     throw new Error("after() cannot schedule work after the request lifecycle has completed.");
   }
   let start;
-  const ready = new Promise((resolve5) => {
-    start = resolve5;
+  const ready = new Promise((resolve6) => {
+    start = resolve6;
   });
   const result = ready.then(callback);
   state.tasks.push({ result, start });
@@ -21610,7 +21871,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;
@@ -21683,7 +21944,7 @@ var ALL_TYPE_ARTIFACTS = {
   routes: true,
   api: true,
   env: true,
-  images: true,
+  images: false,
   i18n: true
 };
 var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -21899,7 +22160,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 = [];
@@ -21919,7 +22180,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,
@@ -21999,7 +22260,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]
             }
           }
         } : {}
@@ -22024,9 +22285,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 });
         }
@@ -22048,10 +22309,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;
@@ -22061,7 +22322,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 {
@@ -22101,7 +22362,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))
@@ -22219,7 +22480,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();
@@ -22297,14 +22558,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"
             )
@@ -22468,12 +22729,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")
           });
@@ -22494,16 +22756,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);
                 });
               });
             }
@@ -22546,13 +22829,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);
                   });
                 });
               }
@@ -22658,13 +22941,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);
                     });
                   });
                 }
@@ -22721,13 +23004,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);
                     });
                   });
                 }
@@ -23447,8 +23730,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"));
@@ -23500,8 +23783,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}`);
@@ -23510,7 +23793,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(
@@ -23546,9 +23829,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);
         }
@@ -24591,6 +24874,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,
@@ -25107,7 +25391,7 @@ function generateClientManifest(bundle) {
 __name(generateClientManifest, "generateClientManifest");
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path21.resolve(config.root || process.cwd());
+  const appRoot = path22.resolve(config.root || process.cwd());
   if (config.extends?.length) {
     const { config: layeredConfig } = await Promise.resolve().then(() => (init_layers(), layers_exports)).then(
       ({ resolveFarmLayers: resolveFarmLayers2 }) => resolveFarmLayers2(config, {
@@ -25293,7 +25577,7 @@ async function defineConfig2(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path21.resolve(appRoot, "src"),
+        "@": path22.resolve(appRoot, "src"),
         // Nitro internals that should not be resolved in browser
         "supports-color": "data:text/javascript,export default false; export const supportsColor = false; export const stdout = false; export const stderr = false;",
         "@poppinss/dumper": "data:text/javascript,export default {};",