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

package/dist/internal/build-runtime.cjs

@@ -5406,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"() {
@@ -5667,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";
@@ -5722,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),
@@ -5741,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",
@@ -5820,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");
@@ -13540,6 +13685,7 @@ var init_app = __esm({
     init_cache();
     init_auth_config();
     init_preload();
+    init_security();
     defaultDocsConfig = {
       enabled: false,
       entry: "/docs",
@@ -13604,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, {
@@ -15242,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({
@@ -15649,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();
@@ -15734,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);
           }
         }
@@ -15746,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;
           }
@@ -16374,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;
 }
@@ -16390,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}",
@@ -16427,7 +16694,7 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
   const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
   const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
-  const routeTypesImportPath = `./${path20.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const routeTypesImportPath = `./${path21.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
@@ -16474,11 +16741,11 @@ ${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentati
 `;
   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();
@@ -16498,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)),
@@ -16571,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;
     }
@@ -16636,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 = [
@@ -16677,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;
 }
@@ -16702,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");
@@ -16719,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;
 }
@@ -16762,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");
@@ -16992,7 +17259,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.16";
+    version = "0.1.0-beta.17";
   }
 });
 
@@ -17172,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;
@@ -17620,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({
@@ -27836,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 {};",
@@ -29645,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(
@@ -32038,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.
@@ -35698,6 +35864,9 @@ async function createProjectModuleServer(createViteServer, config, root) {
         middlewareMode: true,
         hmr: false
       },
+      resolve: {
+        alias: createFarmSourceAlias(root, config.srcDir)
+      },
       optimizeDeps: {
         noDiscovery: true
       },