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

package/dist/internal/build-runtime.cjs

@@ -784,9 +784,9 @@ function getFarmIntegrationPluginServerRuntime(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_SERVER_RUNTIME];
   return typeof value === "boolean" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path27, input) {
+function defineTypedIntegrationRoute(method, path28, input) {
   return {
-    path: path27,
+    path: path28,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -796,7 +796,7 @@ function defineTypedIntegrationRoute(method, path27, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path27,
+      path: path28,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -808,52 +808,52 @@ function defineTypedIntegrationRoute(method, path27, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path27, input) {
+    get(path28, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path27,
+        path28,
         input
       );
     },
-    post(path27, input) {
+    post(path28, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path27,
+        path28,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    put(path27, input) {
+    put(path28, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path27,
+        path28,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path27, input) {
-      return defineTypedIntegrationRoute("PATCH", path27, {
+    patch(path28, input) {
+      return defineTypedIntegrationRoute("PATCH", path28, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path27, input) {
-      return defineTypedIntegrationRoute("DELETE", path27, {
+    delete(path28, input) {
+      return defineTypedIntegrationRoute("DELETE", path28, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path27, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path27, input);
+    options(path28, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path28, input);
     },
-    head(path27, input) {
+    head(path28, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path27,
+        path28,
         input
       );
     }
@@ -1070,8 +1070,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 path27 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path27}${issue.message || "Invalid config"}`;
+    const path28 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path28}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -1756,8 +1756,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path27) {
-  return (path27 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path28) {
+  return (path28 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -2408,13 +2408,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);
   });
@@ -2513,7 +2513,7 @@ var init_integrations = __esm({
 
 // src/markdown.ts
 function resolveMarkdownConfig(config) {
-  if (config === false || config === void 0) {
+  if (config === false) {
     return {
       enabled: false,
       expose: [],
@@ -2521,7 +2521,7 @@ function resolveMarkdownConfig(config) {
       includeMetadata: true
     };
   }
-  if (config === true) {
+  if (config === true || config === void 0) {
     return {
       enabled: true,
       expose: true,
@@ -2529,7 +2529,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),
@@ -2538,11 +2538,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;
@@ -2557,7 +2560,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;
   }
@@ -2585,8 +2591,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, {
@@ -2672,11 +2682,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;
@@ -2767,6 +2790,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");
@@ -2932,26 +2956,26 @@ async function prepareFarmWorkflowsForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs8 = await import("fs/promises");
-  const path27 = await import("path");
-  const generatedDir = path27.join(root, distDir, ".nitro", "farm-workflows");
+  const path28 = await import("path");
+  const generatedDir = path28.join(root, distDir, ".nitro", "farm-workflows");
   await fs8.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = path27.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    const wrapperPath = path28.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
     await fs8.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = path27.join(generatedDir, "http-handler.mjs");
+  const handlerPath = path28.join(generatedDir, "http-handler.mjs");
   await fs8.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(workflowConfig, workflows),
     "utf8"
   );
-  const manifestPath = path27.join(generatedDir, "manifest.json");
+  const manifestPath = path28.join(generatedDir, "manifest.json");
   await fs8.writeFile(
     manifestPath,
     JSON.stringify(
@@ -3034,10 +3058,10 @@ function resolveWorkflowDefinition(module2) {
 }
 async function findWorkflowFiles(root, dirs) {
   const fs8 = await import("fs/promises");
-  const path27 = await import("path");
+  const path28 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path27.isAbsolute(dir) ? dir : path27.join(root, dir);
+    const absoluteDir = path28.isAbsolute(dir) ? dir : path28.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
@@ -3045,10 +3069,10 @@ async function findWorkflowFiles(root, dirs) {
 }
 async function walkWorkflowDir(dir, files) {
   const fs8 = await import("fs/promises");
-  const path27 = await import("path");
+  const path28 = await import("path");
   const entries = await fs8.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path27.join(dir, entry.name);
+    const filePath = path28.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -3068,12 +3092,12 @@ function isWorkflowFile(fileName) {
 }
 async function loadWorkflowModule(filePath, root) {
   const fs8 = await import("fs/promises");
-  const path27 = await import("path");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const path28 = await import("path");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const { build: build2 } = await import("esbuild");
-  const outDir = path27.join(root, ".farm", ".workflow-loader");
+  const outDir = path28.join(root, ".farm", ".workflow-loader");
   await fs8.mkdir(outDir, { recursive: true });
-  const outfile = path27.join(
+  const outfile = path28.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -3094,7 +3118,7 @@ async function loadWorkflowModule(filePath, root) {
   try {
     return await import(
       /* @vite-ignore */
-      `${pathToFileURL3(outfile).href}?t=${Date.now()}`
+      `${pathToFileURL4(outfile).href}?t=${Date.now()}`
     );
   } finally {
     await fs8.unlink(outfile).catch(() => void 0);
@@ -3352,9 +3376,9 @@ async function prepareFarmCronForNitro(config) {
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
   const fs8 = await import("fs/promises");
-  const path27 = await import("path");
-  const manifestPath = path27.join(root, distDir, FARM_CRON_MANIFEST);
-  const generatedDir = path27.join(root, distDir, ".nitro", "farm-cron");
+  const path28 = await import("path");
+  const manifestPath = path28.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path28.join(root, distDir, ".nitro", "farm-cron");
   if (!cron.enabled) {
     await Promise.all([
       fs8.rm(manifestPath, { force: true }),
@@ -3371,7 +3395,7 @@ async function prepareFarmCronForNitro(config) {
   const tasks = {};
   for (const job of cron.jobs) {
     const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = path27.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
+    const wrapperPath = path28.join(generatedDir, `${safeFileName2(job.name)}.mjs`);
     await fs8.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
     tasks[taskName] = {
       handler: wrapperPath,
@@ -3379,7 +3403,7 @@ async function prepareFarmCronForNitro(config) {
     };
   }
   const manifest = createFarmCronManifest(cron);
-  await fs8.mkdir(path27.dirname(manifestPath), { recursive: true });
+  await fs8.mkdir(path28.dirname(manifestPath), { recursive: true });
   await fs8.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return {
@@ -3461,7 +3485,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 path27 = normalizeCronPath(name, job.path);
+  const path28 = 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) {
@@ -3470,7 +3494,7 @@ function normalizeCronJob(name, job) {
   return {
     name,
     schedule,
-    path: path27,
+    path: path28,
     description: job.description?.trim() || void 0
   };
 }
@@ -3478,13 +3502,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 path27 = value.trim();
-  if (path27.startsWith("//") || path27.includes("?") || path27.includes("#")) {
+  const path28 = value.trim();
+  if (path28.startsWith("//") || path28.includes("?") || path28.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  return path27.length > 1 ? path27.replace(/\/+$/, "") : path27;
+  return path28.length > 1 ? path28.replace(/\/+$/, "") : path28;
 }
 function normalizeCronExpression(name, value) {
   if (typeof value !== "string") {
@@ -3932,7 +3956,8 @@ async function createFarmMarkdownSourceResponse(options) {
     return null;
   }
   const url = new URL(options.request.url);
-  if (!url.pathname.endsWith(".md")) {
+  const hasMarkdownExtension = url.pathname.toLowerCase().endsWith(".md");
+  if (!hasMarkdownExtension && !requestAcceptsMarkdown(options.request.headers.get("accept"))) {
     return null;
   }
   const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
@@ -3940,14 +3965,19 @@ async function createFarmMarkdownSourceResponse(options) {
   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: {
-      "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
-    }
+    headers
   });
 }
 var import_react, import_promises, import_path, import_url;
@@ -3958,6 +3988,7 @@ var init_app_markdown = __esm({
     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");
@@ -4873,8 +4904,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path27 = "/", secure = false) {
-  const normalizedPath = path27.startsWith("/") ? path27 : `/${path27}`;
+function createFarmDeploymentCookie(deploymentId, path28 = "/", secure = false) {
+  const normalizedPath = path28.startsWith("/") ? path28 : `/${path28}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -4945,7 +4976,7 @@ var init_devtools_config = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path27 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path28 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -4973,7 +5004,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path27,
+    path: path28,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -5012,11 +5043,11 @@ function getPublicFarmImageConfig(config) {
   };
 }
 function normalizeImagePath(value) {
-  const path27 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path27.startsWith("/") || path27.includes("?") || path27.includes("#")) {
+  const path28 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path28.startsWith("/") || path28.includes("?") || path28.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  return path27;
+  return path28;
 }
 function normalizeIntegerList(values, name, max) {
   if (values.length === 0) {
@@ -5240,6 +5271,96 @@ var init_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_path3.default.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = (0, import_node_module2.createRequire)(import_node_path3.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_path3, import_node_url2;
+var init_auth_config = __esm({
+  "src/auth-config.ts"() {
+    "use strict";
+    import_node_module2 = require("module");
+    import_node_path3 = __toESM(require("path"));
+    import_node_url2 = require("url");
+    __name(resolveFarmAuthConfig, "resolveFarmAuthConfig");
+    __name(resolveFarmAuthIntegration, "resolveFarmAuthIntegration");
+    __name(normalizeBasePath, "normalizeBasePath");
+    __name(validateFarmAuthConfig, "validateFarmAuthConfig");
+  }
+});
+
 // src/config-entry.ts
 var init_config_entry = __esm({
   "src/config-entry.ts"() {
@@ -5360,18 +5481,18 @@ function sanitizeDocsConfig(config) {
   return cloneSerializable(config) || {};
 }
 async function findDocsConfigPath(rootDir, configPath) {
-  const { existsSync: existsSync14 } = await import("fs");
+  const { existsSync: existsSync15 } = await import("fs");
   const root = import_path2.default.resolve(rootDir || process.cwd());
   if (configPath) {
     const resolvedPath = import_path2.default.isAbsolute(configPath) ? configPath : import_path2.default.join(root, configPath);
-    if (!existsSync14(resolvedPath)) {
+    if (!existsSync15(resolvedPath)) {
       throw new Error(`Could not find docs config at ${configPath}.`);
     }
     return import_path2.default.resolve(resolvedPath);
   }
   for (const filename of DOCS_CONFIG_FILENAMES) {
     const resolvedPath = import_path2.default.join(root, filename);
-    if (existsSync14(resolvedPath)) {
+    if (existsSync15(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -5379,7 +5500,7 @@ async function findDocsConfigPath(rootDir, configPath) {
 }
 async function loadDocsConfig(rootDir, configPath) {
   const fs8 = await import("fs/promises");
-  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const { pathToFileURL: pathToFileURL4 } = await import("url");
   const root = import_path2.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
@@ -5408,7 +5529,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(
@@ -5509,6 +5630,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")
@@ -5533,14 +5665,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"),
@@ -5585,7 +5718,7 @@ async function resolveConfig(userConfig, mode) {
   return resolved;
 }
 async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
-  const { existsSync: existsSync14 } = await import("fs");
+  const { existsSync: existsSync15 } = await import("fs");
   const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
   const root = rootDir || process.cwd();
   const loadedEnv = loadEnv(mode, root, "");
@@ -5609,7 +5742,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
     try {
       const absolutePath = relativePath2.startsWith("/") ? relativePath2 : import_path2.default.join(root, relativePath2);
       const normalizedPath = import_path2.default.resolve(absolutePath);
-      if (!existsSync14(normalizedPath)) {
+      if (!existsSync15(normalizedPath)) {
         continue;
       }
       const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
@@ -5639,6 +5772,7 @@ var init_config2 = __esm({
     init_devtools_config();
     init_image_config();
     init_config();
+    init_auth_config();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(hasCustomFarmRouteContext, "hasCustomFarmRouteContext");
@@ -6404,7 +6538,7 @@ function normalizePositiveDuration(value, fallback, name) {
   return Math.floor(value);
 }
 function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function normalizeCacheOptionsTags(options) {
   const tags = /* @__PURE__ */ new Set();
@@ -6964,7 +7098,7 @@ function getProgrammaticRouteSearchClientOptions(search) {
   if (search.temporary?.length) options.temporary = [...search.temporary];
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path27, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path28, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -6973,7 +7107,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path27, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path27
+    path: path28
   });
   return { search, canonicalPath };
 }
@@ -7140,7 +7274,7 @@ function createRouteModuleFromProgrammaticPage(route) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path27) => resolveProgrammaticRouteSearch(route.search, rawSearch, path27, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path28) => resolveProgrammaticRouteSearch(route.search, rawSearch, path28, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -7538,25 +7672,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path27, options) {
+      page(path28, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path27,
+          path: path28,
           ...options
         });
       },
-      layout(path27, options) {
+      layout(path28, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path27,
+          path: path28,
           ...options
         });
       },
-      api(path27, options) {
+      api(path28, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path27,
+          path: path28,
           render,
           runtime,
           regions,
@@ -7897,13 +8031,13 @@ async function inspectStaticMetadataImage(filePath) {
   };
 }
 function getStaticMetadataImageAltPath(filePath) {
-  return import_node_path3.default.join(
-    import_node_path3.default.dirname(filePath),
-    `${import_node_path3.default.basename(filePath, import_node_path3.default.extname(filePath))}.alt.txt`
+  return import_node_path4.default.join(
+    import_node_path4.default.dirname(filePath),
+    `${import_node_path4.default.basename(filePath, import_node_path4.default.extname(filePath))}.alt.txt`
   );
 }
 function getStaticMetadataImageExtension(filePath) {
-  const extension = import_node_path3.default.extname(filePath).slice(1).toLowerCase();
+  const extension = import_node_path4.default.extname(filePath).slice(1).toLowerCase();
   return STATIC_METADATA_IMAGE_EXTENSIONS.includes(extension) ? extension : null;
 }
 async function readAltText(filePath) {
@@ -7917,13 +8051,13 @@ async function readAltText(filePath) {
     throw error;
   }
 }
-var import_node_crypto, import_promises4, import_node_path3, import_image_size, STATIC_METADATA_IMAGE_EXTENSIONS, CONTENT_TYPES;
+var import_node_crypto, import_promises4, import_node_path4, import_image_size, STATIC_METADATA_IMAGE_EXTENSIONS, CONTENT_TYPES;
 var init_static_metadata_image = __esm({
   "src/static-metadata-image.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
     import_promises4 = require("fs/promises");
-    import_node_path3 = __toESM(require("path"));
+    import_node_path4 = __toESM(require("path"));
     import_image_size = require("image-size");
     STATIC_METADATA_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp"];
     CONTENT_TYPES = {
@@ -8517,8 +8651,56 @@ var init_route_manager = __esm({
           "**/{opengraph-image,twitter-image}.{ts,tsx,js,jsx,png,jpg,jpeg,gif,webp}",
           appDir
         );
+        const canonicalPageGroups = /* @__PURE__ */ new Map();
+        for (const file of pageFiles.filter((candidate) => parseRouteSlotFile(candidate) === null)) {
+          const 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_path6.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_path6.default.join(appDir, file)).join(" and ")}.`
+            );
+          }
+          const componentFile = componentFiles[0];
+          const markdownFile = markdownFiles[0];
+          const primaryFile = componentFile || markdownFile;
+          if (!primaryFile) continue;
+          const modulePath = import_path6.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_path6.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]
@@ -10273,14 +10455,14 @@ function createRouteStateProps(input) {
     context: input.pluginExposedContext.size > 0 ? { data: input.pluginExposedContext } : void 0
   };
 }
-var import_react4, import_server, fs2, path9, import_stream, cachedClerkProvider, importRuntimeModule, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
+var import_react4, import_server, fs2, path10, import_stream, cachedClerkProvider, importRuntimeModule, _FarmRouteErrorBoundary, FarmRouteErrorBoundary, _ServerRenderer, ServerRenderer;
 var init_renderer = __esm({
   "src/server/renderer.ts"() {
     "use strict";
     import_react4 = __toESM(require("react"));
     import_server = require("react-dom/server");
     fs2 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
     init_utils();
     init_client_component();
     import_stream = require("stream");
@@ -10299,6 +10481,7 @@ var init_renderer = __esm({
     init_server2();
     init_resolver();
     init_routing();
+    init_response();
     cachedClerkProvider = null;
     importRuntimeModule = new Function("specifier", "return import(specifier);");
     __name(hasRequestHeader, "hasRequestHeader");
@@ -10365,7 +10548,7 @@ var init_renderer = __esm({
        */
       loadSSGManifest() {
         try {
-          const manifestPath = path9.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
+          const manifestPath = path10.join(this.config.root, this.config.outDir, "__ssg_manifest.json");
           if (fs2.existsSync(manifestPath)) {
             const content = fs2.readFileSync(manifestPath, "utf-8");
             this.ssgManifest = JSON.parse(content);
@@ -10540,7 +10723,7 @@ var init_renderer = __esm({
           return true;
         }
         try {
-          const htmlPath = page2.urlPath === "/" ? path9.join(this.config.root, this.config.outDir, "client", "index.html") : path9.join(this.config.root, this.config.outDir, "client", page2.urlPath + ".html");
+          const htmlPath = page2.urlPath === "/" ? path10.join(this.config.root, this.config.outDir, "client", "index.html") : path10.join(this.config.root, this.config.outDir, "client", page2.urlPath + ".html");
           if (fs2.existsSync(htmlPath)) {
             const stat = fs2.statSync(htmlPath);
             const html = fs2.readFileSync(htmlPath, "utf-8");
@@ -10991,6 +11174,15 @@ var init_renderer = __esm({
             });
           });
         } catch (error) {
+          if (isWebResponse(error)) {
+            if (!res.headersSent && !res.writableEnded) {
+              await sendWebResponse(res, error);
+            } else if (!res.writableEnded) {
+              res.end();
+            }
+            completeRender(error.status, pathname);
+            return;
+          }
           if (isFarmRedirectError(error)) {
             const redirect3 = getFarmRedirectError(error);
             const snapshot = getFarmI18nClientSnapshot();
@@ -11291,7 +11483,7 @@ var init_renderer = __esm({
         }
       }
       async renderWithSSR(element, req, res, clearMiddlewareData, options = {}) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const streamStartTime = Date.now();
           const observabilityRoute = options.observabilityRoute || req.__FARM_ROUTE__ || req.url || "/";
           const deploymentId = this.getDeploymentId();
@@ -11471,7 +11663,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                     route: observabilityRoute,
                     durationMs: Date.now() - streamStartTime
                   });
-                  resolve5();
+                  resolve6();
                 }
               });
               res.write(shell);
@@ -11482,7 +11674,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",
@@ -11497,7 +11689,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",
@@ -11513,11 +11705,11 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         res.statusCode = 404;
         const pathname = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`).pathname;
         try {
-          const appDir = path9.join(this.config.root, this.config.srcDir, "app");
+          const appDir = path10.join(this.config.root, this.config.srcDir, "app");
           const notFoundExtensions = [".tsx", ".jsx", ".ts", ".js"];
           let notFoundPath = null;
           for (const ext of notFoundExtensions) {
-            const checkPath = path9.join(appDir, `not-found${ext}`);
+            const checkPath = path10.join(appDir, `not-found${ext}`);
             if (fs2.existsSync(checkPath)) {
               notFoundPath = checkPath;
               break;
@@ -11529,7 +11721,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
             if (NotFoundComponent) {
               let LayoutComponent = null;
               for (const ext of notFoundExtensions) {
-                const layoutPath = path9.join(appDir, `layout${ext}`);
+                const layoutPath = path10.join(appDir, `layout${ext}`);
                 if (fs2.existsSync(layoutPath)) {
                   try {
                     const layoutModule = await this.routeManager.loadLayoutModule(layoutPath);
@@ -11660,6 +11852,11 @@ function isResolvedDocsConfig(value) {
 function isResolvedI18nConfig(value) {
   return Boolean(value && typeof value === "object" && "enabled" in value);
 }
+function isResolvedAuthConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && "enabled" in value && "emailAndPassword" in value && "database" in value
+  );
+}
 function createFarmApp(config, viteServer) {
   return new FarmApp(config, viteServer);
 }
@@ -11686,6 +11883,7 @@ var init_app = __esm({
     init_config();
     init_server2();
     init_cache();
+    init_auth_config();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -11740,6 +11938,7 @@ var init_app = __esm({
           deploy: config.deploy || {},
           storage: config.storage || {},
           cache: config.cache || {},
+          auth: isResolvedAuthConfig(config.auth) ? config.auth : resolveFarmAuthConfig(config.auth),
           integrations: config.integrations || {},
           plugins: config.plugins || [],
           migrations: config.migrations || { commands: [] },
@@ -11809,6 +12008,7 @@ var init_app = __esm({
     __name(_FarmApp, "FarmApp");
     FarmApp = _FarmApp;
     __name(isResolvedI18nConfig, "isResolvedI18nConfig");
+    __name(isResolvedAuthConfig, "isResolvedAuthConfig");
     __name(createFarmApp, "createFarmApp");
   }
 });
@@ -12140,12 +12340,12 @@ var init_runtime2 = __esm({
 });
 
 // src/api/route-manager.ts
-var fs3, path11, API_ROUTE_METHODS, _APIRouteManager, APIRouteManager;
+var fs3, path12, API_ROUTE_METHODS, _APIRouteManager, APIRouteManager;
 var init_route_manager2 = __esm({
   "src/api/route-manager.ts"() {
     "use strict";
     fs3 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    path12 = __toESM(require("path"));
     init_utils();
     init_routes();
     init_routes_server();
@@ -12176,7 +12376,7 @@ var init_route_manager2 = __esm({
       async discoverRoutes() {
         this.routes.clear();
         for (const appDir of this.appDirs) {
-          const apiDir = path11.join(appDir, "api");
+          const apiDir = path12.join(appDir, "api");
           let routeFiles = [];
           if (fs3.existsSync(apiDir)) {
             routeFiles = this.findRouteFiles(apiDir);
@@ -12204,7 +12404,7 @@ var init_route_manager2 = __esm({
         }
         const entries = fs3.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path11.join(dir, entry.name);
+          const fullPath = path12.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") {
@@ -12218,8 +12418,8 @@ var init_route_manager2 = __esm({
        */
       async loadRoute(filePath, appDir) {
         try {
-          const apiDir = path11.join(appDir, "api");
-          const relativePath2 = path11.relative(apiDir, path11.dirname(filePath));
+          const apiDir = path12.join(appDir, "api");
+          const relativePath2 = path12.relative(apiDir, path12.dirname(filePath));
           const routePath = "/api/" + (relativePath2 === "." ? "" : relativePath2.replace(/\\/g, "/"));
           const routeModule = await this.loadModule(filePath);
           const endpoints = {};
@@ -12270,7 +12470,7 @@ var init_route_manager2 = __esm({
         }
       }
       async loadProgrammaticApiRoutes(appDir) {
-        const candidateRoots = [path11.dirname(appDir), appDir];
+        const candidateRoots = [path12.dirname(appDir), appDir];
         const routeFiles = Array.from(
           new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
         );
@@ -12296,11 +12496,11 @@ var init_route_manager2 = __esm({
       }
       findRootRoutesFile(appDir) {
         const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
-        const candidateDirs = [path11.dirname(appDir), appDir];
+        const candidateDirs = [path12.dirname(appDir), appDir];
         const seen = /* @__PURE__ */ new Set();
         for (const dir of candidateDirs) {
           for (const routeName of routeNames) {
-            const routesFile = path11.join(dir, routeName);
+            const routesFile = path12.join(dir, routeName);
             if (seen.has(routesFile)) {
               continue;
             }
@@ -13022,11 +13222,11 @@ function resolveExistingPath(filePath) {
   try {
     return (0, import_node_fs2.realpathSync)(filePath);
   } catch {
-    return import_node_path4.default.resolve(filePath);
+    return import_node_path5.default.resolve(filePath);
   }
 }
 function isDocsSourceFile(filePath) {
-  return DOCS_FILE_EXTENSIONS.has(import_node_path4.default.extname(filePath).toLowerCase());
+  return DOCS_FILE_EXTENSIONS.has(import_node_path5.default.extname(filePath).toLowerCase());
 }
 function discoverDocsSourceFiles(contentDir) {
   const files = [];
@@ -13035,7 +13235,7 @@ function discoverDocsSourceFiles(contentDir) {
       (a, b) => a.name.localeCompare(b.name)
     )) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path4.default.join(dir, entry.name);
+      const absolutePath = import_node_path5.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
       } else if (entry.isFile() && isDocsSourceFile(absolutePath)) {
@@ -13053,7 +13253,7 @@ function getGitLastModifiedDates(contentDir) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!gitRoot) return {};
-    const contentPathspec = normalizeRelativePath(import_node_path4.default.relative(gitRoot, contentDir)) || ".";
+    const contentPathspec = normalizeRelativePath(import_node_path5.default.relative(gitRoot, contentDir)) || ".";
     const contentPrefix = contentPathspec === "." ? "" : `${contentPathspec}/`;
     const history = (0, import_node_child_process.execFileSync)(
       "git",
@@ -13095,7 +13295,7 @@ function getGitLastModifiedDates(contentDir) {
   }
 }
 function readManifest(contentDir) {
-  const manifestPath = import_node_path4.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestPath = import_node_path5.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
   if (!(0, import_node_fs2.existsSync)(manifestPath)) return null;
   try {
     const parsed = JSON.parse(
@@ -13118,14 +13318,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_path4.default.relative(resolvedContentDir, sourcePath));
+    const relativePath2 = normalizeRelativePath(import_node_path5.default.relative(resolvedContentDir, sourcePath));
     pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs2.statSync)(sourcePath).mtime.toISOString());
   }
   return { version: 1, pages };
 }
 function getLastModifiedManifest(contentDir) {
   const resolvedContentDir = resolveExistingPath(contentDir);
-  const manifestPath = import_node_path4.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestPath = import_node_path5.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
   const manifestStat = (0, import_node_fs2.existsSync)(manifestPath) ? (0, import_node_fs2.statSync)(manifestPath) : null;
   const signature = manifestStat ? `file:${manifestStat.mtimeMs}:${manifestStat.size}` : "generated";
   const cached = manifestCache.get(resolvedContentDir);
@@ -13139,21 +13339,21 @@ function resolveFarmDocsPageLastModified(contentDir, sourcePath, frontmatter) {
   if (configured) return configured;
   const resolvedContentDir = resolveExistingPath(contentDir);
   const resolvedSourcePath = resolveExistingPath(sourcePath);
-  const relativePath2 = normalizeRelativePath(import_node_path4.default.relative(resolvedContentDir, resolvedSourcePath));
-  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path4.default.isAbsolute(relativePath2);
+  const relativePath2 = normalizeRelativePath(import_node_path5.default.relative(resolvedContentDir, resolvedSourcePath));
+  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path5.default.isAbsolute(relativePath2);
   if (isInsideContentDir) {
     const generated = getLastModifiedManifest(resolvedContentDir).pages[relativePath2];
     if (generated) return generated;
   }
   return (0, import_node_fs2.statSync)(resolvedSourcePath).mtime.toISOString();
 }
-var import_node_child_process, import_node_fs2, import_node_path4, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
+var import_node_child_process, import_node_fs2, import_node_path5, 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_fs2 = require("fs");
-    import_node_path4 = __toESM(require("path"));
+    import_node_path5 = __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"]);
@@ -13186,9 +13386,9 @@ function isFarmDocsSearchEnabled(docs) {
 }
 function resolveFarmDocsSearchClientModule(root) {
   try {
-    const requireFromApp = (0, import_node_module2.createRequire)(import_node_path5.default.join(import_node_path5.default.resolve(root), "package.json"));
+    const requireFromApp = (0, import_node_module3.createRequire)(import_node_path6.default.join(import_node_path6.default.resolve(root), "package.json"));
     const themeEntry = requireFromApp.resolve("@farming-labs/theme");
-    const commandSearchModule = import_node_path5.default.join(import_node_path5.default.dirname(themeEntry), "docs-command-search.mjs");
+    const commandSearchModule = import_node_path6.default.join(import_node_path6.default.dirname(themeEntry), "docs-command-search.mjs");
     if ((0, import_node_fs3.existsSync)(commandSearchModule)) return commandSearchModule;
   } catch {
   }
@@ -13328,13 +13528,13 @@ async function mountFarmDocsSearch() {
 window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
 `;
 }
-var import_node_fs3, import_node_module2, import_node_path5;
+var import_node_fs3, import_node_module3, import_node_path6;
 var init_search_client = __esm({
   "src/docs/search-client.ts"() {
     "use strict";
     import_node_fs3 = require("fs");
-    import_node_module2 = require("module");
-    import_node_path5 = __toESM(require("path"));
+    import_node_module3 = require("module");
+    import_node_path6 = __toESM(require("path"));
     __name(isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
     __name(resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
     __name(generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
@@ -13749,12 +13949,12 @@ var init_module = __esm({
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
-var fs4, path16, _MiddlewareManager, MiddlewareManager;
+var fs4, path17, _MiddlewareManager, MiddlewareManager;
 var init_manager = __esm({
   "src/middleware/manager.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
+    path17 = __toESM(require("path"));
     init_context();
     init_module();
     init_utils();
@@ -13834,8 +14034,8 @@ var init_manager = __esm({
         const entries = fs4.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-            const subPath = path16.join(dir, entry.name);
-            const subRoutePath = path16.posix.join(routePath, entry.name);
+            const subPath = path17.join(dir, entry.name);
+            const subRoutePath = path17.posix.join(routePath, entry.name);
             await this.discoverInDirectory(subPath, subRoutePath, discovered);
           }
         }
@@ -13846,7 +14046,7 @@ var init_manager = __esm({
       findMiddlewareFile(dir) {
         const extensions = [".ts", ".tsx", ".js", ".jsx"];
         for (const ext of extensions) {
-          const filePath = path16.join(dir, `middleware${ext}`);
+          const filePath = path17.join(dir, `middleware${ext}`);
           if (fs4.existsSync(filePath)) {
             return filePath;
           }
@@ -14313,11 +14513,11 @@ var init_type_generator = __esm({
           routeGroups.get(key).push(route);
         }
         const nestedStructure = {};
-        for (const [path27, routeList] of routeGroups) {
+        for (const [path28, routeList] of routeGroups) {
           const route = routeList[0];
           const importPath = this.getRouteImportPath(route, options.outFile);
           const routeName = this.pathToRouteName(route.path);
-          const cleanPath = path27 === "/api" ? "" : path27.replace(/^\/api\//, "");
+          const cleanPath = path28 === "/api" ? "" : path28.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const allMethods = routeList.flatMap((r) => r.methods);
           for (const method of allMethods) {
@@ -14376,8 +14576,8 @@ ${typeExports}
         const relativeImport = (0, import_path10.relative)((0, import_path10.dirname)(outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path27) {
-        return (path27 === "/api" ? "root" : path27.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+      pathToRouteName(path28) {
+        return (path28 === "/api" ? "root" : path28.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "");
       }
       structureToTypeString(obj, indent) {
         const spaces = "  ".repeat(indent);
@@ -14397,15 +14597,15 @@ ${typeExports}
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path27) {
-        const cleanPath = path27.replace(/^\/api\//, "");
+      getBaseExportName(path28) {
+        const cleanPath = path28.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path27, method) {
-        const cleanPath = path27.replace(/^\/api\//, "");
+      getExportName(path28, method) {
+        const cleanPath = path28.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -14467,19 +14667,22 @@ function createRoutePattern(route) {
   }).join("/");
 }
 async function generateRouteTypes(options) {
-  const {
-    root,
-    srcDir = "src",
-    outFile = DEFAULT_OUT_FILE,
-    extraRoutes = [],
-    suppressLintOnLink = false
-  } = options;
+  const root = path18.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path18.isAbsolute(outFile) ? outFile : path18.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs5.mkdirSync(path18.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+async function createRouteTypeDeclarations(options, outPath) {
+  const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
-  const outPath = path17.join(root, srcDir, outFile);
   const patterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path17.join(source.root, source.srcDir, "app");
+    const appDir = path18.join(source.root, source.srcDir, "app");
     if (fs5.existsSync(appDir)) {
       const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
         cwd: appDir,
@@ -14508,18 +14711,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 = `./${path18.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;
@@ -14528,8 +14732,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;
   }
 }
 `;
@@ -14541,15 +14745,13 @@ declare module "@farm.js/core/dist/client.js" {
 export type RoutePath = ${routePathType};
 export type RoutePattern = ${routePatternType};${augmentationBlock}
 `;
-  fs5.mkdirSync(path17.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
-var path17, fs5, DEFAULT_OUT_FILE;
+var path18, fs5, DEFAULT_OUT_FILE;
 var init_generate_route_types = __esm({
   "src/routing/generate-route-types.ts"() {
     "use strict";
-    path17 = __toESM(require("path"));
+    path18 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
     init_route_slots();
@@ -14561,23 +14763,30 @@ var init_generate_route_types = __esm({
     __name(createRoutePattern, "createRoutePattern");
     DEFAULT_OUT_FILE = "farm-routes.d.ts";
     __name(generateRouteTypes, "generateRouteTypes");
+    __name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
   }
 });
 
 // src/env-types.ts
 async function generateEnvTypes(options) {
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const srcDir = options.srcDir || "src";
-  const outPath = path18.join(root, srcDir, options.outFile || DEFAULT_OUT_FILE2);
+  const outFile = options.outFile || DEFAULT_OUT_FILE2;
+  const outPath = path19.isAbsolute(outFile) ? outFile : path19.join(root, srcDir, outFile);
+  const content = createEnvTypeDeclarations(options, outPath);
+  fs6.mkdirSync(path19.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+function createEnvTypeDeclarations(options, outPath) {
+  const root = path19.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(path18.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
 function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
   const imports = configPaths.map(
@@ -14633,11 +14842,11 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path18.isAbsolute(configPath) ? configPath : path18.join(root, configPath);
+    const resolvedPath = path19.isAbsolute(configPath) ? configPath : path19.join(root, configPath);
     return fs6.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path18.join(root, filename);
+    const resolvedPath = path19.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -14698,15 +14907,15 @@ export {};
 `;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path18.relative(path18.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path19.relative(path19.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs6, path18, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
+var fs6, path19, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
 var init_env_types = __esm({
   "src/env-types.ts"() {
     "use strict";
     fs6 = __toESM(require("fs"));
-    path18 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_write_file_if_changed();
     DEFAULT_OUT_FILE2 = "farm-env.d.ts";
     CONFIG_FILENAMES2 = [
@@ -14728,6 +14937,7 @@ var init_env_types = __esm({
       "config.cjs"
     ];
     __name(generateEnvTypes, "generateEnvTypes");
+    __name(createEnvTypeDeclarations, "createEnvTypeDeclarations");
     __name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
     __name(findConfigPath, "findConfigPath");
     __name(createConfigBackedEnvTypes, "createConfigBackedEnvTypes");
@@ -14738,8 +14948,8 @@ var init_env_types = __esm({
 
 // src/image-types.ts
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path6.default.resolve(options.root, options.outFile) : import_node_path6.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs5.mkdirSync)(import_node_path6.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path7.default.resolve(options.root, options.outFile) : import_node_path7.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs5.mkdirSync)(import_node_path7.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -14763,12 +14973,12 @@ declare module "*?url" {
 }
 `;
 }
-var import_node_fs5, import_node_path6, FARM_STATIC_IMAGE_EXTENSIONS;
+var import_node_fs5, import_node_path7, FARM_STATIC_IMAGE_EXTENSIONS;
 var init_image_types = __esm({
   "src/image-types.ts"() {
     "use strict";
     import_node_fs5 = require("fs");
-    import_node_path6 = __toESM(require("path"));
+    import_node_path7 = __toESM(require("path"));
     init_write_file_if_changed();
     FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
     __name(generateFarmImageTypes, "generateFarmImageTypes");
@@ -14780,9 +14990,9 @@ var init_image_types = __esm({
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? (0, import_node_path7.resolve)(options.root, options.outFile) : (0, import_node_path7.join)((0, import_node_path7.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path8.resolve)(options.root, options.outFile) : (0, import_node_path8.join)((0, import_node_path8.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs6.mkdirSync)((0, import_node_path7.dirname)(outFile), { recursive: true });
+  (0, import_node_fs6.mkdirSync)((0, import_node_path8.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -14823,12 +15033,12 @@ function argumentType(kind) {
       return "string";
   }
 }
-var import_node_fs6, import_node_path7;
+var import_node_fs6, import_node_path8;
 var init_type_generator2 = __esm({
   "src/i18n/type-generator.ts"() {
     "use strict";
     import_node_fs6 = require("fs");
-    import_node_path7 = require("path");
+    import_node_path8 = require("path");
     init_catalog();
     init_write_file_if_changed();
     __name(generateFarmI18nTypes, "generateFarmI18nTypes");
@@ -14852,7 +15062,10 @@ async function generateFarmTypeArtifacts(options) {
   const result = {
     apiRoutes: []
   };
-  if (shouldGenerateRoutes) {
+  const unifiedTypesPath = (0, import_path11.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,
@@ -14860,10 +15073,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);
@@ -14875,22 +15095,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,
@@ -14898,9 +15136,35 @@ async function generateFarmTypeArtifacts(options) {
       outFile: options.i18nTypesOutFile
     });
   }
+  if (shouldRefreshUnifiedTypes) {
+    (0, import_fs4.mkdirSync)((0, import_path11.dirname)(unifiedTypesPath), { recursive: true });
+    writeFileIfChanged(
+      unifiedTypesPath,
+      `/**
+ * Generated by Farm.js. Do not edit.
+ * Contains project-specific route, environment, and internationalization types.
+ */
+
+import "@farm.js/core/image";
+
+${unifiedSections.join("\n")}`
+    );
+    result.typesPath = unifiedTypesPath;
+    removeLegacyTypeArtifacts(root, srcDir);
+  }
   return result;
 }
-var import_fs4, import_path11;
+function removeLegacyTypeArtifacts(root, srcDir) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path11.join)(root, srcDir, fileName);
+    if (!(0, import_fs4.existsSync)(filePath)) continue;
+    const source = (0, import_fs4.readFileSync)(filePath, "utf8");
+    if (source.includes(marker)) {
+      (0, import_fs4.unlinkSync)(filePath);
+    }
+  }
+}
+var import_fs4, import_path11, LEGACY_TYPE_ARTIFACTS;
 var init_type_artifacts = __esm({
   "src/type-artifacts.ts"() {
     "use strict";
@@ -14911,9 +15175,17 @@ var init_type_artifacts = __esm({
     init_env_types();
     init_image_types();
     init_type_generator2();
+    init_catalog();
     init_layers();
     init_write_file_if_changed();
     __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+    LEGACY_TYPE_ARTIFACTS = [
+      ["farm-routes.d.ts", "Auto-generated route types"],
+      ["farm-env.d.ts", "Auto-generated env types"],
+      ["farm-images.d.ts", "Generated by Farm.js"],
+      ["farm-i18n.d.ts", "Generated by Farm.js"]
+    ];
+    __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
   }
 });
 
@@ -14921,7 +15193,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.5";
+    version = "0.1.0-beta.8";
   }
 });
 
@@ -14958,8 +15230,8 @@ function reportAfterError(state, error) {
 function createAfterRequestState(reportError = defaultAfterErrorReporter) {
   let resolveResponseFinished;
   let responseFinished = false;
-  const responseFinishedPromise = new Promise((resolve5) => {
-    resolveResponseFinished = resolve5;
+  const responseFinishedPromise = new Promise((resolve6) => {
+    resolveResponseFinished = resolve6;
   });
   const state = {
     completion: Promise.resolve(),
@@ -15101,12 +15373,12 @@ async function createBlurDataURL(bytes) {
     return void 0;
   }
 }
-var import_promises6, import_node_path8, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
+var import_promises6, import_node_path9, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
 var init_image_vite = __esm({
   "src/image-vite.ts"() {
     "use strict";
     import_promises6 = require("fs/promises");
-    import_node_path8 = __toESM(require("path"));
+    import_node_path9 = __toESM(require("path"));
     import_image_size2 = require("image-size");
     FARM_IMAGE_ID_PREFIX = "\0farm:image:";
     STATIC_IMAGE_RE = /\.(?:avif|gif|jpe?g|png|webp)$/i;
@@ -15954,8 +16226,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 {
@@ -16169,8 +16441,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 {
@@ -16210,38 +16482,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;
   }
 }
 
@@ -16828,9 +17092,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}`;
     }
@@ -16865,10 +17129,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;
@@ -16882,16 +17146,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 [];
@@ -16914,10 +17178,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);
@@ -16978,9 +17242,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 "";
@@ -16998,7 +17262,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;
@@ -17837,13 +18101,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 "";
@@ -17851,13 +18115,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)}`;
@@ -17973,7 +18237,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; }
@@ -18041,7 +18305,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; }
@@ -18051,13 +18315,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}
   `;
@@ -18176,13 +18438,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");
@@ -19154,8 +19416,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path27, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path27);
+        for (const [path28, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path28);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -19169,8 +19431,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path27) {
-        return path27.replace(/^\/api/, "");
+      convertToOpenAPIPath(path28) {
+        return path28.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -19332,8 +19594,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path27, method) {
-        const cleanPath = path27.replace(/^\/api\//, "");
+      generateSummary(path28, method) {
+        const cleanPath = path28.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;
@@ -19342,22 +19604,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path27, method) {
-        const cleanPath = path27.replace(/^\/api\//, "");
+      generateDescription(path28, method) {
+        const cleanPath = path28.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path27, method) {
-        const cleanPath = path27.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path28, method) {
+        const cleanPath = path28.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path27) {
-        const cleanPath = path27.replace(/^\/api\//, "");
+      generateTags(path28) {
+        const cleanPath = path28.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -19370,8 +19632,8 @@ var init_generator = __esm({
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
         const fs8 = require("fs");
-        const path27 = require("path");
-        const dir = path27.dirname(outputPath);
+        const path28 = require("path");
+        const dir = path28.dirname(outputPath);
         if (!fs8.existsSync(dir)) {
           fs8.mkdirSync(dir, { recursive: true });
         }
@@ -19791,7 +20053,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 || "/",
@@ -19840,11 +20102,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();
@@ -21668,7 +21930,7 @@ function fileContainsProgrammaticPageRoute(file) {
 }
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path23.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path24.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -21688,7 +21950,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 = path23.resolve(path23.dirname(cleanId), sourcePath);
+    const resolvedPath = path24.resolve(path24.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -21764,7 +22026,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path23.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path24.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -21789,9 +22051,9 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path23.join(server.config.root, "src/app/globals.css");
+      const globalsCSSPath = path24.join(server.config.root, "src/app/globals.css");
       if (!fs7.existsSync(globalsCSSPath)) {
-        const appDir = path23.join(server.config.root, "src/app");
+        const appDir = path24.join(server.config.root, "src/app");
         if (!fs7.existsSync(appDir)) {
           fs7.mkdirSync(appDir, { recursive: true });
         }
@@ -21813,10 +22075,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path23.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path24.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path23.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path24.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -21826,7 +22088,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path23.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path24.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -21866,7 +22128,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path23.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path24.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -21984,7 +22246,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs7.existsSync(path23.isAbsolute(dir) ? dir : path23.join(farmConfig.root, dir))
+        (dir) => fs7.existsSync(path24.isAbsolute(dir) ? dir : path24.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -22062,14 +22324,14 @@ function farmPlugin(options = {}, initialPluginManager) {
         farmDocsDevRuntime ? [
           [
             "/assets/Geist-Variable-CrgPqtmy.woff2",
-            path23.join(
+            path24.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-sans/Geist-Variable.woff2"
             )
           ],
           [
             "/assets/GeistMono-Variable-BNLlm6Cd.woff2",
-            path23.join(
+            path24.join(
               farmConfig.root,
               "node_modules/geist/dist/fonts/geist-mono/GeistMono-Variable.woff2"
             )
@@ -22233,12 +22495,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")
           });
@@ -22259,16 +22522,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);
                 });
               });
             }
@@ -22311,13 +22595,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);
                   });
                 });
               }
@@ -22423,13 +22707,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);
                     });
                   });
                 }
@@ -22486,13 +22770,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);
                     });
                   });
                 }
@@ -23212,8 +23496,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path23.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path23.join(outDir, "client");
+        const outDir = path24.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path24.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -23265,8 +23549,8 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page2.urlPath === "/" ? path23.join(clientDir, "index.html") : path23.join(clientDir, page2.urlPath + ".html");
-              fs7.mkdirSync(path23.dirname(outputPath), { recursive: true });
+              const outputPath = page2.urlPath === "/" ? path24.join(clientDir, "index.html") : path24.join(clientDir, page2.urlPath + ".html");
+              fs7.mkdirSync(path24.dirname(outputPath), { recursive: true });
               fs7.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
@@ -23275,7 +23559,7 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path23.join(outDir, "__ssg_manifest.json");
+        const manifestPath = path24.join(outDir, "__ssg_manifest.json");
         fs7.writeFileSync(
           manifestPath,
           JSON.stringify(
@@ -23311,9 +23595,9 @@ if (import.meta.hot) {
       }
       const currentFarmConfig = farmApp?.getConfig();
       const normalizedFile = file.replace(/\\/g, "/");
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path23.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path24.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path23.basename(file)}`);
+        logUpdate("PAGE", `updated ${path24.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -24350,6 +24634,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,
@@ -24863,7 +25148,7 @@ function generateClientManifest(bundle) {
 }
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path23.resolve(config.root || process.cwd());
+  const appRoot = path24.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, {
@@ -25049,7 +25334,7 @@ async function defineConfig2(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path23.resolve(appRoot, "src"),
+        "@": path24.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 {};",
@@ -25066,7 +25351,7 @@ async function defineConfig2(config = {}) {
     }
   };
 }
-var fs7, path23, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
+var fs7, path24, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
 var init_vite = __esm({
   "src/vite.ts"() {
     "use strict";
@@ -25087,7 +25372,7 @@ var init_vite = __esm({
     init_route_context();
     init_devtools_config();
     fs7 = __toESM(require("fs"));
-    path23 = __toESM(require("path"));
+    path24 = __toESM(require("path"));
     init_layers();
     init_environment_vite();
     init_version();
@@ -25103,7 +25388,7 @@ var init_vite = __esm({
       routes: true,
       api: true,
       env: true,
-      images: true,
+      images: false,
       i18n: true
     };
     createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -27211,10 +27496,14 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
     const routeRuntimeManifestResultPromise = Promise.allSettled([routeRuntimeManifestPromise]);
     const pageRoutes = [];
     for (const [pattern, entry] of routeManager.getRoutes()) {
+      const markdownSourcePath = entry.markdownSourcePath || (isFarmMarkdownPageFile(entry.modulePath) ? entry.modulePath : void 0);
       pageRoutes.push({
         pattern,
         modulePath: entry.modulePath,
-        ...isFarmMarkdownPageFile(entry.modulePath) ? { source: (0, import_fs5.readFileSync)(entry.modulePath, "utf8") } : {}
+        ...markdownSourcePath ? {
+          source: (0, import_fs5.readFileSync)(markdownSourcePath, "utf8"),
+          markdownSourcePath
+        } : {}
       });
     }
     const routeSlots = Array.from(
@@ -29125,15 +29414,13 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   });
   const pageImports = [];
   const pageRegistrations = [];
-  const hasMarkdownPages = pageRoutes.some(
-    (route) => route.source !== void 0 || isFarmMarkdownPageFile(route.modulePath)
-  );
+  const hasMarkdownPages = pageRoutes.some((route) => route.source !== void 0);
   const orderedPageRoutes = pageRoutes.map((route, index) => ({ route, index })).sort(
     (left, right) => routePatternSpecificity(right.route.pattern) - routePatternSpecificity(left.route.pattern) || left.index - right.index
   ).map(({ route }) => route);
   orderedPageRoutes.forEach((route, index) => {
     const varName = `pageRoute${index}`;
-    if (route.source !== void 0 || isFarmMarkdownPageFile(route.modulePath)) {
+    if (isFarmMarkdownPageFile(route.modulePath)) {
       pageRegistrations.push(`
   {
     pattern: ${JSON.stringify(route.pattern)},
@@ -29145,7 +29432,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
     }),
     markdownSource: {
       source: ${JSON.stringify(route.source ?? "")},
-      filePath: ${JSON.stringify(route.modulePath)},
+      filePath: ${JSON.stringify(route.markdownSourcePath ?? route.modulePath)},
     },
   }`);
       return;
@@ -29157,6 +29444,10 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
     pattern: ${JSON.stringify(route.pattern)},
     module: ${varName},
     shouldHydrate: ${JSON.stringify(shouldHydrate)},
+    ${route.source !== void 0 ? `markdownSource: {
+      source: ${JSON.stringify(route.source)},
+      filePath: ${JSON.stringify(route.markdownSourcePath)},
+    },` : ""}
   }`);
   });
   const layoutImports = [];
@@ -29262,7 +29553,7 @@ function generateVirtualEntryCode(apiRoutes, pageRoutes, layoutRoutes, routeSlot
   const docsRuntimeImport = config.docs?.enabled ? `import { existsSync as farmDocsExistsSync } from "node:fs";
 import { dirname as farmDocsDirname, join as farmDocsJoin } from "node:path";
 import { fileURLToPath as farmDocsFileURLToPath } from "node:url";` : "";
-  const markdownHandlerImport = config.md?.enabled ? `import { createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
+  const markdownHandlerImport = config.md?.enabled ? `import { applyMarkdownNegotiationHeaders, createMarkdownMirrorResponse } from "@farm.js/core/markdown";` : "";
   const appMarkdownImport = hasMarkdownPages ? `import { createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse } from "@farm.js/core/app-markdown";` : "const createFarmMarkdownSourceResponse = null;";
   const mdxComponentsPath = typeof config.mdx?.components === "string" ? import_path12.default.isAbsolute(config.mdx.components) ? config.mdx.components : import_path12.default.join(config.root, config.mdx.components) : null;
   const mdxComponentsImport = mdxComponentsPath ? `import * as FarmMdxComponentsModule from "${mdxComponentsPath.replace(/\\/g, "/")}";` : "";
@@ -29512,10 +29803,12 @@ function serializeFarmInlineValue(value) {
     .replace(/\\u2029/g, "\\\\u2029");
 }
 
-function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots) {
+function renderFarmClientBootstrapScript(canonicalPath, selectedRouteSlots, pageProps) {
   const integrationManifest = ${hasRuntimeIntegrationConfig ? "getRegisteredIntegrationAPIManifest()" : "{}"};
   const serializedRouteSlots = serializeFarmInlineValue(selectedRouteSlots || []);
-  let source = 'window.__FARM_INTEGRATION_API_MANIFEST__=' +
+  const serializedPageProps = serializeFarmInlineValue(pageProps || {});
+  let source = 'window.__FARM_PROPS__=' + serializedPageProps +
+    ';window.__FARM_INTEGRATION_API_MANIFEST__=' +
     serializeFarmInlineValue(integrationManifest) +
     ';window.__FARM_ROUTE_SLOTS__=' + serializedRouteSlots + ';';
   if (typeof canonicalPath === "string" && canonicalPath.startsWith("/")) {
@@ -30566,7 +30859,7 @@ async function getCachedPPRShell(cacheKey) {
  * Main request handler - created at runtime with bundled routes
  */
 async function handleFarmRequest(request) {
-  ${config.i18n.enabled ? `return _runWithFarmI18nRequest(
+  const response = await ${config.i18n.enabled ? `_runWithFarmI18nRequest(
     farmI18nRuntime,
     request,
     async function(farmLocaleResolution) {
@@ -30585,7 +30878,15 @@ async function handleFarmRequest(request) {
       const response = await handleFarmRequestInContext(request, farmLocaleResolution);
       return applyFarmI18nResponse(response, farmLocaleResolution);
     }
-  );` : "return handleFarmRequestInContext(request, null);"}
+  )` : "handleFarmRequestInContext(request, null)"};
+  ${config.md?.enabled ? `const pathname = getFarmRoutePathname(new URL(request.url).pathname);
+  if (matchPageRoute(pathname)) {
+    return applyMarkdownNegotiationHeaders(response, {
+      config: farmMarkdownConfig,
+      pathname,
+    });
+  }` : ""}
+  return response;
 }
 
 async function handleFarmRequestInContext(
@@ -30947,6 +31248,23 @@ async function handleFarmRequestInContext(
             return { ...slot, props: slotProps };
           }),
         );
+        const clientMiddleware = middlewareData?.size
+          ? { data: Object.fromEntries(middlewareData) }
+          : undefined;
+        const clientPageProps = {
+          params: pageProps.params,
+          search: pageProps.search ?? searchParamsObj,
+          searchParams: pageProps.search ?? searchParamsObj,
+          ...("data" in pageProps ? { data: pageProps.data } : {}),
+          ...(pageProps.__farmCanonicalPath
+            ? { __farmCanonicalPath: pageProps.__farmCanonicalPath }
+            : {}),
+          ...(pageProps.__farmRoutePropsResolved
+            ? { __farmRoutePropsResolved: true }
+            : {}),
+          path: pathname,
+          ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
+        };
         const routeSlotPayload = renderedRouteSlots.map(function(slot) {
           return {
             name: slot.name,
@@ -30961,6 +31279,7 @@ async function handleFarmRequestInContext(
               searchParams: slot.props.search || searchParamsObj,
               ...("data" in slot.props ? { data: slot.props.data } : {}),
               path: pathname,
+              ...(clientMiddleware ? { middleware: clientMiddleware } : {}),
             },
           };
         });
@@ -31116,7 +31435,8 @@ async function handleFarmRequestInContext(
           const streamSuffix = '</div>\\n' +
             '  ' + renderFarmClientBootstrapScript(
               pageProps.__farmCanonicalPath,
-              routeSlotPayload
+              routeSlotPayload,
+              clientPageProps
             ) + '\\n' +
             '  <script type="module" src="/farm-client.js"></script>\\n' +
             '</body>\\n</html>';
@@ -31176,7 +31496,8 @@ async function handleFarmRequestInContext(
               /<\\/body>/i,
               '  ' + renderFarmClientBootstrapScript(
                 pageProps.__farmCanonicalPath,
-                routeSlotPayload
+                routeSlotPayload,
+                clientPageProps
               ) + '\\n' +
                 '  <script type="module" src="/farm-client.js"></script>\\n</body>',
             );
@@ -31198,7 +31519,7 @@ async function handleFarmRequestInContext(
 </head>
 <body>
   <div id="root">\${html}</div>
-  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload)}
+  \${renderFarmClientBootstrapScript(pageProps.__farmCanonicalPath, routeSlotPayload, clientPageProps)}
   <script type="module" src="/farm-client.js"></script>
 </body>
 </html>\`;