@farm.js/core 0.1.0-beta.14 → 0.1.0-beta.17

package/dist/internal/build-runtime.cjs

@@ -4303,6 +4303,13 @@ var init_cache_invalidation = __esm({
   }
 });
 
+// src/server-fn-error.ts
+var init_server_fn_error = __esm({
+  "src/server-fn-error.ts"() {
+    "use strict";
+  }
+});
+
 // src/server-action-security.ts
 function resolveServerActionsConfig(config) {
   const allowedOrigins = (config?.allowedOrigins ?? []).map(normalizeAllowedOriginPattern);
@@ -4396,6 +4403,7 @@ var init_server_action_security = __esm({
     "use strict";
     import_node_async_hooks = require("async_hooks");
     init_cache_invalidation();
+    init_server_fn_error();
     DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1e6;
     SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
     __name(resolveServerActionsConfig, "resolveServerActionsConfig");
@@ -4865,6 +4873,15 @@ var init_layers = __esm({
 });
 
 // src/deployment.ts
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
 function normalizeFarmDeploymentId(value) {
   if (typeof value !== "string" || value.trim() === "") {
     throw new TypeError("Farm deploymentId must be a non-empty string");
@@ -4940,6 +4957,7 @@ var init_deployment = __esm({
     FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
     FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
     FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+    __name(getFarmPresetRuntime, "getFarmPresetRuntime");
     __name(normalizeFarmDeploymentId, "normalizeFarmDeploymentId");
     __name(getFarmRequestDeploymentId, "getFarmRequestDeploymentId");
     __name(getFarmDeploymentMismatch, "getFarmDeploymentMismatch");
@@ -5388,6 +5406,143 @@ var init_preload = __esm({
   }
 });
 
+// src/security.ts
+function resolveFarmSecurityConfig(input) {
+  if (input === void 0) return { csp: false };
+  if (!isPlainRecord(input)) {
+    throw new TypeError("security must be an object containing the csp option.");
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "contentSecurityPolicy")) {
+    throw new TypeError(
+      "security.contentSecurityPolicy is not supported. Use security.csp instead."
+    );
+  }
+  const csp = input.csp;
+  if (csp === void 0 || csp === false) return { csp: false };
+  if (typeof csp === "string") {
+    return {
+      csp: {
+        value: validateSerializedCsp(csp),
+        reportOnly: false
+      }
+    };
+  }
+  if (!isPlainRecord(csp)) {
+    throw new TypeError("security.csp must be a policy string, false, or an options object.");
+  }
+  const reportOnly = validateReportOnly(csp.reportOnly);
+  if (Object.prototype.hasOwnProperty.call(csp, "value")) {
+    if (Object.prototype.hasOwnProperty.call(csp, "policy") || Object.prototype.hasOwnProperty.call(csp, "directives")) {
+      throw new TypeError(
+        "Resolved security.csp values cannot include policy or directives options."
+      );
+    }
+    return {
+      csp: {
+        value: validateSerializedCsp(csp.value),
+        reportOnly
+      }
+    };
+  }
+  const { policy, directives } = csp;
+  if (policy !== void 0 && directives !== void 0) {
+    throw new TypeError("security.csp accepts either policy or directives, not both.");
+  }
+  if (policy === void 0 && directives === void 0) {
+    throw new TypeError("security.csp requires a policy string or directives object.");
+  }
+  return {
+    csp: {
+      value: policy !== void 0 ? validateSerializedCsp(policy) : serializeFarmCspDirectives(directives),
+      reportOnly
+    }
+  };
+}
+function serializeFarmCspDirectives(directives) {
+  if (!isPlainRecord(directives)) {
+    throw new TypeError("security.csp.directives must be an object.");
+  }
+  const serialized = [];
+  const normalizedNames = /* @__PURE__ */ new Set();
+  for (const [configuredName, configuredValue] of Object.entries(directives)) {
+    if (configuredValue === false || configuredValue === null || configuredValue === void 0) {
+      continue;
+    }
+    const name = normalizeDirectiveName(configuredName);
+    if (normalizedNames.has(name)) {
+      throw new TypeError(`security.csp contains the duplicate directive ${JSON.stringify(name)}.`);
+    }
+    normalizedNames.add(name);
+    const values = configuredValue === true ? [] : (Array.isArray(configuredValue) ? configuredValue : [configuredValue]).map(
+      validateDirectiveValue
+    );
+    serialized.push(values.length > 0 ? `${name} ${values.join(" ")}` : name);
+  }
+  if (serialized.length === 0) {
+    throw new TypeError("security.csp.directives must contain at least one enabled directive.");
+  }
+  return serialized.join("; ");
+}
+function getFarmSecurityHeader(security) {
+  if (!security.csp) return void 0;
+  return {
+    key: security.csp.reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy",
+    value: security.csp.value
+  };
+}
+function normalizeDirectiveName(value) {
+  const name = value.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new TypeError(`Invalid security.csp directive name: ${JSON.stringify(value)}.`);
+  }
+  return name;
+}
+function validateDirectiveValue(value) {
+  if (typeof value !== "string") {
+    throw new TypeError("security.csp directive values must be strings or booleans.");
+  }
+  const normalized = value.trim();
+  if (!normalized || /[;\r\n]/.test(normalized) || normalized.includes("\0")) {
+    throw new TypeError(`Invalid security.csp directive value: ${JSON.stringify(value)}.`);
+  }
+  return normalized;
+}
+function validateSerializedCsp(value) {
+  if (typeof value !== "string") {
+    throw new TypeError("security.csp policy must be a non-empty single-line string.");
+  }
+  const normalized = value.trim().replace(/;+$/g, "").trim();
+  if (!normalized || /[\r\n]/.test(normalized) || normalized.includes("\0")) {
+    throw new TypeError("security.csp policy must be a non-empty single-line string.");
+  }
+  return normalized;
+}
+function validateReportOnly(value) {
+  if (value === void 0) return false;
+  if (typeof value !== "boolean") {
+    throw new TypeError("security.csp.reportOnly must be a boolean.");
+  }
+  return value;
+}
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var init_security = __esm({
+  "src/security.ts"() {
+    "use strict";
+    __name(resolveFarmSecurityConfig, "resolveFarmSecurityConfig");
+    __name(serializeFarmCspDirectives, "serializeFarmCspDirectives");
+    __name(getFarmSecurityHeader, "getFarmSecurityHeader");
+    __name(normalizeDirectiveName, "normalizeDirectiveName");
+    __name(validateDirectiveValue, "validateDirectiveValue");
+    __name(validateSerializedCsp, "validateSerializedCsp");
+    __name(validateReportOnly, "validateReportOnly");
+    __name(isPlainRecord, "isPlainRecord");
+  }
+});
+
 // src/config-entry.ts
 var init_config_entry = __esm({
   "src/config-entry.ts"() {
@@ -5649,6 +5804,8 @@ async function resolveConfig(userConfig, mode) {
   const routeRules = normalizeRouteRules(userConfig.routeRules);
   const routeRuleRedirects = routeRulesToRedirects(routeRules);
   const routeRuleHeaders = routeRulesToHeaders(routeRules);
+  const security = resolveFarmSecurityConfig(userConfig.security);
+  const securityHeader = getFarmSecurityHeader(security);
   const deploy = resolveDeployConfig(userConfig);
   const root = userConfig.root || process.cwd();
   const srcDir = userConfig.srcDir || "src";
@@ -5704,7 +5861,11 @@ async function resolveConfig(userConfig, mode) {
     trailingSlash: userConfig.trailingSlash ?? false,
     redirects: /* @__PURE__ */ __name(() => [...redirects, ...routeRuleRedirects], "redirects"),
     rewrites: /* @__PURE__ */ __name(() => rewrites, "rewrites"),
-    headers: /* @__PURE__ */ __name(() => [...headers, ...routeRuleHeaders], "headers"),
+    headers: /* @__PURE__ */ __name(() => [
+      ...headers,
+      ...routeRuleHeaders,
+      ...securityHeader ? [{ source: "/*", headers: [securityHeader] }] : []
+    ], "headers"),
     routeRules,
     images: resolveFarmImageConfig(userConfig.images),
     performance: resolveFarmPerformanceConfig(userConfig.performance),
@@ -5723,6 +5884,7 @@ async function resolveConfig(userConfig, mode) {
     notFound: userConfig.notFound || {},
     context: userConfig.context || (() => void 0),
     serverActions: resolveServerActionsConfig(userConfig.serverActions),
+    security,
     deploymentId,
     output: userConfig.output || "standalone",
     distDir: userConfig.distDir || ".farm",
@@ -5802,6 +5964,7 @@ var init_config2 = __esm({
     init_config();
     init_auth_config();
     init_preload();
+    init_security();
     init_config_entry();
     FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
     __name(hasCustomFarmRouteContext, "hasCustomFarmRouteContext");
@@ -13522,6 +13685,7 @@ var init_app = __esm({
     init_cache();
     init_auth_config();
     init_preload();
+    init_security();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -13586,6 +13750,7 @@ var init_app = __esm({
           routeRules: normalizeRouteRules(config.routeRules),
           context: config.context || (() => void 0),
           serverActions: resolveServerActionsConfig(config.serverActions),
+          security: resolveFarmSecurityConfig(config.security),
           images: resolveFarmImageConfig(config.images),
           performance: resolveFarmPerformanceConfig(config.performance),
           i18n: isResolvedI18nConfig(config.i18n) ? config.i18n : resolveFarmI18nConfig(config.i18n, {
@@ -15224,6 +15389,126 @@ var init_fonts = __esm({
   }
 });
 
+// src/server/vite-config.ts
+function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
+  const resolvedProjectRoot = import_node_path9.default.resolve(projectRoot);
+  return appDirectories.map((appDirectory) => {
+    const relativeAppDirectory = import_node_path9.default.relative(resolvedProjectRoot, import_node_path9.default.resolve(appDirectory)).replace(/\\/g, "/");
+    const prefix = relativeAppDirectory || ".";
+    return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
+  });
+}
+function createFarmClientOptimizeDepsConfig(entries) {
+  return {
+    // Keep normal application dependency discovery for CJS-only packages, but
+    // seed every Farm browser runtime so React is present in the first crawl.
+    noDiscovery: false,
+    // Waiting for the crawl avoids serving a partial optimizer generation and
+    // then changing browser hashes while hydration is already in progress.
+    holdUntilCrawlEnd: true,
+    include: [...FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE],
+    // Farm's HTML boots through a virtual module and imports route UI lazily.
+    // Explicit entries let Vite finish that crawl before a navigation can
+    // rotate the optimizer hash underneath a hydrated React runtime.
+    ...entries?.length ? { entries: [...entries] } : {}
+  };
+}
+function createFarmSourceAlias(projectRoot, srcDir = "src") {
+  return {
+    "@": import_node_path9.default.resolve(projectRoot, srcDir)
+  };
+}
+function mergeNoExternal(farmValue, userValue) {
+  if (farmValue === true || userValue === true) return true;
+  const normalize = /* @__PURE__ */ __name((value) => value == null || value === true ? [] : Array.isArray(value) ? value : [value], "normalize");
+  return Array.from(/* @__PURE__ */ new Set([...normalize(farmValue), ...normalize(userValue)]));
+}
+function mergeAlias(farmValue, userValue) {
+  if (!farmValue) return userValue || {};
+  if (!userValue) return farmValue;
+  if (!Array.isArray(farmValue) && !Array.isArray(userValue)) {
+    return {
+      ...farmValue,
+      ...userValue
+    };
+  }
+  const normalize = /* @__PURE__ */ __name((value) => Array.isArray(value) ? [...value] : Object.entries(value).map(([find, replacement]) => ({ find, replacement })), "normalize");
+  return [...normalize(userValue), ...normalize(farmValue)];
+}
+function mergeFarmViteConfig(farmConfig, userConfig = {}) {
+  const noDiscovery = userConfig.optimizeDeps?.noDiscovery ?? farmConfig.optimizeDeps?.noDiscovery;
+  const holdUntilCrawlEnd = userConfig.optimizeDeps?.holdUntilCrawlEnd ?? (userConfig.optimizeDeps?.noDiscovery === true ? false : farmConfig.optimizeDeps?.holdUntilCrawlEnd);
+  return {
+    ...farmConfig,
+    ...userConfig,
+    plugins: [...farmConfig.plugins || [], ...userConfig.plugins || []],
+    server: {
+      ...farmConfig.server,
+      ...userConfig.server
+    },
+    resolve: {
+      ...farmConfig.resolve,
+      ...userConfig.resolve,
+      alias: mergeAlias(farmConfig.resolve?.alias, userConfig.resolve?.alias),
+      dedupe: Array.from(
+        /* @__PURE__ */ new Set([...farmConfig.resolve?.dedupe || [], ...userConfig.resolve?.dedupe || []])
+      )
+    },
+    optimizeDeps: {
+      ...farmConfig.optimizeDeps,
+      ...userConfig.optimizeDeps,
+      noDiscovery,
+      holdUntilCrawlEnd,
+      include: Array.from(
+        /* @__PURE__ */ new Set([
+          ...farmConfig.optimizeDeps?.include || [],
+          ...userConfig.optimizeDeps?.include || []
+        ])
+      ),
+      exclude: Array.from(
+        /* @__PURE__ */ new Set([
+          ...farmConfig.optimizeDeps?.exclude || [],
+          ...userConfig.optimizeDeps?.exclude || []
+        ])
+      )
+    },
+    ssr: {
+      ...farmConfig.ssr,
+      ...userConfig.ssr,
+      noExternal: mergeNoExternal(farmConfig.ssr?.noExternal, userConfig.ssr?.noExternal)
+    }
+  };
+}
+var import_node_path9, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
+var init_vite_config = __esm({
+  "src/server/vite-config.ts"() {
+    "use strict";
+    import_node_path9 = __toESM(require("path"));
+    FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
+    FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
+      "react",
+      "react-dom",
+      "react-dom/client",
+      "react/jsx-runtime",
+      "react/jsx-dev-runtime",
+      "@farm.js/core/client",
+      "@farm.js/core/plugin/client",
+      "@farm.js/core/deferred",
+      "@farm.js/core/deployment",
+      "@farm.js/core/i18n/client",
+      "@farm.js/core/query/client",
+      "@farm.js/core/server-fn/client",
+      "@farm.js/core/server-query/client"
+    ];
+    __name(createFarmClientOptimizeDepsEntries, "createFarmClientOptimizeDepsEntries");
+    __name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
+    __name(createFarmSourceAlias, "createFarmSourceAlias");
+    __name(mergeNoExternal, "mergeNoExternal");
+    __name(mergeAlias, "mergeAlias");
+    __name(mergeFarmViteConfig, "mergeFarmViteConfig");
+  }
+});
+
 // src/default-styles.ts
 var defaultGlobalCSS;
 var init_default_styles = __esm({
@@ -15631,12 +15916,12 @@ var init_module = __esm({
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
-var fs4, path19, _MiddlewareManager, MiddlewareManager;
+var fs4, path20, _MiddlewareManager, MiddlewareManager;
 var init_manager = __esm({
   "src/middleware/manager.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
+    path20 = __toESM(require("path"));
     init_context();
     init_module();
     init_utils();
@@ -15716,8 +16001,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 = path19.join(dir, entry.name);
-            const subRoutePath = path19.posix.join(routePath, entry.name);
+            const subPath = path20.join(dir, entry.name);
+            const subRoutePath = path20.posix.join(routePath, entry.name);
             await this.discoverInDirectory(subPath, subRoutePath, discovered);
           }
         }
@@ -15728,7 +16013,7 @@ var init_manager = __esm({
       findMiddlewareFile(dir) {
         const extensions = [".ts", ".tsx", ".js", ".jsx"];
         for (const ext of extensions) {
-          const filePath = path19.join(dir, `middleware${ext}`);
+          const filePath = path20.join(dir, `middleware${ext}`);
           if (fs4.existsSync(filePath)) {
             return filePath;
           }
@@ -16340,6 +16625,13 @@ function routePatternToTsTypeLiterals(pattern) {
 function routePatternToRouteLiteral(pattern) {
   return JSON.stringify(pattern);
 }
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
 function createRoutePattern(route) {
   if (route.segments.length === 0) return "/";
   return "/" + route.segments.map((seg) => {
@@ -16349,12 +16641,12 @@ function createRoutePattern(route) {
   }).join("/");
 }
 async function generateRouteTypes(options) {
-  const root = path20.resolve(options.root);
+  const root = path21.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path20.isAbsolute(outFile) ? outFile : path20.join(root, srcDir, outFile);
+  const outPath = path21.isAbsolute(outFile) ? outFile : path21.join(root, srcDir, outFile);
   const content = await createRouteTypeDeclarations(options, outPath);
-  fs5.mkdirSync(path20.dirname(outPath), { recursive: true });
+  fs5.mkdirSync(path21.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
@@ -16365,7 +16657,7 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path20.join(source.root, source.srcDir, "app");
+    const appDir = path21.join(source.root, source.srcDir, "app");
     if (fs5.existsSync(appDir)) {
       const routeModuleFiles = await glob.default(
         "**/{page,layout,loading,error}.{ts,tsx,js,jsx,md,mdx}",
@@ -16399,10 +16691,10 @@ async function createRouteTypeDeclarations(options, outPath) {
   const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
   const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
-  const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
-  const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
-  const routeModulePatternType = routeModulePatternLiterals.length ? routeModulePatternLiterals.join(" | ") : "never";
-  const routeTypesImportPath = `./${path20.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
+  const routeTypesImportPath = `./${path21.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
@@ -16443,17 +16735,17 @@ declare global {
  * Regenerated on dev start and when routes change.
  * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
  */
-export type RoutePath = ${routePathType};
-export type RoutePattern = ${routePatternType};
-export type RouteModulePattern = ${routeModulePatternType};${linkAugmentationBlock}${routeModuleAugmentationBlock}
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
 `;
   return content;
 }
-var path20, fs5, DEFAULT_OUT_FILE;
+var path21, fs5, DEFAULT_OUT_FILE;
 var init_generate_route_types = __esm({
   "src/routing/generate-route-types.ts"() {
     "use strict";
-    path20 = __toESM(require("path"));
+    path21 = __toESM(require("path"));
     fs5 = __toESM(require("fs"));
     init_utils();
     init_route_slots();
@@ -16462,6 +16754,8 @@ var init_generate_route_types = __esm({
     __name(routeSegmentsToTsTypeLiteral, "routeSegmentsToTsTypeLiteral");
     __name(routePatternToTsTypeLiterals, "routePatternToTsTypeLiterals");
     __name(routePatternToRouteLiteral, "routePatternToRouteLiteral");
+    __name(renderTypeUnion, "renderTypeUnion");
+    __name(renderTypeAlias, "renderTypeAlias");
     __name(createRoutePattern, "createRoutePattern");
     DEFAULT_OUT_FILE = "farm-routes.d.ts";
     __name(generateRouteTypes, "generateRouteTypes");
@@ -16471,17 +16765,17 @@ var init_generate_route_types = __esm({
 
 // src/env-types.ts
 async function generateEnvTypes(options) {
-  const root = path21.resolve(options.root);
+  const root = path22.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE2;
-  const outPath = path21.isAbsolute(outFile) ? outFile : path21.join(root, srcDir, outFile);
+  const outPath = path22.isAbsolute(outFile) ? outFile : path22.join(root, srcDir, outFile);
   const content = createEnvTypeDeclarations(options, outPath);
-  fs6.mkdirSync(path21.dirname(outPath), { recursive: true });
+  fs6.mkdirSync(path22.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
 function createEnvTypeDeclarations(options, outPath) {
-  const root = path21.resolve(options.root);
+  const root = path22.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
     ...(options.layerConfigPaths ?? []).filter((value) => fs6.existsSync(value)),
@@ -16544,11 +16838,11 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path21.isAbsolute(configPath) ? configPath : path21.join(root, configPath);
+    const resolvedPath = path22.isAbsolute(configPath) ? configPath : path22.join(root, configPath);
     return fs6.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path21.join(root, filename);
+    const resolvedPath = path22.join(root, filename);
     if (fs6.existsSync(resolvedPath)) {
       return resolvedPath;
     }
@@ -16609,15 +16903,15 @@ export {};
 `;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path21.relative(path21.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path22.relative(path22.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs6, path21, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
+var fs6, path22, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
 var init_env_types = __esm({
   "src/env-types.ts"() {
     "use strict";
     fs6 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    path22 = __toESM(require("path"));
     init_write_file_if_changed();
     DEFAULT_OUT_FILE2 = "farm-env.d.ts";
     CONFIG_FILENAMES2 = [
@@ -16650,8 +16944,8 @@ var init_env_types = __esm({
 
 // src/image-types.ts
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path9.default.resolve(options.root, options.outFile) : import_node_path9.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs7.mkdirSync)(import_node_path9.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path10.default.resolve(options.root, options.outFile) : import_node_path10.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs7.mkdirSync)(import_node_path10.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -16675,12 +16969,12 @@ declare module "*?url" {
 }
 `;
 }
-var import_node_fs7, import_node_path9, FARM_STATIC_IMAGE_EXTENSIONS;
+var import_node_fs7, import_node_path10, FARM_STATIC_IMAGE_EXTENSIONS;
 var init_image_types = __esm({
   "src/image-types.ts"() {
     "use strict";
     import_node_fs7 = require("fs");
-    import_node_path9 = __toESM(require("path"));
+    import_node_path10 = __toESM(require("path"));
     init_write_file_if_changed();
     FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
     __name(generateFarmImageTypes, "generateFarmImageTypes");
@@ -16692,9 +16986,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_path10.resolve)(options.root, options.outFile) : (0, import_node_path10.join)((0, import_node_path10.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path11.resolve)(options.root, options.outFile) : (0, import_node_path11.join)((0, import_node_path11.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs8.mkdirSync)((0, import_node_path10.dirname)(outFile), { recursive: true });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path11.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -16735,12 +17029,12 @@ function argumentType(kind) {
       return "string";
   }
 }
-var import_node_fs8, import_node_path10;
+var import_node_fs8, import_node_path11;
 var init_type_generator2 = __esm({
   "src/i18n/type-generator.ts"() {
     "use strict";
     import_node_fs8 = require("fs");
-    import_node_path10 = require("path");
+    import_node_path11 = require("path");
     init_catalog();
     init_write_file_if_changed();
     __name(generateFarmI18nTypes, "generateFarmI18nTypes");
@@ -16762,7 +17056,8 @@ async function generateFarmTypeArtifacts(options) {
   const sourceRoots = getFarmSourceRoots({ root, srcDir, layers: options.layers });
   const appDirs = getFarmAppDirectories({ root, srcDir, layers: options.layers });
   const result = {
-    apiRoutes: []
+    apiRoutes: [],
+    stalePaths: []
   };
   const unifiedTypesPath = (0, import_path11.join)(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
@@ -16778,22 +17073,29 @@ async function generateFarmTypeArtifacts(options) {
     unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
     result.routeTypesPath = unifiedTypesPath;
   } else if (shouldGenerateRoutes) {
-    result.routeTypesPath = await generateRouteTypes({
+    const routeOptions = {
       root,
       srcDir,
       outFile: options.routeTypesOutFile,
       extraRoutes: options.extraRoutes || [],
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
-    });
+    };
+    if (options.check) {
+      const routeTypesPath = resolveGeneratedPath(root, srcDir, options.routeTypesOutFile);
+      const content = await createRouteTypeDeclarations(routeOptions, routeTypesPath);
+      checkGeneratedFile(routeTypesPath, content, result.stalePaths);
+      result.routeTypesPath = routeTypesPath;
+    } else {
+      result.routeTypesPath = await generateRouteTypes(routeOptions);
+    }
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
     const apiTypesPath = options.apiTypesOutFile ? (0, import_path11.resolve)(root, options.apiTypesOutFile) : (0, import_path11.join)(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
-    (0, import_fs4.mkdirSync)((0, import_path11.dirname)(apiTypesPath), { recursive: true });
-    writeFileIfChanged(apiTypesPath, content);
+    writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
@@ -16811,36 +17113,63 @@ async function generateFarmTypeArtifacts(options) {
     );
     result.envTypesPath = unifiedTypesPath;
   } else if (shouldGenerateEnv) {
-    result.envTypesPath = await generateEnvTypes({
+    const envOptions = {
       root,
       srcDir,
       outFile: options.envTypesOutFile,
       configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-    });
+    };
+    if (options.check) {
+      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
+      checkGeneratedFile(
+        envTypesPath,
+        createEnvTypeDeclarations(envOptions, envTypesPath),
+        result.stalePaths
+      );
+      result.envTypesPath = envTypesPath;
+    } else {
+      result.envTypesPath = await generateEnvTypes(envOptions);
+    }
   }
   if (shouldGenerateImages && options.imageTypesOutFile) {
-    result.imageTypesPath = generateFarmImageTypes({
-      root,
-      srcDir,
-      outFile: options.imageTypesOutFile
-    });
+    const imageTypesPath = resolveGeneratedPath(root, srcDir, options.imageTypesOutFile, false);
+    if (options.check) {
+      checkGeneratedFile(imageTypesPath, createFarmImageTypeDeclarations(), result.stalePaths);
+      result.imageTypesPath = imageTypesPath;
+    } else {
+      result.imageTypesPath = generateFarmImageTypes({
+        root,
+        srcDir,
+        outFile: options.imageTypesOutFile
+      });
+    }
   }
   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,
-      config: options.i18nConfig,
-      outFile: options.i18nTypesOutFile
-    });
+    if (options.check) {
+      const i18nTypesPath = resolveGeneratedPath(root, srcDir, options.i18nTypesOutFile, false);
+      const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+      checkGeneratedFile(
+        i18nTypesPath,
+        renderFarmI18nTypes(options.i18nConfig.locales, signatures),
+        result.stalePaths
+      );
+      result.i18nTypesPath = i18nTypesPath;
+    } else {
+      result.i18nTypesPath = await generateFarmI18nTypes({
+        root,
+        srcDir,
+        config: options.i18nConfig,
+        outFile: options.i18nTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes) {
-    (0, import_fs4.mkdirSync)((0, import_path11.dirname)(unifiedTypesPath), { recursive: true });
-    writeFileIfChanged(
+    writeOrCheckGeneratedFile(
       unifiedTypesPath,
       `/**
  * Generated by Farm.js. Do not edit.
@@ -16849,13 +17178,37 @@ async function generateFarmTypeArtifacts(options) {
 
 import "@farm.js/core/image";
 
-${unifiedSections.join("\n")}`
+${unifiedSections.map((section) => section.trimEnd()).join("\n\n")}
+`,
+      options.check,
+      result.stalePaths
     );
     result.typesPath = unifiedTypesPath;
-    removeLegacyTypeArtifacts(root, srcDir);
+    if (options.check) {
+      collectLegacyTypeArtifacts(root, srcDir, result.stalePaths);
+    } else {
+      removeLegacyTypeArtifacts(root, srcDir);
+    }
   }
   return result;
 }
+function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
+  if ((0, import_path11.isAbsolute)(outFile)) return (0, import_path11.resolve)(outFile);
+  return (0, import_path11.resolve)(root, relativeToSrc ? (0, import_path11.join)(srcDir, outFile) : outFile);
+}
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  (0, import_fs4.mkdirSync)((0, import_path11.dirname)(filePath), { recursive: true });
+  writeFileIfChanged(filePath, content);
+}
+function checkGeneratedFile(filePath, content, stalePaths) {
+  if (!(0, import_fs4.existsSync)(filePath) || (0, import_fs4.readFileSync)(filePath, "utf8") !== content) {
+    stalePaths.push(filePath);
+  }
+}
 function removeLegacyTypeArtifacts(root, srcDir) {
   for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
     const filePath = (0, import_path11.join)(root, srcDir, fileName);
@@ -16866,6 +17219,13 @@ function removeLegacyTypeArtifacts(root, srcDir) {
     }
   }
 }
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path11.join)(root, srcDir, fileName);
+    if (!(0, import_fs4.existsSync)(filePath)) continue;
+    if ((0, import_fs4.readFileSync)(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
+  }
+}
 var import_fs4, import_path11, LEGACY_TYPE_ARTIFACTS;
 var init_type_artifacts = __esm({
   "src/type-artifacts.ts"() {
@@ -16881,6 +17241,9 @@ var init_type_artifacts = __esm({
     init_layers();
     init_write_file_if_changed();
     __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+    __name(resolveGeneratedPath, "resolveGeneratedPath");
+    __name(writeOrCheckGeneratedFile, "writeOrCheckGeneratedFile");
+    __name(checkGeneratedFile, "checkGeneratedFile");
     LEGACY_TYPE_ARTIFACTS = [
       ["farm-routes.d.ts", "Auto-generated route types"],
       ["farm-env.d.ts", "Auto-generated env types"],
@@ -16888,6 +17251,7 @@ var init_type_artifacts = __esm({
       ["farm-i18n.d.ts", "Generated by Farm.js"]
     ];
     __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
+    __name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
   }
 });
 
@@ -16895,7 +17259,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.14";
+    version = "0.1.0-beta.17";
   }
 });
 
@@ -17075,12 +17439,12 @@ async function createBlurDataURL(bytes) {
     return void 0;
   }
 }
-var import_promises7, import_node_path11, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
+var import_promises7, import_node_path12, 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_promises7 = require("fs/promises");
-    import_node_path11 = __toESM(require("path"));
+    import_node_path12 = __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;
@@ -17523,106 +17887,6 @@ var init_image_server = __esm({
   }
 });
 
-// src/server/vite-config.ts
-function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = import_node_path12.default.resolve(projectRoot);
-  return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = import_node_path12.default.relative(resolvedProjectRoot, import_node_path12.default.resolve(appDirectory)).replace(/\\/g, "/");
-    const prefix = relativeAppDirectory || ".";
-    return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
-  });
-}
-function createFarmClientOptimizeDepsConfig(entries) {
-  return {
-    // Keep normal application dependency discovery for CJS-only packages, but
-    // seed every Farm browser runtime so React is present in the first crawl.
-    noDiscovery: false,
-    // Waiting for the crawl avoids serving a partial optimizer generation and
-    // then changing browser hashes while hydration is already in progress.
-    holdUntilCrawlEnd: true,
-    include: [...FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE],
-    // Farm's HTML boots through a virtual module and imports route UI lazily.
-    // Explicit entries let Vite finish that crawl before a navigation can
-    // rotate the optimizer hash underneath a hydrated React runtime.
-    ...entries?.length ? { entries: [...entries] } : {}
-  };
-}
-function mergeNoExternal(farmValue, userValue) {
-  if (farmValue === true || userValue === true) return true;
-  const normalize = /* @__PURE__ */ __name((value) => value == null || value === true ? [] : Array.isArray(value) ? value : [value], "normalize");
-  return Array.from(/* @__PURE__ */ new Set([...normalize(farmValue), ...normalize(userValue)]));
-}
-function mergeFarmViteConfig(farmConfig, userConfig = {}) {
-  const noDiscovery = userConfig.optimizeDeps?.noDiscovery ?? farmConfig.optimizeDeps?.noDiscovery;
-  const holdUntilCrawlEnd = userConfig.optimizeDeps?.holdUntilCrawlEnd ?? (userConfig.optimizeDeps?.noDiscovery === true ? false : farmConfig.optimizeDeps?.holdUntilCrawlEnd);
-  return {
-    ...farmConfig,
-    ...userConfig,
-    plugins: [...farmConfig.plugins || [], ...userConfig.plugins || []],
-    server: {
-      ...farmConfig.server,
-      ...userConfig.server
-    },
-    resolve: {
-      ...farmConfig.resolve,
-      ...userConfig.resolve,
-      dedupe: Array.from(
-        /* @__PURE__ */ new Set([...farmConfig.resolve?.dedupe || [], ...userConfig.resolve?.dedupe || []])
-      )
-    },
-    optimizeDeps: {
-      ...farmConfig.optimizeDeps,
-      ...userConfig.optimizeDeps,
-      noDiscovery,
-      holdUntilCrawlEnd,
-      include: Array.from(
-        /* @__PURE__ */ new Set([
-          ...farmConfig.optimizeDeps?.include || [],
-          ...userConfig.optimizeDeps?.include || []
-        ])
-      ),
-      exclude: Array.from(
-        /* @__PURE__ */ new Set([
-          ...farmConfig.optimizeDeps?.exclude || [],
-          ...userConfig.optimizeDeps?.exclude || []
-        ])
-      )
-    },
-    ssr: {
-      ...farmConfig.ssr,
-      ...userConfig.ssr,
-      noExternal: mergeNoExternal(farmConfig.ssr?.noExternal, userConfig.ssr?.noExternal)
-    }
-  };
-}
-var import_node_path12, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
-var init_vite_config = __esm({
-  "src/server/vite-config.ts"() {
-    "use strict";
-    import_node_path12 = __toESM(require("path"));
-    FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
-    FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
-      "react",
-      "react-dom",
-      "react-dom/client",
-      "react/jsx-runtime",
-      "react/jsx-dev-runtime",
-      "@farm.js/core/client",
-      "@farm.js/core/plugin/client",
-      "@farm.js/core/deferred",
-      "@farm.js/core/deployment",
-      "@farm.js/core/i18n/client",
-      "@farm.js/core/query/client",
-      "@farm.js/core/server-fn/client",
-      "@farm.js/core/server-query/client"
-    ];
-    __name(createFarmClientOptimizeDepsEntries, "createFarmClientOptimizeDepsEntries");
-    __name(createFarmClientOptimizeDepsConfig, "createFarmClientOptimizeDepsConfig");
-    __name(mergeNoExternal, "mergeNoExternal");
-    __name(mergeFarmViteConfig, "mergeFarmViteConfig");
-  }
-});
-
 // src/docs/pixel-border-css.ts
 var farmDocsPixelBorderCss;
 var init_pixel_border_css = __esm({
@@ -27739,7 +28003,7 @@ async function defineConfig2(config = {}) {
       // Stub out problematic server-only modules during dev mode
       alias: {
         ...getFarmLayerAliases(config.layers),
-        "@": path27.resolve(appRoot, "src"),
+        ...createFarmSourceAlias(appRoot, config.srcDir),
         // 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 {};",
@@ -29190,6 +29454,7 @@ init_fonts();
 
 // src/route-runtime-manifest.ts
 var import_path8 = __toESM(require("path"));
+init_deployment();
 init_route_runtime();
 init_ssg();
 var FARM_ROUTE_RUNTIME_MANIFEST = "route-runtime-manifest.json";
@@ -29250,10 +29515,15 @@ async function writeFarmRouteRuntimeManifest(directory, manifest) {
 }
 __name(writeFarmRouteRuntimeManifest, "writeFarmRouteRuntimeManifest");
 function validateFarmRouteRuntimeDeployment(manifest, preset) {
-  const runtime = getPresetRuntime(preset);
+  const runtime = getFarmPresetRuntime(preset);
   const warnings = /* @__PURE__ */ new Set();
   for (const route of manifest.routes) {
     if (route.rendering === "static") continue;
+    if (runtime === "unknown" && route.runtime !== "auto") {
+      warnings.add(
+        `Preset "${preset}" has an unknown runtime, so Farm could not verify routes that explicitly require node or edge.`
+      );
+    }
     if (runtime !== "unknown" && route.runtime !== "auto" && route.runtime !== runtime) {
       throw new Error(
         `Route "${route.pattern}" requires the ${route.runtime} runtime, but preset "${preset}" emits ${runtime} functions. Choose a compatible preset or change the route runtime.`
@@ -29273,16 +29543,6 @@ function validateFarmRouteRuntimeDeployment(manifest, preset) {
   return { runtime, warnings: Array.from(warnings) };
 }
 __name(validateFarmRouteRuntimeDeployment, "validateFarmRouteRuntimeDeployment");
-function getPresetRuntime(preset) {
-  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
-    return "edge";
-  }
-  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun") {
-    return "node";
-  }
-  return "unknown";
-}
-__name(getPresetRuntime, "getPresetRuntime");
 function normalizeManifestSource(root, modulePath) {
   const queryIndex = modulePath.indexOf("?");
   const filePath = queryIndex === -1 ? modulePath : modulePath.slice(0, queryIndex);
@@ -29552,6 +29812,7 @@ __name(withVite5TransformContext, "withVite5TransformContext");
 
 // src/nitro/universal-build.ts
 init_font_vite();
+init_vite_config();
 var import_meta = {};
 function preloadFarmNitroRuntime() {
   return import("nitro").then(
@@ -31945,9 +32206,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         postcss: postcssConfigDir
       } : void 0,
       resolve: {
-        alias: {
-          "@": import_path12.default.resolve(root, "src")
-        },
+        alias: createFarmSourceAlias(root, config.srcDir),
         // Programmatic route wrappers are created inside @farm.js/core. Resolve
         // their React imports from the application so React 18/19 elements and
         // the selected server renderer always share the same runtime instance.
@@ -35605,6 +35864,9 @@ async function createProjectModuleServer(createViteServer, config, root) {
         middlewareMode: true,
         hmr: false
       },
+      resolve: {
+        alias: createFarmSourceAlias(root, config.srcDir)
+      },
       optimizeDeps: {
         noDiscovery: true
       },