@farm.js/core 0.1.0-beta.96 → 0.1.0-beta.97

package/dist/internal/build-runtime.cjs

@@ -856,11 +856,11 @@ function resolveFarmServerHealthConfig(config) {
   return Object.freeze({ enabled: true, livenessPath, readinessPath });
 }
 function normalizeHealthPath(value, optionName) {
-  const path41 = value.trim();
-  if (!path41.startsWith("/") || path41.includes("?") || path41.includes("#") || path41.includes("*")) {
+  const path42 = value.trim();
+  if (!path42.startsWith("/") || path42.includes("?") || path42.includes("#") || path42.includes("*")) {
     throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
   }
-  const normalized = path41.length > 1 ? path41.replace(/\/+$/, "") || "/" : path41;
+  const normalized = path42.length > 1 ? path42.replace(/\/+$/, "") || "/" : path42;
   assertBrowserStableRoutePath(normalized);
   return normalized;
 }
@@ -1697,9 +1697,9 @@ function getFarmIntegrationPluginOwner(plugin) {
   const value = plugin[FARM_INTEGRATION_PLUGIN_OWNER];
   return value && typeof value === "object" ? value : void 0;
 }
-function defineTypedIntegrationRoute(method, path41, input) {
+function defineTypedIntegrationRoute(method, path42, input) {
   return {
-    path: path41,
+    path: path42,
     method,
     middleware: input.middleware,
     before: input.before,
@@ -1709,7 +1709,7 @@ function defineTypedIntegrationRoute(method, path41, input) {
     input: normalizeIntegrationRouteInputSchemas(input),
     handler: input.handler,
     __operation: defineIntegrationAPIOperation({
-      path: path41,
+      path: path42,
       method,
       bodyFormat: input.bodyFormat,
       responseFormat: input.responseFormat,
@@ -1721,58 +1721,58 @@ function defineTypedIntegrationRoute(method, path41, input) {
 }
 function createIntegrationRouteFactory() {
   return {
-    get(path41, input) {
+    get(path42, input) {
       return defineTypedIntegrationRoute(
         "GET",
-        path41,
+        path42,
         input
       );
     },
-    post(path41, input) {
+    post(path42, input) {
       return defineTypedIntegrationRoute(
         "POST",
-        path41,
+        path42,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    query(path41, input) {
-      return defineTypedIntegrationRoute("QUERY", path41, {
+    query(path42, input) {
+      return defineTypedIntegrationRoute("QUERY", path42, {
         bodyFormat: "json",
         ...input
       });
     },
-    put(path41, input) {
+    put(path42, input) {
       return defineTypedIntegrationRoute(
         "PUT",
-        path41,
+        path42,
         {
           bodyFormat: "json",
           ...input
         }
       );
     },
-    patch(path41, input) {
-      return defineTypedIntegrationRoute("PATCH", path41, {
+    patch(path42, input) {
+      return defineTypedIntegrationRoute("PATCH", path42, {
         bodyFormat: "json",
         ...input
       });
     },
-    delete(path41, input) {
-      return defineTypedIntegrationRoute("DELETE", path41, {
+    delete(path42, input) {
+      return defineTypedIntegrationRoute("DELETE", path42, {
         bodyFormat: "json",
         ...input
       });
     },
-    options(path41, input) {
-      return defineTypedIntegrationRoute("OPTIONS", path41, input);
+    options(path42, input) {
+      return defineTypedIntegrationRoute("OPTIONS", path42, input);
     },
-    head(path41, input) {
+    head(path42, input) {
       return defineTypedIntegrationRoute(
         "HEAD",
-        path41,
+        path42,
         input
       );
     }
@@ -2053,8 +2053,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 path41 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
-    return `${path41}${issue.message || "Invalid config"}`;
+    const path42 = normalizedPath.length ? `${normalizedPath.join(".")}: ` : "";
+    return `${path42}${issue.message || "Invalid config"}`;
   }).join("; ") : error.message || "Invalid config";
   return new Error(`Integration "${integration.type}" config validation failed: ${issues}`);
 }
@@ -2778,8 +2778,8 @@ function normalizeIntegrationValidationIssues(source, error) {
     }
   ];
 }
-function normalizeIntegrationValidationPath(path41) {
-  return (path41 || []).map((segment) => {
+function normalizeIntegrationValidationPath(path42) {
+  return (path42 || []).map((segment) => {
     const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
     return typeof key === "symbol" ? key.description || key.toString() : key;
   });
@@ -4021,8 +4021,8 @@ function toViteModuleId(filePath, root) {
 }
 async function fileExists(filePath) {
   try {
-    const fs14 = await import("fs/promises");
-    await fs14.access(filePath);
+    const fs15 = await import("fs/promises");
+    await fs15.access(filePath);
     return true;
   } catch {
     return false;
@@ -4216,35 +4216,35 @@ async function prepareFarmWorkflowsForNitro(config) {
   const workflowConfig = isResolvedWorkflowConfig(config.workflows) ? config.workflows : resolveWorkflowsConfig(config.workflows);
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
-  const fs14 = await import("fs/promises");
-  const path41 = await import("path");
-  const generatedDir = path41.join(root, distDir, ".nitro", "farm-workflows");
+  const fs15 = await import("fs/promises");
+  const path42 = await import("path");
+  const generatedDir = path42.join(root, distDir, ".nitro", "farm-workflows");
   const workflows = await discoverFarmWorkflows({
     root,
     workflows: workflowConfig
   });
   if (workflows.length === 0) {
-    await fs14.rm(generatedDir, { recursive: true, force: true });
+    await fs15.rm(generatedDir, { recursive: true, force: true });
     return {
       workflows,
       tasks: {},
       scheduledTasks: {}
     };
   }
-  await fs14.rm(generatedDir, { recursive: true, force: true });
-  await fs14.mkdir(generatedDir, { recursive: true });
+  await fs15.rm(generatedDir, { recursive: true, force: true });
+  await fs15.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const scheduledTasks = createScheduledTasks(workflows);
   for (const workflow of workflows) {
-    const wrapperPath = toPosixPath(path41.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
-    await fs14.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    const wrapperPath = toPosixPath(path42.join(generatedDir, `${safeFileName(workflow.id)}.mjs`));
+    await fs15.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
     tasks[workflow.id] = {
       handler: wrapperPath,
       description: workflow.description || `Farm workflow ${workflow.id}`
     };
   }
-  const handlerPath = toPosixPath(path41.join(generatedDir, "http-handler.mjs"));
-  await fs14.writeFile(
+  const handlerPath = toPosixPath(path42.join(generatedDir, "http-handler.mjs"));
+  await fs15.writeFile(
     handlerPath,
     createNitroWorkflowHTTPHandler(
       workflowConfig,
@@ -4253,8 +4253,8 @@ async function prepareFarmWorkflowsForNitro(config) {
     ),
     "utf8"
   );
-  const manifestPath = path41.join(generatedDir, "manifest.json");
-  await fs14.writeFile(
+  const manifestPath = path42.join(generatedDir, "manifest.json");
+  await fs15.writeFile(
     manifestPath,
     JSON.stringify(
       {
@@ -4342,21 +4342,21 @@ function resolveWorkflowDefinition(module2) {
   return null;
 }
 async function findWorkflowFiles(root, dirs) {
-  const path41 = await import("path");
+  const path42 = await import("path");
   const files = [];
   for (const dir of dirs) {
-    const absoluteDir = path41.isAbsolute(dir) ? dir : path41.join(root, dir);
+    const absoluteDir = path42.isAbsolute(dir) ? dir : path42.join(root, dir);
     if (!await pathExists(absoluteDir)) continue;
     await walkWorkflowDir(absoluteDir, files);
   }
   return files.sort();
 }
 async function walkWorkflowDir(dir, files) {
-  const fs14 = await import("fs/promises");
-  const path41 = await import("path");
-  const entries = await fs14.readdir(dir, { withFileTypes: true });
+  const fs15 = await import("fs/promises");
+  const path42 = await import("path");
+  const entries = await fs15.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const filePath = path41.join(dir, entry.name);
+    const filePath = path42.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
       await walkWorkflowDir(filePath, files);
@@ -4368,20 +4368,20 @@ async function walkWorkflowDir(dir, files) {
   }
 }
 async function pathExists(filePath) {
-  const fs14 = await import("fs/promises");
-  return fs14.access(filePath).then(() => true).catch(() => false);
+  const fs15 = await import("fs/promises");
+  return fs15.access(filePath).then(() => true).catch(() => false);
 }
 function isWorkflowFile(fileName) {
   return /\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(fileName) && !/\.d\.[cm]?ts$/.test(fileName);
 }
 async function loadWorkflowModule(filePath, root) {
-  const fs14 = await import("fs/promises");
-  const path41 = await import("path");
+  const fs15 = await import("fs/promises");
+  const path42 = await import("path");
   const { pathToFileURL: pathToFileURL10 } = await import("url");
   const { build: build3 } = await import("esbuild");
-  const outDir = path41.join(root, ".farm", ".workflow-loader");
-  await fs14.mkdir(outDir, { recursive: true });
-  const outfile = path41.join(
+  const outDir = path42.join(root, ".farm", ".workflow-loader");
+  await fs15.mkdir(outDir, { recursive: true });
+  const outfile = path42.join(
     outDir,
     `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
   );
@@ -4405,7 +4405,7 @@ async function loadWorkflowModule(filePath, root) {
       `${pathToFileURL10(outfile).href}?t=${Date.now()}`
     );
   } finally {
-    await fs14.unlink(outfile).catch(() => void 0);
+    await fs15.unlink(outfile).catch(() => void 0);
   }
 }
 function workflowIdFromFile(root, dirs, filePath) {
@@ -4695,14 +4695,14 @@ async function prepareFarmCronForNitro(config) {
   const cron = isResolvedCronConfig(config.cron) ? config.cron : resolveCronConfig(config.cron);
   const root = config.root || process.cwd();
   const distDir = config.distDir || ".farm";
-  const fs14 = await import("fs/promises");
-  const path41 = await import("path");
-  const manifestPath = path41.join(root, distDir, FARM_CRON_MANIFEST);
-  const generatedDir = path41.join(root, distDir, ".nitro", "farm-cron");
+  const fs15 = await import("fs/promises");
+  const path42 = await import("path");
+  const manifestPath = path42.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path42.join(root, distDir, ".nitro", "farm-cron");
   if (!cron.enabled) {
     await Promise.all([
-      fs14.rm(manifestPath, { force: true }),
-      fs14.rm(generatedDir, { recursive: true, force: true })
+      fs15.rm(manifestPath, { force: true }),
+      fs15.rm(generatedDir, { recursive: true, force: true })
     ]);
     return {
       jobs: [],
@@ -4710,21 +4710,21 @@ async function prepareFarmCronForNitro(config) {
       scheduledTasks: {}
     };
   }
-  await fs14.rm(generatedDir, { recursive: true, force: true });
-  await fs14.mkdir(generatedDir, { recursive: true });
+  await fs15.rm(generatedDir, { recursive: true, force: true });
+  await fs15.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   for (const job of cron.jobs) {
     const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = toPosixPath(path41.join(generatedDir, `${safeFileName2(job.name)}.mjs`));
-    await fs14.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
+    const wrapperPath = toPosixPath(path42.join(generatedDir, `${safeFileName2(job.name)}.mjs`));
+    await fs15.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
     tasks[taskName] = {
       handler: wrapperPath,
       description: job.description || `Farm cron ${job.name}`
     };
   }
   const manifest = createFarmCronManifest(cron);
-  await fs14.mkdir(path41.dirname(manifestPath), { recursive: true });
-  await fs14.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await fs15.mkdir(path42.dirname(manifestPath), { recursive: true });
+  await fs15.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return {
     jobs: cron.jobs,
@@ -4805,7 +4805,7 @@ function normalizeCronJob(name2, job) {
   if (!job || typeof job !== "object" || Array.isArray(job)) {
     throw new TypeError(`Farm cron ${JSON.stringify(name2)} must be a configuration object.`);
   }
-  const path41 = normalizeCronPath(name2, job.path);
+  const path42 = normalizeCronPath(name2, job.path);
   const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
   const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name2, value)))];
   if (schedule.length === 0) {
@@ -4814,7 +4814,7 @@ function normalizeCronJob(name2, job) {
   return {
     name: name2,
     schedule,
-    path: path41,
+    path: path42,
     description: job.description?.trim() || void 0
   };
 }
@@ -4831,13 +4831,13 @@ function normalizeCronPath(name2, value) {
       `Farm cron ${JSON.stringify(name2)} path cannot contain backslashes or control characters.`
     );
   }
-  const path41 = value.trim();
-  if (path41.startsWith("//") || path41.includes("?") || path41.includes("#")) {
+  const path42 = value.trim();
+  if (path42.startsWith("//") || path42.includes("?") || path42.includes("#")) {
     throw new TypeError(
       `Farm cron ${JSON.stringify(name2)} path must be an application pathname without a host, query, or hash.`
     );
   }
-  for (const segment of path41.split("/")) {
+  for (const segment of path42.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -4859,7 +4859,7 @@ function normalizeCronPath(name2, value) {
       );
     }
   }
-  return path41.length > 1 ? path41.replace(/\/+$/, "") : path41;
+  return path42.length > 1 ? path42.replace(/\/+$/, "") : path42;
 }
 function normalizeCronExpression(name2, value) {
   if (typeof value !== "string") {
@@ -5526,15 +5526,27 @@ function getFarmCacheInvalidationState() {
     taskListeners: /* @__PURE__ */ new Set()
   });
 }
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
 function notifyFarmCacheInvalidation(key) {
   if (typeof key !== "string" || key.length === 0) return;
   for (const listener of getFarmCacheInvalidationState().listeners) {
-    listener(key);
+    try {
+      listener(key);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
   }
 }
 function notifyFarmCacheTask(task) {
   for (const listener of getFarmCacheInvalidationState().taskListeners) {
-    listener(task);
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
   }
 }
 function encodeFarmCacheInvalidations(keys) {
@@ -5573,6 +5585,7 @@ var init_cache_invalidation = __esm({
     FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
     globalState = globalThis;
     __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+    __name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
     __name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
     __name(notifyFarmCacheTask, "notifyFarmCacheTask");
     __name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
@@ -6182,8 +6195,8 @@ function createFarmDeploymentMismatchResponse(mismatch) {
     }
   );
 }
-function createFarmDeploymentCookie(deploymentId, path41 = "/", secure = false) {
-  const normalizedPath = path41.startsWith("/") ? path41 : `/${path41}`;
+function createFarmDeploymentCookie(deploymentId, path42 = "/", secure = false) {
+  const normalizedPath = path42.startsWith("/") ? path42 : `/${path42}`;
   return [
     `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
     `Path=${normalizedPath}`,
@@ -6412,7 +6425,7 @@ var init_dev_indicators = __esm({
 
 // src/image-config.ts
 function resolveFarmImageConfig(config) {
-  const path41 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const path42 = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
   const deviceSizes = normalizeIntegerList(
     config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
     "images.deviceSizes"
@@ -6440,7 +6453,7 @@ function resolveFarmImageConfig(config) {
   );
   return Object.freeze({
     provider: config?.provider ?? "auto",
-    path: path41,
+    path: path42,
     domains: Object.freeze([
       ...new Set(
         (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
@@ -6486,11 +6499,11 @@ function normalizeImagePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new TypeError("images.path cannot contain backslashes or control characters");
   }
-  const path41 = value.trim().replace(/\/+$/, "") || "/";
-  if (!path41.startsWith("/") || path41.startsWith("//") || path41.includes("?") || path41.includes("#")) {
+  const path42 = value.trim().replace(/\/+$/, "") || "/";
+  if (!path42.startsWith("/") || path42.startsWith("//") || path42.includes("?") || path42.includes("#")) {
     throw new TypeError("images.path must be an absolute pathname without a query or hash");
   }
-  for (const segment of path41.split("/")) {
+  for (const segment of path42.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -6506,7 +6519,7 @@ function normalizeImagePath(value) {
       throw new TypeError('images.path cannot contain "." or ".." path segments');
     }
   }
-  return path41;
+  return path42;
 }
 function normalizeIntegerList(values, name2, max) {
   if (values.length === 0) {
@@ -7399,17 +7412,17 @@ function normalizeFarmAPIBasePath(value) {
   if (hasUnstableCharacters(value)) {
     throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
   }
-  const path41 = value.trim();
-  if (!path41) {
+  const path42 = value.trim();
+  if (!path42) {
     throw new Error("Farm api.basePath cannot be empty.");
   }
-  if (path41.includes("?") || path41.includes("#")) {
+  if (path42.includes("?") || path42.includes("#")) {
     throw new Error("Farm api.basePath cannot contain a query string or hash.");
   }
-  if (path41.startsWith("//")) {
+  if (path42.startsWith("//")) {
     throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
   }
-  for (const segment of path41.split("/")) {
+  for (const segment of path42.split("/")) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
@@ -7425,7 +7438,7 @@ function normalizeFarmAPIBasePath(value) {
       throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
     }
   }
-  const normalized = `/${path41.replace(/^\/+|\/+$/g, "")}`;
+  const normalized = `/${path42.replace(/^\/+|\/+$/g, "")}`;
   return normalized === "/" ? "/" : normalized;
 }
 function getFarmAPIBaseURL() {
@@ -7574,7 +7587,9 @@ function resolveDeployConfig(config, overrides = {}) {
       }
     }
   }
-  const preset = overrides.preset || deploy.preset || config.preset || getPresetForDeployTarget(target) || "node-server";
+  const configuredPreset = deploy.preset || config.preset;
+  const overrideTargetPreset = overrideTarget && getDeployTargetForPreset(configuredPreset) !== overrideTarget ? getPresetForDeployTarget(overrideTarget) : void 0;
+  const preset = overrides.preset || overrideTargetPreset || configuredPreset || getPresetForDeployTarget(target) || "node-server";
   const resolvedTarget = target || getDeployTargetForPreset(preset);
   if (detectedTarget && resolvedTarget !== detectedTarget) {
     const mismatchKey = `mismatch:${resolvedTarget}:${detectedTarget}`;
@@ -7676,19 +7691,19 @@ async function findDocsConfigPath(rootDir, configPath) {
   return void 0;
 }
 async function loadDocsConfig(rootDir, configPath) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const { pathToFileURL: pathToFileURL10 } = await import("url");
   const root = import_path2.default.resolve(rootDir || process.cwd());
   const resolvedPath = await findDocsConfigPath(root, configPath);
   if (!resolvedPath) return void 0;
   try {
     if (resolvedPath.endsWith(".json")) {
-      const content = await fs14.readFile(resolvedPath, "utf8");
+      const content = await fs15.readFile(resolvedPath, "utf8");
       return { config: JSON.parse(content), configPath: resolvedPath };
     }
     const { build: build3 } = await import("esbuild");
     const configCacheDir = import_path2.default.join(root, ".farm", ".config-loader");
-    await fs14.mkdir(configCacheDir, { recursive: true });
+    await fs15.mkdir(configCacheDir, { recursive: true });
     const modulePath = import_path2.default.join(
       configCacheDir,
       `docs-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
@@ -7714,7 +7729,7 @@ async function loadDocsConfig(rootDir, configPath) {
         moduleUrl
       );
     } finally {
-      await fs14.unlink(modulePath).catch(() => void 0);
+      await fs15.unlink(modulePath).catch(() => void 0);
     }
     return {
       config: importedConfig.default || importedConfig,
@@ -7907,6 +7922,7 @@ async function resolveConfig(userConfig, mode) {
       serverComponents: false,
       serverActions: false,
       isolatedClientHydration: "off",
+      ppr: false,
       ...userConfig.experimental
     },
     plugins: [...resolveIntegrationPlugins(integrations), ...userConfig.plugins || []],
@@ -8180,7 +8196,13 @@ function recordFarmEventTrace(event) {
       activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
     }
     const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) recordSpanError(activeSpan, error);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
   }
   const completedTraceContext = recordCompletedEventSpan(event, activeContext);
   return traceContext ?? completedTraceContext;
@@ -8274,12 +8296,25 @@ function getCompletedSpanDescriptor(event) {
       return void 0;
   }
 }
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
 function toEventAttributes(event) {
   const attributes = {};
+  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
   for (const [key, value] of Object.entries(event)) {
     if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
       continue;
     }
+    if (redactKey && key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
       attributes[`farm.${key}`] = value;
     } else if (Array.isArray(value)) {
@@ -8297,9 +8332,13 @@ function toEventAttributes(event) {
 function getEventError(event) {
   return "error" in event ? event.error : void 0;
 }
-function recordSpanError(span, error) {
+function recordSpanException(span, error) {
   const normalized = error instanceof Error ? error : new Error(String(error));
   span.recordException(normalized);
+  return normalized;
+}
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
   span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
 }
 function setResponseStatus(span, status) {
@@ -8357,8 +8396,10 @@ var init_tracing = __esm({
     __name(recordFarmEventTrace, "recordFarmEventTrace");
     __name(recordCompletedEventSpan, "recordCompletedEventSpan");
     __name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
+    __name(hashFarmCacheKey, "hashFarmCacheKey");
     __name(toEventAttributes, "toEventAttributes");
     __name(getEventError, "getEventError");
+    __name(recordSpanException, "recordSpanException");
     __name(recordSpanError, "recordSpanError");
     __name(setResponseStatus, "setResponseStatus");
     __name(resolveResultStatus, "resolveResultStatus");
@@ -8553,10 +8594,11 @@ var init_observability = __esm({
 });
 
 // src/ssg.ts
-function resolveConfiguredRouteRenderingConfig(mod, source) {
+function resolveConfiguredRouteRenderingConfig(mod, source, options) {
+  const pprEnabled = options?.experimentalPPR === true;
   const directiveConfig = parseRouteRenderingDirective(source);
   let ssg = directiveConfig?.ssg ?? false;
-  let ppr = directiveConfig?.ppr ?? false;
+  let requestedPPR = directiveConfig?.ppr ?? false;
   let revalidate = directiveConfig?.revalidate;
   const moduleDynamic = normalizeDynamicMode(mod?.dynamic);
   const dynamic = moduleDynamic ?? directiveConfig?.dynamic;
@@ -8566,12 +8608,12 @@ function resolveConfiguredRouteRenderingConfig(mod, source) {
     ssg = mod.ssg === true;
   }
   if (hasExplicitPPR) {
-    ppr = mod?.ppr === true || mod?.experimental_ppr === true;
+    requestedPPR = mod?.ppr === true || mod?.experimental_ppr === true;
   }
   if (typeof mod?.revalidate === "number") {
     if (mod.revalidate > 0) {
       revalidate = mod.revalidate;
-      if (!hasExplicitSsg && !ppr) {
+      if (!hasExplicitSsg && !requestedPPR) {
         ssg = true;
       }
     } else {
@@ -8585,22 +8627,23 @@ function resolveConfiguredRouteRenderingConfig(mod, source) {
   }
   if (moduleDynamic === "force-static" || moduleDynamic === "error") {
     ssg = true;
-    ppr = false;
+    requestedPPR = false;
   } else if (moduleDynamic === "force-dynamic") {
     ssg = false;
-    ppr = false;
+    requestedPPR = false;
     revalidate = void 0;
   }
+  const ppr = pprEnabled && !ssg && requestedPPR;
   return {
     ssg,
-    ppr: ssg ? false : ppr,
+    ppr,
     revalidate: ssg || ppr ? revalidate : void 0,
     dynamic,
     directive: directiveConfig?.directive
   };
 }
-function resolveRouteRenderingConfig(mod, source) {
-  const rendering = resolveConfiguredRouteRenderingConfig(mod, source);
+function resolveRouteRenderingConfig(mod, source, options) {
+  const rendering = resolveConfiguredRouteRenderingConfig(mod, source, options);
   if (!rendering.ssg || !source) {
     return rendering;
   }
@@ -8614,9 +8657,9 @@ function resolveRouteRenderingConfig(mod, source) {
     revalidate: void 0
   };
 }
-async function resolveRouteRenderingConfigFromFile(mod, filePath) {
+async function resolveRouteRenderingConfigFromFile(mod, filePath, options) {
   const source = await (0, import_promises3.readFile)(filePath, "utf8").catch(() => void 0);
-  return resolveRouteRenderingConfig(mod, source);
+  return resolveRouteRenderingConfig(mod, source, options);
 }
 function analyzeStaticRouteCandidate(mod, source, options = {}) {
   const blockers = [];
@@ -10115,7 +10158,7 @@ function getProgrammaticRouteSearchClientOptions2(search) {
   if (search.temporary?.length) options.temporary = [...search.temporary];
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path41, routePath) {
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path42, routePath) {
   const schema = getProgrammaticRouteSearchSchema(searchConfig);
   const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
   const options = getProgrammaticRouteSearchOptions(searchConfig);
@@ -10124,7 +10167,7 @@ function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path41, routePa
     schema,
     rawSearch,
     parsedSearch: search,
-    path: path41
+    path: path42
   });
   return { search, canonicalPath };
 }
@@ -10203,8 +10246,8 @@ function normalizeComparableValue(value) {
   }
   return value;
 }
-function createRoute(path41, options) {
-  return routesBuilder.page(path41, options);
+function createRoute(path42, options) {
+  return routesBuilder.page(path42, options);
 }
 function isProgrammaticRoutesFileName2(fileName) {
   const normalized = fileName.replace(/\\/g, "/");
@@ -10287,7 +10330,7 @@ function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
     mod.__farmRouteData = route.data;
     mod.__farmRouteParsesProps = true;
     mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
-    mod.__farmResolveRouteCanonicalPath = (rawSearch, path41) => resolveProgrammaticRouteSearch(route.search, rawSearch, path41, route.path).canonicalPath;
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path42) => resolveProgrammaticRouteSearch(route.search, rawSearch, path42, route.path).canonicalPath;
   }
   if (route.pending || route.error || route.notFound) {
     mod.__farmRouteComponents = {
@@ -10697,25 +10740,25 @@ var init_routes = __esm({
     ];
     __name(defineRoutes, "defineRoutes");
     routesBuilder = {
-      page(path41, options) {
+      page(path42, options) {
         return normalizeProgrammaticRoute({
           kind: "page",
-          path: path41,
+          path: path42,
           ...options
         });
       },
-      layout(path41, options) {
+      layout(path42, options) {
         return normalizeProgrammaticRoute({
           kind: "layout",
-          path: path41,
+          path: path42,
           ...options
         });
       },
-      api(path41, options) {
+      api(path42, options) {
         const { render, runtime, regions, maxDuration, ...methods } = options;
         return normalizeProgrammaticRoute({
           kind: "api",
-          path: path41,
+          path: path42,
           render,
           runtime,
           regions,
@@ -11300,7 +11343,7 @@ function getIslandStrategyExport(content) {
 }
 function stripUseClientDirective(content) {
   return content.replace(
-    /^((?:\s|\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)*)(["'])use client\2\s*;?\s*/,
+    /^((?:\s|\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/|(?:"[^"\n]*"|'[^'\n]*')\s*;?)*)(["'])use client\2\s*;?\s*/,
     "$1"
   );
 }
@@ -14588,7 +14631,7 @@ var init_runtime = __esm({
         return this.resolveMessage(locale, key);
       }
       hasMessage(locale, key) {
-        return (this.catalogs[locale]?.[key] ?? this.catalogs[this.config.fallbackLocale]?.[key]) !== void 0;
+        return this.readOwnMessage(locale, key) !== void 0;
       }
       getClientSnapshot(resolution) {
         return {
@@ -14616,8 +14659,19 @@ var init_runtime = __esm({
         }
         return formatter.format(values);
       }
+      // Look up a message by own-property only. A key named after an
+      // Object.prototype member (toString, valueOf, constructor, ...) must resolve
+      // to a real catalog entry or undefined, never the inherited prototype value
+      // (mirrors the own-property handling added to catalog.ts in #454).
+      readOwnMessage(locale, key) {
+        const direct = this.catalogs[locale];
+        if (direct && Object.prototype.hasOwnProperty.call(direct, key)) return direct[key];
+        const fallback = this.catalogs[this.config.fallbackLocale];
+        if (fallback && Object.prototype.hasOwnProperty.call(fallback, key)) return fallback[key];
+        return void 0;
+      }
       resolveMessage(locale, key) {
-        const message = this.catalogs[locale]?.[key] ?? this.catalogs[this.config.fallbackLocale]?.[key];
+        const message = this.readOwnMessage(locale, key);
         if (message !== void 0) return message;
         if (this.config.strict) {
           throw new Error(`Missing Farm i18n message "${key}" for locale "${locale}".`);
@@ -17043,7 +17097,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.96";
+    version = "0.1.0-beta.97";
   }
 });
 
@@ -18111,7 +18165,8 @@ var init_renderer2 = __esm({
           }
           const renderingConfig = await resolveRouteRenderingConfigFromFile(
             routeModule,
-            route.modulePath
+            route.modulePath,
+            { experimentalPPR: this.config.experimental?.ppr === true }
           );
           const pprBypassReason = renderingConfig.ppr ? this.getPPRShellBypassReason(req, middlewareMap, middlewareContext, pluginExposedContext) : void 0;
           const canCachePPRShell = renderingConfig.ppr && !pprBypassReason;
@@ -18816,6 +18871,11 @@ var init_renderer2 = __esm({
           );
           res.statusCode = options.statusCode;
           res.setHeader("Content-Type", "text/html; charset=utf-8");
+          res.setHeader("Cache-Control", "private, no-store");
+          res.setHeader("X-Content-Type-Options", "nosniff");
+          if (typeof res.removeHeader === "function") {
+            res.removeHeader("X-Farm-PPR");
+          }
           res.write(this.createFullHTML(html, false, options.pathname));
           res.end();
           return true;
@@ -19595,6 +19655,7 @@ var init_app = __esm({
             serverComponents: config.experimental?.serverComponents ?? false,
             serverActions: config.experimental?.serverActions ?? false,
             isolatedClientHydration: config.experimental?.isolatedClientHydration ?? "off",
+            ppr: config.experimental?.ppr ?? false,
             ...config.experimental
           },
           vite: config.vite || {}
@@ -19656,15 +19717,15 @@ function isEndpointFailure(value) {
   return value instanceof EndpointFailure;
 }
 function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path41;
+  let path42;
   let options;
   let handler;
   if (typeof pathOrOptions === "string") {
-    path41 = pathOrOptions;
+    path42 = pathOrOptions;
     options = optionsOrHandler;
     handler = maybeHandler;
   } else {
-    path41 = "";
+    path42 = "";
     options = pathOrOptions;
     handler = optionsOrHandler;
   }
@@ -19691,13 +19752,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     ...betterCallOptions
   } = options;
   const endpoint = (0, import_better_call.createEndpoint)(
-    path41 || "/__farm_auto_path__",
+    path42 || "/__farm_auto_path__",
     betterCallOptions,
     wrappedHandler
   );
-  endpoint.__path = path41 || void 0;
+  endpoint.__path = path42 || void 0;
   endpoint.__method = options.method || "GET";
-  endpoint.__autoPath = !path41;
+  endpoint.__autoPath = !path42;
   endpoint.__handler = wrappedHandler;
   endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
   endpoint.__middleware = middleware;
@@ -19708,6 +19769,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
     body: options.body,
     inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
     query: options.query,
+    inputQuery: options.query,
     headers: options.headers,
     response: null,
     errors
@@ -19923,10 +19985,10 @@ function createRouteFactoryAt(prefix) {
     "OPTIONS"
   ]) {
     factory[method.toLowerCase()] = (child, options) => {
-      const path41 = joinRoutePath(prefix, child);
+      const path42 = joinRoutePath(prefix, child);
       const input = options.input ?? {};
       const endpoint = createEndpoint(
-        path41,
+        path42,
         {
           method,
           body: input.body,
@@ -19942,28 +20004,28 @@ function createRouteFactoryAt(prefix) {
       );
       endpoint.__types.params = input.params;
       endpoint.__output = options.output;
-      return Object.freeze({ path: path41, method, endpoint });
+      return Object.freeze({ path: path42, method, endpoint });
     };
   }
   return Object.freeze(factory);
 }
 function joinRoutePath(prefix, child) {
   if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path41 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path41 === "/api" || path41.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path41)) {
+  const path42 = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
+  if (!(path42 === "/api" || path42.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path42)) {
     throw new TypeError(
-      `Plugin route "${path41}" must be a canonical /api path without a query, hash, or empty segment.`
+      `Plugin route "${path42}" must be a canonical /api path without a query, hash, or empty segment.`
     );
   }
-  assertBrowserStableRoutePath(path41);
-  assertUniqueRouteParameters(path41, "api");
-  getRoutePatternShape(path41, "api");
-  for (const segment of path41.split("/")) {
+  assertBrowserStableRoutePath(path42);
+  assertUniqueRouteParameters(path42, "api");
+  getRoutePatternShape(path42, "api");
+  for (const segment of path42.split("/")) {
     if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
       throw new TypeError(`Route segment "${segment}" is reserved.`);
     }
   }
-  return path41;
+  return path42;
 }
 function resolvePluginRoutes(plugins = []) {
   return plugins.flatMap((plugin) => {
@@ -20046,7 +20108,7 @@ function mergePluginAPIRoutes(existing, plugins, expected) {
   }
   const result = [...routes.values()];
   if (expected) {
-    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path41, methods }) => `${path41}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
+    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path: path42, methods }) => `${path42}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
     if (signature(result) !== signature(expected)) {
       throw new Error(
         "Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app."
@@ -21150,6 +21212,59 @@ var init_client_plugin_build = __esm({
   }
 });
 
+// src/client-cache-persistence-build.ts
+function resolveFarmClientCacheAdapterEntry(root, cache) {
+  const client = cache?.client;
+  const adapter = client?.adapter;
+  if (adapter === void 0) return void 0;
+  if (typeof adapter !== "string" || adapter.trim().length === 0) {
+    throw new Error(
+      'cache.client.adapter must be a module path string, for example "./src/cache-adapter".'
+    );
+  }
+  const resolved = import_node_path11.default.resolve(root, adapter);
+  const found = resolveAdapterFile(resolved);
+  if (!found) {
+    throw new Error(
+      `cache.client.adapter was not found: ${adapter} (resolved to ${resolved}). Point it at a client module whose default export is created with defineClientCacheAdapter().`
+    );
+  }
+  const options = {};
+  if (client?.version !== void 0) options.version = client.version;
+  if (client?.flushDelayMs !== void 0) options.flushDelayMs = client.flushDelayMs;
+  return { importPath: found.replace(/\\/g, "/"), options };
+}
+function resolveAdapterFile(resolved) {
+  if (import_node_fs5.default.existsSync(resolved) && import_node_fs5.default.statSync(resolved).isFile()) return resolved;
+  for (const extension of ADAPTER_EXTENSIONS) {
+    const candidate = `${resolved}.${extension}`;
+    if (import_node_fs5.default.existsSync(candidate) && import_node_fs5.default.statSync(candidate).isFile()) return candidate;
+  }
+  return void 0;
+}
+function generateClientCachePersistenceCode(entry) {
+  if (!entry) return { imports: "", init: "" };
+  return {
+    imports: [
+      `import * as __farmClientCacheAdapterModule from ${JSON.stringify(entry.importPath)};`,
+      `import { initConfiguredClientCachePersistence as __farmInitClientCachePersistence } from "@farm.js/core/client";`
+    ].join("\n"),
+    init: `__farmInitClientCachePersistence(__farmClientCacheAdapterModule, ${JSON.stringify(entry.options)});`
+  };
+}
+var import_node_fs5, import_node_path11, ADAPTER_EXTENSIONS;
+var init_client_cache_persistence_build = __esm({
+  "src/client-cache-persistence-build.ts"() {
+    "use strict";
+    import_node_fs5 = __toESM(require("fs"));
+    import_node_path11 = __toESM(require("path"));
+    ADAPTER_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "mjs"];
+    __name(resolveFarmClientCacheAdapterEntry, "resolveFarmClientCacheAdapterEntry");
+    __name(resolveAdapterFile, "resolveAdapterFile");
+    __name(generateClientCachePersistenceCode, "generateClientCachePersistenceCode");
+  }
+});
+
 // src/environment-vite.ts
 function transformEnvironmentFunctions(options) {
   if (!isTransformableModule(options.id) || !containsEnvironmentFunction(options.code)) {
@@ -21505,22 +21620,22 @@ function normalizeRelativePath(value) {
 }
 function resolveExistingPath(filePath) {
   try {
-    return (0, import_node_fs5.realpathSync)(filePath);
+    return (0, import_node_fs6.realpathSync)(filePath);
   } catch {
-    return import_node_path11.default.resolve(filePath);
+    return import_node_path12.default.resolve(filePath);
   }
 }
 function isDocsSourceFile(filePath) {
-  return DOCS_FILE_EXTENSIONS.has(import_node_path11.default.extname(filePath).toLowerCase());
+  return DOCS_FILE_EXTENSIONS.has(import_node_path12.default.extname(filePath).toLowerCase());
 }
 function discoverDocsSourceFiles(contentDir) {
   const files = [];
   const visit = /* @__PURE__ */ __name((dir) => {
-    for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true }).sort(
+    for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true }).sort(
       (a, b) => a.name.localeCompare(b.name)
     )) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path11.default.join(dir, entry.name);
+      const absolutePath = import_node_path12.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
       } else if (entry.isFile() && isDocsSourceFile(absolutePath)) {
@@ -21528,7 +21643,7 @@ function discoverDocsSourceFiles(contentDir) {
       }
     }
   }, "visit");
-  if ((0, import_node_fs5.existsSync)(contentDir)) visit(contentDir);
+  if ((0, import_node_fs6.existsSync)(contentDir)) visit(contentDir);
   return files;
 }
 function getGitLastModifiedDates(contentDir) {
@@ -21538,7 +21653,7 @@ function getGitLastModifiedDates(contentDir) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!gitRoot) return {};
-    const contentPathspec = normalizeRelativePath(import_node_path11.default.relative(gitRoot, contentDir)) || ".";
+    const contentPathspec = normalizeRelativePath(import_node_path12.default.relative(gitRoot, contentDir)) || ".";
     const contentPrefix = contentPathspec === "." ? "" : `${contentPathspec}/`;
     const history = (0, import_node_child_process.execFileSync)(
       "git",
@@ -21580,11 +21695,11 @@ function getGitLastModifiedDates(contentDir) {
   }
 }
 function readManifest(contentDir) {
-  const manifestPath = import_node_path11.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
-  if (!(0, import_node_fs5.existsSync)(manifestPath)) return null;
+  const manifestPath = import_node_path12.default.join(contentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  if (!(0, import_node_fs6.existsSync)(manifestPath)) return null;
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs5.readFileSync)(manifestPath, "utf8")
+      (0, import_node_fs6.readFileSync)(manifestPath, "utf8")
     );
     if (parsed.version !== 1 || !parsed.pages || typeof parsed.pages !== "object") return null;
     const pages = Object.fromEntries(
@@ -21603,15 +21718,15 @@ 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_path11.default.relative(resolvedContentDir, sourcePath));
-    pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs5.statSync)(sourcePath).mtime.toISOString());
+    const relativePath2 = normalizeRelativePath(import_node_path12.default.relative(resolvedContentDir, sourcePath));
+    pages[relativePath2] = gitDates[relativePath2] || (options.fallback === "now" ? fallbackDate : (0, import_node_fs6.statSync)(sourcePath).mtime.toISOString());
   }
   return { version: 1, pages };
 }
 function getLastModifiedManifest(contentDir) {
   const resolvedContentDir = resolveExistingPath(contentDir);
-  const manifestPath = import_node_path11.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
-  const manifestStat = (0, import_node_fs5.existsSync)(manifestPath) ? (0, import_node_fs5.statSync)(manifestPath) : null;
+  const manifestPath = import_node_path12.default.join(resolvedContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST);
+  const manifestStat = (0, import_node_fs6.existsSync)(manifestPath) ? (0, import_node_fs6.statSync)(manifestPath) : null;
   const signature = manifestStat ? `file:${manifestStat.mtimeMs}:${manifestStat.size}` : "generated";
   const cached = manifestCache.get(resolvedContentDir);
   if (cached?.signature === signature) return cached.manifest;
@@ -21624,21 +21739,21 @@ function resolveFarmDocsPageLastModified(contentDir, sourcePath, frontmatter) {
   if (configured) return configured;
   const resolvedContentDir = resolveExistingPath(contentDir);
   const resolvedSourcePath = resolveExistingPath(sourcePath);
-  const relativePath2 = normalizeRelativePath(import_node_path11.default.relative(resolvedContentDir, resolvedSourcePath));
-  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path11.default.isAbsolute(relativePath2);
+  const relativePath2 = normalizeRelativePath(import_node_path12.default.relative(resolvedContentDir, resolvedSourcePath));
+  const isInsideContentDir = relativePath2 !== ".." && !relativePath2.startsWith("../") && !import_node_path12.default.isAbsolute(relativePath2);
   if (isInsideContentDir) {
     const generated = getLastModifiedManifest(resolvedContentDir).pages[relativePath2];
     if (generated) return generated;
   }
-  return (0, import_node_fs5.statSync)(resolvedSourcePath).mtime.toISOString();
+  return (0, import_node_fs6.statSync)(resolvedSourcePath).mtime.toISOString();
 }
-var import_node_child_process, import_node_fs5, import_node_path11, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
+var import_node_child_process, import_node_fs6, import_node_path12, FARM_DOCS_LAST_MODIFIED_MANIFEST, COMMIT_MARKER, DOCS_FILE_EXTENSIONS, manifestCache;
 var init_last_modified = __esm({
   "src/docs/last-modified.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
-    import_node_fs5 = require("fs");
-    import_node_path11 = __toESM(require("path"));
+    import_node_fs6 = require("fs");
+    import_node_path12 = __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"]);
@@ -21671,10 +21786,10 @@ function isFarmDocsSearchEnabled(docs) {
 }
 function resolveFarmDocsSearchClientModule(root) {
   try {
-    const requireFromApp = (0, import_node_module6.createRequire)(import_node_path12.default.join(import_node_path12.default.resolve(root), "package.json"));
+    const requireFromApp = (0, import_node_module6.createRequire)(import_node_path13.default.join(import_node_path13.default.resolve(root), "package.json"));
     const themeEntry = requireFromApp.resolve("@farming-labs/theme");
-    const commandSearchModule = import_node_path12.default.join(import_node_path12.default.dirname(themeEntry), "docs-command-search.mjs");
-    if ((0, import_node_fs6.existsSync)(commandSearchModule)) return commandSearchModule;
+    const commandSearchModule = import_node_path13.default.join(import_node_path13.default.dirname(themeEntry), "docs-command-search.mjs");
+    if ((0, import_node_fs7.existsSync)(commandSearchModule)) return commandSearchModule;
   } catch {
   }
   return void 0;
@@ -21813,13 +21928,13 @@ async function mountFarmDocsSearch() {
 window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
 `;
 }
-var import_node_fs6, import_node_module6, import_node_path12;
+var import_node_fs7, import_node_module6, import_node_path13;
 var init_search_client = __esm({
   "src/docs/search-client.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_module6 = require("module");
-    import_node_path12 = __toESM(require("path"));
+    import_node_path13 = __toESM(require("path"));
     __name(isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
     __name(resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
     __name(generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
@@ -21830,12 +21945,12 @@ var init_search_client = __esm({
 // src/docs/fonts.ts
 function resolveFarmDocsFontAssets(root) {
   return FARM_DOCS_FONT_SOURCES.flatMap(({ family, packagePath }) => {
-    const sourcePath = import_node_path13.default.join(root, "node_modules", packagePath);
-    if (!(0, import_node_fs7.existsSync)(sourcePath)) return [];
-    const source = (0, import_node_fs7.readFileSync)(sourcePath);
+    const sourcePath = import_node_path14.default.join(root, "node_modules", packagePath);
+    if (!(0, import_node_fs8.existsSync)(sourcePath)) return [];
+    const source = (0, import_node_fs8.readFileSync)(sourcePath);
     const fingerprint = (0, import_node_crypto3.createHash)("sha256").update(source).digest("hex").slice(0, 12);
-    const extension = import_node_path13.default.extname(packagePath);
-    const baseName = import_node_path13.default.basename(packagePath, extension);
+    const extension = import_node_path14.default.extname(packagePath);
+    const baseName = import_node_path14.default.basename(packagePath, extension);
     return [
       {
         family,
@@ -21848,13 +21963,13 @@ function resolveFarmDocsFontAssets(root) {
 function toFarmDocsPublicFontAssets(assets) {
   return assets.map(({ family, url }) => ({ family, url }));
 }
-var import_node_crypto3, import_node_fs7, import_node_path13, FARM_DOCS_FONT_SOURCES;
+var import_node_crypto3, import_node_fs8, import_node_path14, FARM_DOCS_FONT_SOURCES;
 var init_fonts = __esm({
   "src/docs/fonts.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
-    import_node_fs7 = require("fs");
-    import_node_path13 = __toESM(require("path"));
+    import_node_fs8 = require("fs");
+    import_node_path14 = __toESM(require("path"));
     FARM_DOCS_FONT_SOURCES = [
       {
         family: "Geist Sans",
@@ -21948,13 +22063,13 @@ function generateFarmIntegrationProviderServerModules(providers, root) {
 }
 function resolveProviderModule(moduleId, root) {
   if (!moduleId.startsWith(".")) return moduleId;
-  return toViteModuleId(import_node_path14.default.resolve(root, moduleId), root);
+  return toViteModuleId(import_node_path15.default.resolve(root, moduleId), root);
 }
-var import_node_path14;
+var import_node_path15;
 var init_integration_provider_build = __esm({
   "src/integration-provider-build.ts"() {
     "use strict";
-    import_node_path14 = __toESM(require("path"));
+    import_node_path15 = __toESM(require("path"));
     init_integrations();
     init_utils();
     __name(generateFarmIntegrationProviderClientCode, "generateFarmIntegrationProviderClientCode");
@@ -21971,9 +22086,9 @@ function getFarmClientOptimizeDepsInclude(renderer) {
   );
 }
 function createFarmClientOptimizeDepsEntries(projectRoot, appDirectories) {
-  const resolvedProjectRoot = import_node_path15.default.resolve(projectRoot);
+  const resolvedProjectRoot = import_node_path16.default.resolve(projectRoot);
   return appDirectories.map((appDirectory) => {
-    const relativeAppDirectory = import_node_path15.default.relative(resolvedProjectRoot, import_node_path15.default.resolve(appDirectory)).replace(/\\/g, "/");
+    const relativeAppDirectory = import_node_path16.default.relative(resolvedProjectRoot, import_node_path16.default.resolve(appDirectory)).replace(/\\/g, "/");
     const prefix = relativeAppDirectory || ".";
     return `${prefix}/${FARM_CLIENT_ENTRY_PATTERN}`;
   });
@@ -21995,7 +22110,7 @@ function createFarmClientOptimizeDepsConfig(entries, renderer) {
 }
 function createFarmSourceAlias(projectRoot, srcDir = "src") {
   return {
-    "@": import_node_path15.default.resolve(projectRoot, srcDir)
+    "@": import_node_path16.default.resolve(projectRoot, srcDir)
   };
 }
 function mergeNoExternal(farmValue, userValue) {
@@ -22059,11 +22174,11 @@ function mergeFarmViteConfig(farmConfig, userConfig = {}) {
     }
   };
 }
-var import_node_path15, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
+var import_node_path16, FARM_CLIENT_ENTRY_PATTERN, FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE;
 var init_vite_config = __esm({
   "src/server/vite-config.ts"() {
     "use strict";
-    import_node_path15 = __toESM(require("path"));
+    import_node_path16 = __toESM(require("path"));
     FARM_CLIENT_ENTRY_PATTERN = "**/{page,layout,loading,error,not-found,default}.{js,jsx,ts,tsx}";
     FARM_CLIENT_OPTIMIZE_DEPS_INCLUDE = [
       "react",
@@ -23161,12 +23276,12 @@ var init_cli_colors = __esm({
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
-var fs8, path28, _MiddlewareManager, MiddlewareManager;
+var fs9, path29, _MiddlewareManager, MiddlewareManager;
 var init_manager = __esm({
   "src/middleware/manager.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path28 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path29 = __toESM(require("path"));
     init_decode();
     init_context();
     init_module();
@@ -23238,7 +23353,7 @@ var init_manager = __esm({
        * Recursively discover middleware files
        */
       async discoverInDirectory(dir, routePath, discovered) {
-        if (!fs8.existsSync(dir)) {
+        if (!fs9.existsSync(dir)) {
           return;
         }
         const middlewareFile = this.findMiddlewareFile(dir);
@@ -23248,10 +23363,10 @@ var init_manager = __esm({
             discovered.push(middleware);
           }
         }
-        const entries = fs8.readdirSync(dir, { withFileTypes: true });
+        const entries = fs9.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-            const subPath = path28.join(dir, entry.name);
+            const subPath = path29.join(dir, entry.name);
             const subRoutePath = appendMiddlewareRoutePath(routePath, entry.name);
             await this.discoverInDirectory(subPath, subRoutePath, discovered);
           }
@@ -23263,8 +23378,8 @@ var init_manager = __esm({
       findMiddlewareFile(dir) {
         const extensions = [".ts", ".tsx", ".js", ".jsx"];
         for (const ext of extensions) {
-          const filePath = path28.join(dir, `middleware${ext}`);
-          if (fs8.existsSync(filePath)) {
+          const filePath = path29.join(dir, `middleware${ext}`);
+          if (fs9.existsSync(filePath)) {
             return filePath;
           }
         }
@@ -23603,7 +23718,7 @@ var init_manager = __esm({
 // src/write-file-if-changed.ts
 function writeFileIfChanged(filePath, content) {
   try {
-    if ((0, import_node_fs9.readFileSync)(filePath, "utf8") === content) {
+    if ((0, import_node_fs10.readFileSync)(filePath, "utf8") === content) {
       return false;
     }
   } catch (error) {
@@ -23611,14 +23726,14 @@ function writeFileIfChanged(filePath, content) {
       throw error;
     }
   }
-  (0, import_node_fs9.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs10.writeFileSync)(filePath, content, "utf8");
   return true;
 }
-var import_node_fs9;
+var import_node_fs10;
 var init_write_file_if_changed = __esm({
   "src/write-file-if-changed.ts"() {
     "use strict";
-    import_node_fs9 = require("fs");
+    import_node_fs10 = require("fs");
     __name(writeFileIfChanged, "writeFileIfChanged");
   }
 });
@@ -23796,9 +23911,9 @@ var init_type_generator = __esm({
         }
         const nestedStructure = {};
         const usedRouteNames = /* @__PURE__ */ new Map();
-        for (const [path41, routeList] of routeGroups) {
-          const routeName = this.uniqueRouteName(path41, usedRouteNames);
-          const cleanPath = path41 === "/api" ? "" : path41.replace(/^\/api\//, "");
+        for (const [path42, routeList] of routeGroups) {
+          const routeName = this.uniqueRouteName(path42, usedRouteNames);
+          const cleanPath = path42 === "/api" ? "" : path42.replace(/^\/api\//, "");
           const parts = cleanPath ? cleanPath.split("/") : [];
           const methodSources = /* @__PURE__ */ new Map();
           for (const route of routeList) {
@@ -23862,11 +23977,11 @@ var init_type_generator = __esm({
           methods.add(route.method);
           manifest.set(route.path, methods);
         }
-        const routeManifest = [...manifest].sort(([a], [b]) => a.localeCompare(b)).map(([path41, methods]) => ({ path: path41, methods: [...methods].sort() }));
+        const routeManifest = [...manifest].sort(([a], [b]) => a.localeCompare(b)).map(([path42, methods]) => ({ path: path42, methods: [...methods].sort() }));
         const manifestSource = routeManifest.length ? `[
 ${routeManifest.map(
-          ({ path: path41, methods }) => `  {
-    path: ${JSON.stringify(path41)},
+          ({ path: path42, methods }) => `  {
+    path: ${JSON.stringify(path42)},
     methods: [${methods.map((method) => JSON.stringify(method)).join(", ")}],
   },`
         ).join("\n")}
@@ -23896,11 +24011,11 @@ export const apiRoutes = ${manifestSource} as const;
         const relativeImport = (0, import_path12.relative)((0, import_path12.dirname)(outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
         return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       }
-      pathToRouteName(path41) {
-        return (path41 === "/api" ? "root" : path41.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
+      pathToRouteName(path42) {
+        return (path42 === "/api" ? "root" : path42.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
       }
-      uniqueRouteName(path41, usedNames) {
-        const base = this.pathToRouteName(path41);
+      uniqueRouteName(path42, usedNames) {
+        const base = this.pathToRouteName(path42);
         const seen = usedNames.get(base);
         usedNames.set(base, (seen ?? 0) + 1);
         return seen ? `${base}_${seen + 1}` : base;
@@ -23923,15 +24038,15 @@ export const apiRoutes = ${manifestSource} as const;
       toTypePropertyKey(key) {
         return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
       }
-      getBaseExportName(path41) {
-        const cleanPath = path41.replace(/^\/api\//, "");
+      getBaseExportName(path42) {
+        const cleanPath = path42.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return "api";
         }
         return cleanPath;
       }
-      getExportName(path41, method) {
-        const cleanPath = path41.replace(/^\/api\//, "");
+      getExportName(path42, method) {
+        const cleanPath = path42.replace(/^\/api\//, "");
         if (cleanPath === "") {
           return method.toLowerCase();
         }
@@ -24000,12 +24115,12 @@ function createRoutePattern(route) {
   }).join("/");
 }
 async function generateRouteTypes(options) {
-  const root = path29.resolve(options.root);
+  const root = path30.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path29.isAbsolute(outFile) ? outFile : path29.join(root, srcDir, outFile);
+  const outPath = path30.isAbsolute(outFile) ? outFile : path30.join(root, srcDir, outFile);
   const content = await createRouteTypeDeclarations(options, outPath);
-  fs9.mkdirSync(path29.dirname(outPath), { recursive: true });
+  fs10.mkdirSync(path30.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
@@ -24019,8 +24134,8 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
-    const appDir = path29.join(source.root, source.srcDir, "app");
-    if (fs9.existsSync(appDir)) {
+    const appDir = path30.join(source.root, source.srcDir, "app");
+    if (fs10.existsSync(appDir)) {
       const routeModuleFiles = await glob.default(
         `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
         {
@@ -24056,7 +24171,7 @@ async function createRouteTypeDeclarations(options, outPath) {
   const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
   const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
   const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
-  const routeTypesImportPath = `./${path29.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const routeTypesImportPath = `./${path30.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
@@ -24103,12 +24218,12 @@ ${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentati
 `;
   return content;
 }
-var path29, fs9, DEFAULT_OUT_FILE;
+var path30, fs10, DEFAULT_OUT_FILE;
 var init_generate_route_types = __esm({
   "src/routing/generate-route-types.ts"() {
     "use strict";
-    path29 = __toESM(require("path"));
-    fs9 = __toESM(require("fs"));
+    path30 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
     init_utils();
     init_route_slots();
     init_routes_server();
@@ -24128,20 +24243,20 @@ var init_generate_route_types = __esm({
 
 // src/env-types.ts
 async function generateEnvTypes(options) {
-  const root = path30.resolve(options.root);
+  const root = path31.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const outFile = options.outFile || DEFAULT_OUT_FILE2;
-  const outPath = path30.isAbsolute(outFile) ? outFile : path30.join(root, srcDir, outFile);
+  const outPath = path31.isAbsolute(outFile) ? outFile : path31.join(root, srcDir, outFile);
   const content = createEnvTypeDeclarations(options, outPath);
-  fs10.mkdirSync(path30.dirname(outPath), { recursive: true });
+  fs11.mkdirSync(path31.dirname(outPath), { recursive: true });
   writeFileIfChanged(outPath, content);
   return outPath;
 }
 function createEnvTypeDeclarations(options, outPath) {
-  const root = path30.resolve(options.root);
+  const root = path31.resolve(options.root);
   const configPath = findConfigPath(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs10.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs11.existsSync(value)),
     ...configPath ? [configPath] : []
   ];
   const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
@@ -24201,12 +24316,12 @@ export {};
 }
 function findConfigPath(root, configPath) {
   if (configPath) {
-    const resolvedPath = path30.isAbsolute(configPath) ? configPath : path30.join(root, configPath);
-    return fs10.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path31.isAbsolute(configPath) ? configPath : path31.join(root, configPath);
+    return fs11.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES2) {
-    const resolvedPath = path30.join(root, filename);
-    if (fs10.existsSync(resolvedPath)) {
+    const resolvedPath = path31.join(root, filename);
+    if (fs11.existsSync(resolvedPath)) {
       return resolvedPath;
     }
   }
@@ -24266,15 +24381,15 @@ export {};
 `;
 }
 function toTypeImportPath(outPath, targetPath) {
-  const relativePath2 = path30.relative(path30.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path31.relative(path31.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs10, path30, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
+var fs11, path31, DEFAULT_OUT_FILE2, CONFIG_FILENAMES2;
 var init_env_types = __esm({
   "src/env-types.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path30 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path31 = __toESM(require("path"));
     init_write_file_if_changed();
     DEFAULT_OUT_FILE2 = "farm-env.d.ts";
     CONFIG_FILENAMES2 = [
@@ -24307,8 +24422,8 @@ var init_env_types = __esm({
 
 // src/image-types.ts
 function generateFarmImageTypes(options) {
-  const outputPath = options.outFile ? import_node_path17.default.resolve(options.root, options.outFile) : import_node_path17.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
-  (0, import_node_fs10.mkdirSync)(import_node_path17.default.dirname(outputPath), { recursive: true });
+  const outputPath = options.outFile ? import_node_path18.default.resolve(options.root, options.outFile) : import_node_path18.default.join(options.root, options.srcDir || "src", "farm-images.d.ts");
+  (0, import_node_fs11.mkdirSync)(import_node_path18.default.dirname(outputPath), { recursive: true });
   writeFileIfChanged(outputPath, createFarmImageTypeDeclarations());
   return outputPath;
 }
@@ -24332,12 +24447,12 @@ declare module "*?url" {
 }
 `;
 }
-var import_node_fs10, import_node_path17, FARM_STATIC_IMAGE_EXTENSIONS;
+var import_node_fs11, import_node_path18, FARM_STATIC_IMAGE_EXTENSIONS;
 var init_image_types = __esm({
   "src/image-types.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
-    import_node_path17 = __toESM(require("path"));
+    import_node_fs11 = require("fs");
+    import_node_path18 = __toESM(require("path"));
     init_write_file_if_changed();
     FARM_STATIC_IMAGE_EXTENSIONS = ["avif", "gif", "jpeg", "jpg", "png", "webp"];
     __name(generateFarmImageTypes, "generateFarmImageTypes");
@@ -24347,10 +24462,10 @@ var init_image_types = __esm({
 
 // src/content-types.ts
 function createContentTypeDeclarations(options, outPath) {
-  const root = path32.resolve(options.root);
+  const root = path33.resolve(options.root);
   const projectConfig = findConfigPath2(root, options.configPath);
   const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs11.existsSync(value)),
+    ...(options.layerConfigPaths ?? []).filter((value) => fs12.existsSync(value)),
     ...projectConfig ? [projectConfig] : []
   ];
   if (configPaths.length === 0) return createEmptyContentTypes();
@@ -24418,25 +24533,25 @@ export {};
 }
 function findConfigPath2(root, configPath) {
   if (configPath) {
-    const resolvedPath = path32.isAbsolute(configPath) ? configPath : path32.join(root, configPath);
-    return fs11.existsSync(resolvedPath) ? resolvedPath : null;
+    const resolvedPath = path33.isAbsolute(configPath) ? configPath : path33.join(root, configPath);
+    return fs12.existsSync(resolvedPath) ? resolvedPath : null;
   }
   for (const filename of CONFIG_FILENAMES3) {
-    const resolvedPath = path32.join(root, filename);
-    if (fs11.existsSync(resolvedPath)) return resolvedPath;
+    const resolvedPath = path33.join(root, filename);
+    if (fs12.existsSync(resolvedPath)) return resolvedPath;
   }
   return null;
 }
 function toTypeImportPath2(outPath, targetPath) {
-  const relativePath2 = path32.relative(path32.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  const relativePath2 = path33.relative(path33.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
   return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
 }
-var fs11, path32, CONFIG_FILENAMES3;
+var fs12, path33, CONFIG_FILENAMES3;
 var init_content_types = __esm({
   "src/content-types.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path32 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path33 = __toESM(require("path"));
     CONFIG_FILENAMES3 = [
       "farm.config.ts",
       "farm.config.tsx",
@@ -24466,9 +24581,9 @@ var init_content_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_path18.resolve)(options.root, options.outFile) : (0, import_node_path18.join)((0, import_node_path18.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? (0, import_node_path19.resolve)(options.root, options.outFile) : (0, import_node_path19.join)((0, import_node_path19.resolve)(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
-  (0, import_node_fs11.mkdirSync)((0, import_node_path18.dirname)(outFile), { recursive: true });
+  (0, import_node_fs12.mkdirSync)((0, import_node_path19.dirname)(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
   return outFile;
 }
@@ -24509,12 +24624,12 @@ function argumentType(kind) {
       return "string";
   }
 }
-var import_node_fs11, import_node_path18;
+var import_node_fs12, import_node_path19;
 var init_type_generator2 = __esm({
   "src/i18n/type-generator.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
-    import_node_path18 = require("path");
+    import_node_fs12 = require("fs");
+    import_node_path19 = require("path");
     init_catalog();
     init_write_file_if_changed();
     __name(generateFarmI18nTypes, "generateFarmI18nTypes");
@@ -24936,11 +25051,11 @@ function devServableFileExists(pathname, baseDirs) {
   if (!relativePathname) return false;
   for (const baseDir of baseDirs) {
     if (typeof baseDir !== "string" || baseDir.length === 0) continue;
-    const resolvedBase = path33.resolve(baseDir);
-    const candidate = path33.resolve(resolvedBase, relativePathname);
-    if (!candidate.startsWith(resolvedBase + path33.sep)) continue;
+    const resolvedBase = path34.resolve(baseDir);
+    const candidate = path34.resolve(resolvedBase, relativePathname);
+    if (!candidate.startsWith(resolvedBase + path34.sep)) continue;
     try {
-      if (fs12.existsSync(candidate) && fs12.statSync(candidate).isFile()) {
+      if (fs13.existsSync(candidate) && fs13.statSync(candidate).isFile()) {
         return true;
       }
     } catch {
@@ -24948,12 +25063,12 @@ function devServableFileExists(pathname, baseDirs) {
   }
   return false;
 }
-var fs12, path33;
+var fs13, path34;
 var init_dev_static = __esm({
   "src/dev-static.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path33 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path34 = __toESM(require("path"));
     __name(shouldBypassFarmRouterForDottedPath, "shouldBypassFarmRouterForDottedPath");
     __name(devServableFileExists, "devServableFileExists");
   }
@@ -24962,6 +25077,7 @@ var init_dev_static = __esm({
 // src/server-query-boundary.ts
 function findClientServerFnViolation(code, id) {
   if (id.startsWith("\0") || id.startsWith("virtual:") || id.includes("node_modules")) return null;
+  if (/\.(md|mdx)(\?|$)/.test(id)) return null;
   if (!code.includes("@farm.js/core")) return null;
   for (const match of code.matchAll(FARM_CORE_IMPORT_RE)) {
     const specifiers = match[1];
@@ -25052,12 +25168,12 @@ async function createBlurDataURL(bytes) {
     return void 0;
   }
 }
-var import_promises8, import_node_path19, import_image_size2, FARM_IMAGE_ID_PREFIX, STATIC_IMAGE_RE, SCRIPT_IMPORTER_RE;
+var import_promises8, import_node_path20, 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_promises8 = require("fs/promises");
-    import_node_path19 = __toESM(require("path"));
+    import_node_path20 = __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;
@@ -26072,10 +26188,10 @@ function resolveFarmDocsFavicon(docs, options) {
   if (typeof configuredFavicon === "string" && configuredFavicon.trim()) {
     return configuredFavicon.trim();
   }
-  const publicDir = import_node_path20.default.join(import_node_path20.default.resolve(options.root), "public");
+  const publicDir = import_node_path21.default.join(import_node_path21.default.resolve(options.root), "public");
   for (const fileName of FARM_DOCS_FAVICON_FILES) {
-    const faviconPath = import_node_path20.default.join(publicDir, fileName);
-    if ((0, import_node_fs12.existsSync)(faviconPath) && (0, import_node_fs12.statSync)(faviconPath).isFile()) {
+    const faviconPath = import_node_path21.default.join(publicDir, fileName);
+    if ((0, import_node_fs13.existsSync)(faviconPath) && (0, import_node_fs13.statSync)(faviconPath).isFile()) {
       return `/${fileName}`;
     }
   }
@@ -26109,10 +26225,10 @@ function isSafeSegment(segment) {
   return segment !== ".." && !segment.includes("/") && !segment.includes("\\");
 }
 function resolveInside(root, target) {
-  const resolvedRoot = import_node_path20.default.resolve(root);
-  const resolvedTarget = import_node_path20.default.resolve(target);
-  const relative6 = import_node_path20.default.relative(resolvedRoot, resolvedTarget);
-  if (relative6 === "" || !relative6.startsWith("..") && !import_node_path20.default.isAbsolute(relative6)) {
+  const resolvedRoot = import_node_path21.default.resolve(root);
+  const resolvedTarget = import_node_path21.default.resolve(target);
+  const relative6 = import_node_path21.default.relative(resolvedRoot, resolvedTarget);
+  if (relative6 === "" || !relative6.startsWith("..") && !import_node_path21.default.isAbsolute(relative6)) {
     return resolvedTarget;
   }
   return null;
@@ -26121,10 +26237,10 @@ function resolveExistingFileInside(root, target) {
   const safePath = resolveInside(root, target);
   if (!safePath) return null;
   try {
-    const realRoot = (0, import_node_fs12.realpathSync)(root);
-    const realTarget = (0, import_node_fs12.realpathSync)(safePath);
+    const realRoot = (0, import_node_fs13.realpathSync)(root);
+    const realTarget = (0, import_node_fs13.realpathSync)(safePath);
     const containedTarget = resolveInside(realRoot, realTarget);
-    return containedTarget && (0, import_node_fs12.statSync)(containedTarget).isFile() ? containedTarget : null;
+    return containedTarget && (0, import_node_fs13.statSync)(containedTarget).isFile() ? containedTarget : null;
   } catch {
     return null;
   }
@@ -26138,16 +26254,16 @@ function isFarmDocsRequest(docs, request) {
   return pathname === entry || pathname === `${entry}.md` || pathname.startsWith(`${entry}/`);
 }
 function resolveFarmDocsContentDir(docs, options) {
-  const root = import_node_path20.default.resolve(options.root);
+  const root = import_node_path21.default.resolve(options.root);
   const srcDir = options.srcDir || "src";
   const configuredContentDir = docs.contentDir || docs.config.contentDir;
   if (configuredContentDir) {
-    return import_node_path20.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path20.default.join(root, configuredContentDir);
+    return import_node_path21.default.isAbsolute(configuredContentDir) ? configuredContentDir : import_node_path21.default.join(root, configuredContentDir);
   }
   const entryDir = docs.config.entry || trimSlashes2(docs.entry) || "docs";
-  const appDocsDir = import_node_path20.default.join(root, srcDir, "app", entryDir);
-  if ((0, import_node_fs12.existsSync)(appDocsDir)) return appDocsDir;
-  return import_node_path20.default.join(root, entryDir);
+  const appDocsDir = import_node_path21.default.join(root, srcDir, "app", entryDir);
+  if ((0, import_node_fs13.existsSync)(appDocsDir)) return appDocsDir;
+  return import_node_path21.default.join(root, entryDir);
 }
 function getFarmDocsRouteTypeEntries(docs) {
   if (!docs?.enabled) return [];
@@ -26170,10 +26286,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_path20.default.join(contentDir, ...segments);
-  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path20.default.join(contentDir, filename)) : [
-    ...DOCS_FILE_NAMES.map((filename) => import_node_path20.default.join(slugDir, filename)),
-    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path20.default.join(contentDir, `${slug}${extension}`))
+  const slugDir = import_node_path21.default.join(contentDir, ...segments);
+  const candidates = segments.length === 0 ? DOCS_FILE_NAMES.map((filename) => import_node_path21.default.join(contentDir, filename)) : [
+    ...DOCS_FILE_NAMES.map((filename) => import_node_path21.default.join(slugDir, filename)),
+    ...DOCS_FILE_EXTENSIONS2.map((extension) => import_node_path21.default.join(contentDir, `${slug}${extension}`))
   ];
   for (const candidate of candidates) {
     const safePath = resolveExistingFileInside(contentDir, candidate);
@@ -26212,7 +26328,7 @@ function titleFromMarkdown2(body, fallback) {
 function loadFarmDocsPage(contentDir, docs, slug) {
   const sourcePath = findDocsPageFile(contentDir, slug);
   if (!sourcePath) return null;
-  const source = (0, import_node_fs12.readFileSync)(sourcePath, "utf8");
+  const source = (0, import_node_fs13.readFileSync)(sourcePath, "utf8");
   const { frontmatter, body } = parseFrontmatter(source);
   const title = frontmatter.title || titleFromMarkdown2(body, titleFromSlug(slug));
   const href = createDocsHref(docs.entry, slug);
@@ -26235,9 +26351,9 @@ function createDocsHref(entry, slug) {
   return normalizedSlug ? `${normalizedEntry}/${normalizedSlug}` : normalizedEntry;
 }
 function pathToSlug(contentDir, filePath) {
-  const relative6 = import_node_path20.default.relative(contentDir, filePath).replace(/\\/g, "/");
+  const relative6 = import_node_path21.default.relative(contentDir, filePath).replace(/\\/g, "/");
   if (relative6.startsWith("..")) return null;
-  const extension = import_node_path20.default.extname(relative6);
+  const extension = import_node_path21.default.extname(relative6);
   if (!DOCS_FILE_EXTENSIONS2.includes(extension)) return null;
   const withoutExtension = relative6.slice(0, -extension.length);
   if (withoutExtension === "page" || withoutExtension === "index") return "";
@@ -26250,12 +26366,12 @@ function loadPage(contentDir, docs, request) {
   return loadFarmDocsPage(contentDir, docs, getRequestSlug(docs, request));
 }
 function discoverFarmDocsPages(contentDir, docs) {
-  if (!(0, import_node_fs12.existsSync)(contentDir)) return [];
+  if (!(0, import_node_fs13.existsSync)(contentDir)) return [];
   const pages = [];
   const visit = /* @__PURE__ */ __name((dir) => {
-    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const absolutePath = import_node_path20.default.join(dir, entry.name);
+      const absolutePath = import_node_path21.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         visit(absolutePath);
         continue;
@@ -26263,7 +26379,7 @@ function discoverFarmDocsPages(contentDir, docs) {
       if (!entry.isFile()) continue;
       const slug = pathToSlug(contentDir, absolutePath);
       if (slug === null) continue;
-      const source = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
+      const source = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
       const { frontmatter, body } = parseFrontmatter(source);
       pages.push({
         slug,
@@ -26782,11 +26898,30 @@ function renderMarkdownHtml(body) {
 function extractTocItems(body, depth) {
   const slug = createSlugger();
   const maxLevel = Math.max(2, Math.min(depth, 6));
-  return body.split(/\r?\n/).map((line) => line.match(/^(#{2,6})\s+(.+)$/)).filter((match) => Boolean(match)).map((match) => ({
-    id: slug(match[2].trim()),
-    title: match[2].trim(),
-    level: match[1].length
-  })).filter((item) => item.level <= maxLevel);
+  const items = [];
+  let fence = null;
+  for (const line of body.split(/\r?\n/)) {
+    const nextFence = getCodeFence(line);
+    if (fence) {
+      if (nextFence && nextFence.marker === fence.marker && isClosingCodeFence(line, fence)) {
+        fence = null;
+      }
+      continue;
+    }
+    if (nextFence) {
+      fence = nextFence;
+      continue;
+    }
+    const match = line.match(/^(#{2,6})\s+(.+)$/);
+    if (!match) continue;
+    const title = match[2].trim();
+    const id = slug(title);
+    const level = match[1].length;
+    if (level <= maxLevel) {
+      items.push({ id, title, level });
+    }
+  }
+  return items;
 }
 function getThemeUI(docs) {
   const theme = docs.config.theme;
@@ -27275,12 +27410,12 @@ function createFarmDocsHandler(docs, options) {
     );
   }, "handleFarmDocsRequest");
 }
-var import_node_fs12, import_node_path20, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER;
+var import_node_fs13, import_node_path21, import_docs, import_marked, import_sugar_high, DOCS_FILE_NAMES, DOCS_FILE_EXTENSIONS2, FARM_DOCS_FALLBACK_FAVICON, FARM_DOCS_FAVICON_FILES, CODE_LANGUAGE_LABELS, EXTENSIONLESS_CODE_FILENAMES, SIDEBAR_SECTION_ORDER, SIDEBAR_PAGE_ORDER;
 var init_handler = __esm({
   "src/docs/handler.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
-    import_node_path20 = __toESM(require("path"));
+    import_node_fs13 = require("fs");
+    import_node_path21 = __toESM(require("path"));
     import_docs = require("@farming-labs/docs");
     import_marked = require("marked");
     import_sugar_high = require("sugar-high");
@@ -28313,8 +28448,8 @@ var init_generator = __esm({
           }
           routeGroups.get(key).push(route);
         }
-        for (const [path41, routeList] of routeGroups) {
-          const openAPIPath = this.convertToOpenAPIPath(path41);
+        for (const [path42, routeList] of routeGroups) {
+          const openAPIPath = this.convertToOpenAPIPath(path42);
           spec.paths[openAPIPath] = {};
           for (const route of routeList) {
             for (const method of route.methods) {
@@ -28334,8 +28469,8 @@ var init_generator = __esm({
       /**
        * Convert Farm.js API path to OpenAPI path format
        */
-      convertToOpenAPIPath(path41) {
-        return path41.replace(/^\/api/, "");
+      convertToOpenAPIPath(path42) {
+        return path42.replace(/^\/api/, "");
       }
       /**
        * Extract request body schema from endpoint
@@ -28497,8 +28632,8 @@ var init_generator = __esm({
       /**
        * Generate operation summary
        */
-      generateSummary(path41, method) {
-        const cleanPath = path41.replace(/^\/api\//, "");
+      generateSummary(path42, method) {
+        const cleanPath = path42.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         const lastPart = pathParts[pathParts.length - 1];
         const action = method === "GET" ? "Get" : method === "QUERY" ? "Query" : method === "POST" ? "Create" : method === "PUT" ? "Update" : method === "DELETE" ? "Delete" : method === "PATCH" ? "Update" : method;
@@ -28507,22 +28642,22 @@ var init_generator = __esm({
       /**
        * Generate operation description
        */
-      generateDescription(path41, method) {
-        const cleanPath = path41.replace(/^\/api\//, "");
+      generateDescription(path42, method) {
+        const cleanPath = path42.replace(/^\/api\//, "");
         return `${method} ${cleanPath} endpoint`;
       }
       /**
        * Generate operation ID
        */
-      generateOperationId(path41, method) {
-        const cleanPath = path41.replace(/^\/api\//, "").replace(/\//g, "_");
+      generateOperationId(path42, method) {
+        const cleanPath = path42.replace(/^\/api\//, "").replace(/\//g, "_");
         return `${method.toLowerCase()}_${cleanPath}`;
       }
       /**
        * Generate tags for grouping operations
        */
-      generateTags(path41) {
-        const cleanPath = path41.replace(/^\/api\//, "");
+      generateTags(path42) {
+        const cleanPath = path42.replace(/^\/api\//, "");
         const pathParts = cleanPath.split("/");
         if (pathParts.length > 1) {
           return [pathParts[0]];
@@ -28534,13 +28669,13 @@ var init_generator = __esm({
        */
       async generateSpecFile(routes, outputPath) {
         const spec = await this.generateSpec(routes);
-        const fs14 = require("fs");
-        const path41 = require("path");
-        const dir = path41.dirname(outputPath);
-        if (!fs14.existsSync(dir)) {
-          fs14.mkdirSync(dir, { recursive: true });
+        const fs15 = require("fs");
+        const path42 = require("path");
+        const dir = path42.dirname(outputPath);
+        if (!fs15.existsSync(dir)) {
+          fs15.mkdirSync(dir, { recursive: true });
         }
-        fs14.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
+        fs15.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
       }
     };
     __name(_OpenAPIGenerator, "OpenAPIGenerator");
@@ -28968,7 +29103,7 @@ async function createFarmDevtoolsSnapshot(input) {
     generatedAt: (input.now?.() || /* @__PURE__ */ new Date()).toISOString(),
     health: resolveHealth(diagnostics),
     project: {
-      name: import_node_path21.default.basename(import_node_path21.default.resolve(input.root)),
+      name: import_node_path22.default.basename(import_node_path22.default.resolve(input.root)),
       root: input.root,
       srcDir: input.srcDir,
       basePath: config.basePath || "/",
@@ -29017,11 +29152,11 @@ async function createFarmDevtoolsSnapshot(input) {
     diagnostics
   };
 }
-var import_node_path21;
+var import_node_path22;
 var init_devtools = __esm({
   "src/devtools.ts"() {
     "use strict";
-    import_node_path21 = __toESM(require("path"));
+    import_node_path22 = __toESM(require("path"));
     init_config4();
     init_cron();
     init_route_runtime();
@@ -29662,6 +29797,7 @@ function renderFarmDevtoolsHtml(snapshot) {
     .nav-item .icon { width: 13px; height: 13px; }
     .nav-item small { color: #666; font-size: 9px; font-weight: 400; }
     .topbar-meta { display: flex; flex: 0 0 auto; margin-left: auto; border-left: 1px solid var(--line); }
+    .deprecation-tag { display: inline-flex; align-items: center; padding: 0 10px; border-right: 1px solid var(--line); color: #d9a626; font-family: var(--font-mono); font-size: 10px; text-transform: uppercase; white-space: nowrap; }
     .topbar-status { display: flex; min-width: max-content; align-items: center; gap: 7px; padding: 0 11px; color: var(--muted-strong); font-family: var(--font-mono); font-size: 9px; text-transform: uppercase; }
     .status-dot { width: 5px; height: 5px; background: #fff; box-shadow: 0 0 0 3px rgb(255 255 255 / 0.06); }
     .status-dot-attention { background: #909090; animation: status-pulse 1.8s ease-in-out infinite; }
@@ -30171,6 +30307,7 @@ function renderFarmDevtoolsHtml(snapshot) {
           ${renderNavigationItem("raw", "Raw")}
         </nav>
         <div class="topbar-meta">
+          <span class="deprecation-tag" title="The built-in dashboard is deprecated. Install @farm.js/devtools for the maintained workspace.">Deprecated &middot; use @farm.js/devtools</span>
           <span class="project-select">${escapeHtml3(snapshot.project.name)} ${icon(
     "chevron"
   )}</span>
@@ -30822,6 +30959,8 @@ __export(vite_exports, {
   defineConfig: () => defineConfig2,
   farmI18nClientBridgePlugin: () => farmI18nClientBridgePlugin,
   farmPlugin: () => farmPlugin,
+  generateClientCachePersistenceCode: () => generateClientCachePersistenceCode,
+  resolveFarmClientCacheAdapterEntry: () => resolveFarmClientCacheAdapterEntry,
   rewriteEarlySsrRelativeImports: () => rewriteEarlySsrRelativeImports,
   transformIsolatedClientBoundaryModule: () => transformIsolatedClientBoundaryModule,
   withFarmRequestTracing: () => withFarmRequestTracing
@@ -31191,18 +31330,18 @@ function isPotentialProgrammaticRouteSourceFile(normalizedFile, srcDirSlug) {
   return normalizedFile.startsWith(`${srcDirSlug}/`) && /\.(ts|tsx|js|jsx)$/.test(normalizedFile) && !normalizedFile.endsWith(".d.ts") && !normalizedFile.endsWith("/farm-routes.d.ts") && !normalizedFile.endsWith("/farm-env.d.ts") && !normalizedFile.endsWith("/lib/api.generated.ts");
 }
 function fileContainsProgrammaticPageRoute(file) {
-  if (!fs13.existsSync(file)) {
+  if (!fs14.existsSync(file)) {
     return false;
   }
   try {
-    return scanProgrammaticPagePaths(fs13.readFileSync(file, "utf8")).length > 0;
+    return scanProgrammaticPagePaths(fs14.readFileSync(file, "utf8")).length > 0;
   } catch {
     return false;
   }
 }
 function rewriteEarlySsrRelativeImports(options) {
   const cleanId = options.id.split("?", 1)[0];
-  if (!path37.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
+  if (!path38.isAbsolute(cleanId) || cleanId.replace(/\\/g, "/").includes("/node_modules/")) {
     return null;
   }
   const replacements = [];
@@ -31222,7 +31361,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 = path37.resolve(path37.dirname(cleanId), sourcePath);
+    const resolvedPath = path38.resolve(path38.dirname(cleanId), sourcePath);
     replacements.push({
       start: source.start,
       end: source.end,
@@ -31379,7 +31518,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...layerRoots.length ? {
           server: {
             fs: {
-              allow: [path37.resolve(options.root || process.cwd()), ...layerRoots]
+              allow: [path38.resolve(options.root || process.cwd()), ...layerRoots]
             }
           }
         } : {}
@@ -31410,13 +31549,13 @@ function farmPlugin(options = {}, initialPluginManager) {
         },
         server
       );
-      const globalsCSSPath = path37.join(server.config.root, "src/app/globals.css");
-      if (!fs13.existsSync(globalsCSSPath)) {
-        const appDir = path37.join(server.config.root, "src/app");
-        if (!fs13.existsSync(appDir)) {
-          fs13.mkdirSync(appDir, { recursive: true });
+      const globalsCSSPath = path38.join(server.config.root, "src/app/globals.css");
+      if (!fs14.existsSync(globalsCSSPath)) {
+        const appDir = path38.join(server.config.root, "src/app");
+        if (!fs14.existsSync(appDir)) {
+          fs14.mkdirSync(appDir, { recursive: true });
         }
-        fs13.writeFileSync(globalsCSSPath, defaultGlobalCSS);
+        fs14.writeFileSync(globalsCSSPath, defaultGlobalCSS);
       }
       await farmApp.initialize();
       const farmConfig = farmApp.getConfig();
@@ -31437,10 +31576,10 @@ function farmPlugin(options = {}, initialPluginManager) {
         });
       }
       const sourceRoots = getFarmSourceRoots(farmConfig);
-      server.watcher.add(sourceRoots.map((source) => path37.join(source.root, source.srcDir)));
+      server.watcher.add(sourceRoots.map((source) => path38.join(source.root, source.srcDir)));
       if (farmConfig.i18n.enabled) {
         server.watcher.add(
-          farmConfig.i18n.messages.includes("{locale}") ? path37.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
+          farmConfig.i18n.messages.includes("{locale}") ? path38.dirname(farmConfig.i18n.messages) : farmConfig.i18n.messages
         );
       }
       const workflowConfig = farmConfig.workflows;
@@ -31450,7 +31589,7 @@ function farmPlugin(options = {}, initialPluginManager) {
         ...farmDocsDevRuntime?.getFarmDocsRouteTypeEntries(farmConfig.docs) ?? []
       ], "getExtraRouteTypes");
       const appDirSlugs = sourceRoots.map(
-        (source) => path37.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
+        (source) => path38.join(source.root, source.srcDir, "app").replace(/\\/g, "/")
       );
       const generateTypeArtifacts = /* @__PURE__ */ __name(async (reason, selection = ALL_TYPE_ARTIFACTS, log = false) => {
         try {
@@ -31491,7 +31630,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       }, "generateTypeArtifacts");
       await generateTypeArtifacts("startup");
       const srcDirSlugs = sourceRoots.map(
-        (source) => path37.join(source.root, source.srcDir).replace(/\\/g, "/")
+        (source) => path38.join(source.root, source.srcDir).replace(/\\/g, "/")
       );
       const layerConfigFiles = new Set(
         farmConfig.layers.map((layer) => layer.configFile?.replace(/\\/g, "/")).filter((file) => Boolean(file))
@@ -31612,7 +31751,7 @@ function farmPlugin(options = {}, initialPluginManager) {
       await apiRouteManager.discoverRoutes();
       let discoveredWorkflows = [];
       const hasWorkflowDirectory = workflowConfig.enabled && workflowConfig.dirs.some(
-        (dir) => fs13.existsSync(path37.isAbsolute(dir) ? dir : path37.join(farmConfig.root, dir))
+        (dir) => fs14.existsSync(path38.isAbsolute(dir) ? dir : path38.join(farmConfig.root, dir))
       );
       if (hasWorkflowDirectory) {
         const { createFarmWorkflowRequestHandler: createFarmWorkflowRequestHandler2, discoverFarmWorkflows: discoverFarmWorkflows2 } = await loadFarmWorkflowsDevRuntime();
@@ -31877,12 +32016,12 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             }
           }
           const farmDocsFontPath = farmDocsFontAssets.get(requestPathname);
-          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs13.existsSync(farmDocsFontPath)) {
+          if ((requestMethod === "GET" || requestMethod === "HEAD") && farmDocsFontPath && fs14.existsSync(farmDocsFontPath)) {
             res.statusCode = 200;
             res.setHeader("Content-Type", "font/woff2");
             res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
             if (requestMethod === "HEAD") res.end();
-            else fs13.createReadStream(farmDocsFontPath).pipe(res);
+            else fs14.createReadStream(farmDocsFontPath).pipe(res);
             return;
           }
           if (requestMethod === "GET" && (requestPathname === FARM_DEVTOOLS_PATH || requestPathname === `${FARM_DEVTOOLS_PATH}.json`)) {
@@ -31938,6 +32077,12 @@ window.__FARM_MANIFEST__ = ${inlineValue({
             if (requestPathname.endsWith(".json")) {
               res.end(JSON.stringify(snapshot, null, 2));
             } else {
+              if (!warnedDeprecatedDevtoolsDashboard) {
+                warnedDeprecatedDevtoolsDashboard = true;
+                logger.warn(
+                  "The built-in DevTools dashboard is deprecated. Install @farm.js/devtools and add devtools() to plugins in farm.config.ts."
+                );
+              }
               const { renderFarmDevtoolsHtml: renderFarmDevtoolsHtml2 } = await loadFarmDevtoolsUIRuntime();
               res.end(renderFarmDevtoolsHtml2(snapshot));
             }
@@ -31980,7 +32125,7 @@ window.__FARM_MANIFEST__ = ${inlineValue({
                 return null;
               }
               return {
-                source: await fs13.promises.readFile(sourcePath, "utf8"),
+                source: await fs14.promises.readFile(sourcePath, "utf8"),
                 filePath: sourcePath
               };
             }, "resolveSource")
@@ -32864,7 +33009,10 @@ ${generatedDevIndicatorsClientRuntime}`,
           renderer,
           isolatedHydrationMode === "enabled",
           resolvedConfig?.trailingSlash ?? false,
-          resolvedConfig?.basePath ?? "/"
+          resolvedConfig?.basePath ?? "/",
+          generateClientCachePersistenceCode(
+            resolveFarmClientCacheAdapterEntry(root, resolvedConfig?.cache)
+          )
         );
       }
       if (id === "/@farm/server") {
@@ -33003,7 +33151,7 @@ export const manifest = getManifest();
         const root = currentConfig.root || server?.config.root || process.cwd();
         const cleanId = id.split("?", 1)[0];
         const selectedIsolatedModules = options.isolatedClientBoundaryModules ?? farmApp?.getRouteManager().getIsolatedClientBoundaryModules(root);
-        const selectedForIsolatedHydration = selectedIsolatedModules?.has(path37.resolve(cleanId)) === true;
+        const selectedForIsolatedHydration = selectedIsolatedModules?.has(path38.resolve(cleanId)) === true;
         if (isolatedHydrationEnabled && selectedForIsolatedHydration && isIsolatableClientBoundarySource(clientBoundarySource)) {
           isolatedModuleReference = toViteModuleId(cleanId, root);
           const transformedBoundary = transformIsolatedClientBoundaryModule({
@@ -33094,8 +33242,8 @@ if (import.meta.hot) {
         }
         logger.info(`Found ${ssgPages.length} SSG pages, ${ssrRoutes.length} SSR routes`);
         logger.info("Pre-rendering SSG pages...");
-        const outDir = path37.join(server?.config.root || process.cwd(), options.outDir || "dist");
-        const clientDir = path37.join(outDir, "client");
+        const outDir = path38.join(server?.config.root || process.cwd(), options.outDir || "dist");
+        const clientDir = path38.join(outDir, "client");
         for (const page2 of ssgPages) {
           try {
             const staticRequest = new Request(new URL(page2.urlPath, "http://farm.static"));
@@ -33147,9 +33295,9 @@ if (import.meta.hot) {
   <script type="module" src="/assets/client.js"></script>
 </body>
 </html>`;
-              const outputPath = page2.urlPath === "/" ? path37.join(clientDir, "index.html") : path37.join(clientDir, page2.urlPath + ".html");
-              fs13.mkdirSync(path37.dirname(outputPath), { recursive: true });
-              fs13.writeFileSync(outputPath, fullHtml);
+              const outputPath = page2.urlPath === "/" ? path38.join(clientDir, "index.html") : path38.join(clientDir, page2.urlPath + ".html");
+              fs14.mkdirSync(path38.dirname(outputPath), { recursive: true });
+              fs14.writeFileSync(outputPath, fullHtml);
               const revalidateInfo = page2.revalidate ? ` (revalidate: ${page2.revalidate}s)` : "";
               logger.success(`  \u2713 ${page2.urlPath}${revalidateInfo}`);
             });
@@ -33157,8 +33305,8 @@ if (import.meta.hot) {
             logger.error(`  \u2717 ${page2.urlPath}: ${error}`);
           }
         }
-        const manifestPath = path37.join(outDir, "__ssg_manifest.json");
-        fs13.writeFileSync(
+        const manifestPath = path38.join(outDir, "__ssg_manifest.json");
+        fs14.writeFileSync(
           manifestPath,
           JSON.stringify(
             ssgPages.map((p) => ({
@@ -33201,9 +33349,9 @@ if (import.meta.hot) {
         server2.ws.send({ type: "full-reload", path: "*" });
         return [];
       }
-      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path37.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
+      const currentSrcRoot = currentFarmConfig ? getFarmSourceRoots(currentFarmConfig).map((source) => path38.join(source.root, source.srcDir).replace(/\\/g, "/")).find((sourceRoot) => normalizedFile.startsWith(`${sourceRoot}/`)) || null : null;
       if (currentSrcRoot && normalizedFile.startsWith(`${currentSrcRoot}/`) && isProgrammaticRoutesFileName(normalizedFile)) {
-        logUpdate("PAGE", `updated ${path37.basename(file)}`);
+        logUpdate("PAGE", `updated ${path38.basename(file)}`);
         for (const mod of modules) {
           server2.moduleGraph.invalidateModule(mod);
         }
@@ -33619,7 +33767,7 @@ function parseRouteModuleSchema2(schema, value, label, routePath) {
     throw new Error(`Invalid ${label} for route "${routePath}": ${message}`);
   }
 }
-function generateClientCode(integrationProviders = [], documentNavigationMatchers = [], docsSearchClientRuntime = EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, devtoolsClientRuntime = "", plugins = [], root = process.cwd(), srcDir = "src", publicRuntimeConfig = void 0, docsAdapterReact, renderer = REACT_RENDERER, isolatedHydrationEnabled = false, trailingSlash = false, basePath = "/") {
+function generateClientCode(integrationProviders = [], documentNavigationMatchers = [], docsSearchClientRuntime = EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, devtoolsClientRuntime = "", plugins = [], root = process.cwd(), srcDir = "src", publicRuntimeConfig = void 0, docsAdapterReact, renderer = REACT_RENDERER, isolatedHydrationEnabled = false, trailingSlash = false, basePath = "/", clientCachePersistence = { imports: "", init: "" }) {
   const providerClientCode = generateFarmIntegrationProviderClientCode(integrationProviders, root);
   const clientPluginEntry = generateFarmClientPluginEntryCode(
     plugins,
@@ -33675,6 +33823,7 @@ import {
 } from '@farm.js/core/deployment'
 ${providerClientCode.imports}
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${docsSearchClientRuntime}
 ${devtoolsClientRuntime}
 ${docsAdapterImportBlock}
@@ -33690,6 +33839,7 @@ const integrationDocumentNavigationMatchers = ${JSON.stringify(documentNavigatio
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 
 let reactRoot = null;
 ${isolatedHydrationRuntime}
@@ -35070,7 +35220,7 @@ function generateClientManifest(bundle) {
 }
 async function defineConfig2(config = {}) {
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const appRoot = path37.resolve(config.root || process.cwd());
+  const appRoot = path38.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, {
@@ -35284,7 +35434,7 @@ async function defineConfig2(config = {}) {
     }
   };
 }
-var fs13, path37, import_node_url9, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
+var fs14, path38, import_node_url9, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifactSelection, FARM_I18N_CLIENT_BRIDGE_ID, warnedDeprecatedDevtoolsDashboard, EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME, FARM_CONFIG_FILENAMES;
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
@@ -35293,6 +35443,8 @@ var init_vite2 = __esm({
     init_default_styles();
     init_plugin();
     init_client_plugin_build();
+    init_client_cache_persistence_build();
+    init_client_cache_persistence_build();
     init_route_manager2();
     init_config3();
     init_server_path();
@@ -35308,8 +35460,8 @@ var init_vite2 = __esm({
     init_route_context();
     init_devtools_config();
     init_dev_indicators();
-    fs13 = __toESM(require("fs"));
-    path37 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path38 = __toESM(require("path"));
     import_node_url9 = require("url");
     init_layers();
     init_environment_vite();
@@ -35358,6 +35510,7 @@ var init_vite2 = __esm({
       i18n: false
     }), "createEmptyTypeArtifactSelection");
     FARM_I18N_CLIENT_BRIDGE_ID = "\0farm-i18n-client-bridge";
+    warnedDeprecatedDevtoolsDashboard = false;
     EMPTY_FARM_DOCS_SEARCH_CLIENT_RUNTIME = `
 function isFarmDocsSearchPage() {
   return false;
@@ -36094,7 +36247,7 @@ module.exports = __toCommonJS(build_runtime_exports);
 // src/build/index.ts
 init_config4();
 var import_path17 = __toESM(require("path"));
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 init_utils();
 init_app();
 init_route_manager2();
@@ -36109,15 +36262,15 @@ var import_path8 = __toESM(require("path"));
 var FARM_CLIENT_CSS_HREF_PLACEHOLDER = "/__farm_client_css_href__";
 var FARM_CLIENT_JS_SRC_PLACEHOLDER = "/__farm_client_js_src__";
 async function hashAndCopy(sourcePath, destinationDir, hashedName) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   try {
-    const bytes = await fs14.readFile(sourcePath);
+    const bytes = await fs15.readFile(sourcePath);
     if (bytes.length === 0) return null;
     const { createHash: createHash5 } = await import("crypto");
     const hash = createHash5("sha256").update(bytes).digest("hex").slice(0, 8);
     const name2 = hashedName(hash);
-    await fs14.mkdir(destinationDir, { recursive: true });
-    await fs14.writeFile(import_path8.default.join(destinationDir, name2), bytes);
+    await fs15.mkdir(destinationDir, { recursive: true });
+    await fs15.writeFile(import_path8.default.join(destinationDir, name2), bytes);
     return name2;
   } catch {
     return null;
@@ -36134,9 +36287,9 @@ async function resolveHashedClientCssHref(clientOutputDir) {
 }
 __name(resolveHashedClientCssHref, "resolveHashedClientCssHref");
 async function findFingerprintedClientEntry(clientOutputDir) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   try {
-    const entries = await fs14.readdir(clientOutputDir);
+    const entries = await fs15.readdir(clientOutputDir);
     return entries.find((name2) => /^farm-client-h[0-9a-f]+\.js$/.test(name2)) ?? null;
   } catch {
     return null;
@@ -36146,10 +36299,10 @@ __name(findFingerprintedClientEntry, "findFingerprintedClientEntry");
 async function resolveHashedClientJsSrc(clientOutputDir) {
   const entryName = await findFingerprintedClientEntry(clientOutputDir);
   if (!entryName) return "/farm-client.js";
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const shim = `export * from "./${entryName}";
 `;
-  await fs14.writeFile(import_path8.default.join(clientOutputDir, "farm-client.js"), shim);
+  await fs15.writeFile(import_path8.default.join(clientOutputDir, "farm-client.js"), shim);
   return `/${entryName}`;
 }
 __name(resolveHashedClientJsSrc, "resolveHashedClientJsSrc");
@@ -36157,6 +36310,7 @@ __name(resolveHashedClientJsSrc, "resolveHashedClientJsSrc");
 // src/nitro/universal-build.ts
 init_server_path();
 init_client_plugin_build();
+init_client_cache_persistence_build();
 var import_os = __toESM(require("os"));
 var import_path14 = __toESM(require("path"));
 var import_fs5 = require("fs");
@@ -36253,10 +36407,10 @@ async function createFarmRouteRuntimeManifest(options) {
 }
 __name(createFarmRouteRuntimeManifest, "createFarmRouteRuntimeManifest");
 async function writeFarmRouteRuntimeManifest(directory, manifest) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const manifestPath = import_path9.default.join(directory, FARM_ROUTE_RUNTIME_MANIFEST);
-  await fs14.mkdir(directory, { recursive: true });
-  await fs14.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await fs15.mkdir(directory, { recursive: true });
+  await fs15.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return manifestPath;
 }
@@ -36302,7 +36456,7 @@ __name(normalizeManifestSource, "normalizeManifestSource");
 // src/nitro/vercel-route-runtime.ts
 var import_path10 = __toESM(require("path"));
 init_route_runtime();
-async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs14) {
+async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs15) {
   const dynamicRoutes = manifest.routes.filter(
     (route) => route.rendering === "dynamic" && route.runtime !== "edge"
   );
@@ -36333,8 +36487,8 @@ async function createFarmVercelRouteRuntimeFunctions(outputDir, manifest, fs14)
     groupIndex += 1;
     const functionName = `__farm_runtime_${groupIndex}`;
     const functionDir = import_path10.default.join(functionsDir, `${functionName}.func`);
-    await fs14.cp(baseFunctionDir, functionDir, { recursive: true, force: true });
-    await configureVercelFunction(functionDir, group.config, fs14);
+    await fs15.cp(baseFunctionDir, functionDir, { recursive: true, force: true });
+    await configureVercelFunction(functionDir, group.config, fs15);
     destinations.set(key, `/${functionName}`);
   }
   const routes = [];
@@ -36381,15 +36535,15 @@ function farmRoutePatternToVercelSource(pattern) {
   return source || "/";
 }
 __name(farmRoutePatternToVercelSource, "farmRoutePatternToVercelSource");
-async function configureVercelFunction(functionDir, config, fs14) {
+async function configureVercelFunction(functionDir, config, fs15) {
   const configPath = import_path10.default.join(functionDir, ".vc-config.json");
-  const current = JSON.parse(await fs14.readFile(configPath, "utf8"));
+  const current = JSON.parse(await fs15.readFile(configPath, "utf8"));
   const next = {
     ...current,
     ...config.regions?.length ? { regions: config.regions } : {},
     ...config.maxDuration ? { maxDuration: config.maxDuration } : {}
   };
-  await fs14.writeFile(configPath, `${JSON.stringify(next, null, 2)}
+  await fs15.writeFile(configPath, `${JSON.stringify(next, null, 2)}
 `);
 }
 __name(configureVercelFunction, "configureVercelFunction");
@@ -36439,6 +36593,34 @@ function createFarmVercelImmutableAssetRoute() {
   };
 }
 __name(createFarmVercelImmutableAssetRoute, "createFarmVercelImmutableAssetRoute");
+function buildFarmVercelRoutes(options) {
+  const { presetRoutes, runtimeRoutes, apiBasePath } = options;
+  const filesystemIndex = presetRoutes.findIndex((route) => route.handle === "filesystem");
+  const sourceRoutes = filesystemIndex >= 0 ? presetRoutes.slice(0, filesystemIndex) : [];
+  const preservedSourceRoutes = sourceRoutes.filter((route) => route.continue !== true);
+  return [
+    ...preservedSourceRoutes,
+    createFarmVercelImmutableAssetRoute(),
+    { handle: "filesystem" },
+    ...runtimeRoutes,
+    ...apiBasePath === "/" ? [] : [
+      {
+        src: `${apiBasePath}/(.*)`,
+        dest: "/__nitro",
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "*",
+          "Access-Control-Allow-Headers": "*"
+        }
+      }
+    ],
+    {
+      src: "/(.*)",
+      dest: "/__nitro"
+    }
+  ];
+}
+__name(buildFarmVercelRoutes, "buildFarmVercelRoutes");
 
 // src/nitro/node-server-entry.ts
 function createFarmNodeServerEntry(options) {
@@ -36732,23 +36914,23 @@ init_vite();
 
 // src/instrumentation.ts
 var import_esbuild = require("esbuild");
-var import_node_fs8 = __toESM(require("fs"));
-var import_node_path16 = __toESM(require("path"));
+var import_node_fs9 = __toESM(require("fs"));
+var import_node_path17 = __toESM(require("path"));
 var import_node_url8 = require("url");
 var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
 function resolveFarmInstrumentationFile(root, srcDir = "src") {
   const candidates = [
     ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => import_node_path16.default.join(root, srcDir, `instrumentation.${extension}`)
+      (extension) => import_node_path17.default.join(root, srcDir, `instrumentation.${extension}`)
     ),
     ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => import_node_path16.default.join(root, `instrumentation.${extension}`)
+      (extension) => import_node_path17.default.join(root, `instrumentation.${extension}`)
     )
-  ].filter((candidate) => import_node_fs8.default.existsSync(candidate));
+  ].filter((candidate) => import_node_fs9.default.existsSync(candidate));
   if (candidates.length > 1) {
     throw new Error(
       `Farm.js found multiple instrumentation files:
-${candidates.map((candidate) => `- ${import_node_path16.default.relative(root, candidate)}`).join("\n")}
+${candidates.map((candidate) => `- ${import_node_path17.default.relative(root, candidate)}`).join("\n")}
 Keep only one instrumentation file in the project root or ${srcDir}/.`
     );
   }
@@ -37103,7 +37285,7 @@ function hasProjectPostcssConfig(root) {
 }
 __name(hasProjectPostcssConfig, "hasProjectPostcssConfig");
 async function findFarmConfigPath(root) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const candidates = [
     "farm.config.ts",
     "farm.config.mts",
@@ -37117,7 +37299,7 @@ async function findFarmConfigPath(root) {
   for (const candidate of candidates) {
     const resolvedPath = import_path14.default.join(root, candidate);
     try {
-      await fs14.access(resolvedPath);
+      await fs15.access(resolvedPath);
       return resolvedPath;
     } catch {
     }
@@ -37144,13 +37326,13 @@ function hasFarmServerRuntimePlugins(config) {
 }
 __name(hasFarmServerRuntimePlugins, "hasFarmServerRuntimePlugins");
 async function discoverMiddlewareRoutes(appDir) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
   const routes = /* @__PURE__ */ new Map();
   async function walk(dir, routePath, discovered) {
     let entries;
     try {
-      entries = await fs14.readdir(dir, { withFileTypes: true });
+      entries = await fs15.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -37231,12 +37413,12 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
       })
     );
     logger.info(`\u{1F4CB} Found ${pageRoutes.length} page routes`);
-    const fs14 = await import("fs/promises");
+    const fs15 = await import("fs/promises");
     const layoutRoutes = [];
     const appDir = import_path14.default.join(root, srcDir, "app");
     async function findLayoutsForClient(dir, routePrefix = "/") {
       try {
-        const entries = await fs14.readdir(dir, { withFileTypes: true });
+        const entries = await fs15.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && entry.name.match(/^layout\.(tsx?|jsx?|vue|svelte)$/)) {
             layoutRoutes.push({
@@ -37384,7 +37566,7 @@ async function buildUniversal(config, routeManager, apiRouteManager, serverRende
 }
 __name(buildUniversal, "buildUniversal");
 async function writeSSRAssetsToClient(bundle, outputDir) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   for (const [fileName, output] of Object.entries(bundle)) {
     if (output.type !== "asset") continue;
     if (fileName === "farm-fonts.css") {
@@ -37392,29 +37574,29 @@ async function writeSSRAssetsToClient(bundle, outputDir) {
       continue;
     }
     const filePath = import_path14.default.join(outputDir, fileName);
-    await fs14.mkdir(import_path14.default.dirname(filePath), { recursive: true });
-    await fs14.writeFile(filePath, output.source);
+    await fs15.mkdir(import_path14.default.dirname(filePath), { recursive: true });
+    await fs15.writeFile(filePath, output.source);
   }
 }
 __name(writeSSRAssetsToClient, "writeSSRAssetsToClient");
 async function copyFarmDocsFontAssetsToClient(root, outputDir) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   await Promise.all(
     resolveFarmDocsFontAssets(root).map(async ({ sourcePath, url }) => {
       const targetPath = import_path14.default.join(outputDir, url.replace(/^\/+/, ""));
-      await fs14.mkdir(import_path14.default.dirname(targetPath), { recursive: true });
-      await fs14.copyFile(sourcePath, targetPath);
+      await fs15.mkdir(import_path14.default.dirname(targetPath), { recursive: true });
+      await fs15.copyFile(sourcePath, targetPath);
     })
   );
 }
 __name(copyFarmDocsFontAssetsToClient, "copyFarmDocsFontAssetsToClient");
 async function mergeBuiltFontCss(outputDir, fontCssSource) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const fontCssPath = import_path14.default.join(outputDir, "farm-fonts.css");
   let fontCss = fontCssSource;
   if (fontCss === void 0) {
     try {
-      fontCss = await fs14.readFile(fontCssPath);
+      fontCss = await fs15.readFile(fontCssPath);
     } catch {
       return;
     }
@@ -37422,12 +37604,12 @@ async function mergeBuiltFontCss(outputDir, fontCssSource) {
   const clientCssPath = import_path14.default.join(outputDir, "farm-client.css");
   let clientCss = "";
   try {
-    clientCss = await fs14.readFile(clientCssPath, "utf8");
+    clientCss = await fs15.readFile(clientCssPath, "utf8");
   } catch {
   }
   const normalizedFontCss = typeof fontCss === "string" ? fontCss : Buffer.from(fontCss).toString("utf8");
-  await fs14.writeFile(fontCssPath, normalizedFontCss);
-  await fs14.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
+  await fs15.writeFile(fontCssPath, normalizedFontCss);
+  await fs15.writeFile(clientCssPath, mergeFarmFontCss(clientCss, normalizedFontCss));
 }
 __name(mergeBuiltFontCss, "mergeBuiltFontCss");
 var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError extends Error {
@@ -37439,12 +37621,12 @@ var _IncompleteClientBuildOutputError = class _IncompleteClientBuildOutputError
 __name(_IncompleteClientBuildOutputError, "IncompleteClientBuildOutputError");
 var IncompleteClientBuildOutputError = _IncompleteClientBuildOutputError;
 async function validateClientBuildOutput(root, srcDir, outputDir) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const fingerprinted = await findFingerprintedClientEntry(outputDir);
   const clientEntryPath = import_path14.default.join(outputDir, fingerprinted ?? "farm-client.js");
   let clientEntrySize = 0;
   try {
-    const clientEntry = await fs14.stat(clientEntryPath);
+    const clientEntry = await fs15.stat(clientEntryPath);
     if (clientEntry.isFile()) clientEntrySize = clientEntry.size;
   } catch {
   }
@@ -37455,12 +37637,12 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
   const globalsCssPath = import_path14.default.join(root, srcDir, "app", "globals.css");
   let expectsCss = false;
   try {
-    const globalsCss = await fs14.readFile(globalsCssPath, "utf8");
+    const globalsCss = await fs15.readFile(globalsCssPath, "utf8");
     expectsCss = globalsCss.replace(/\/\*[\s\S]*?\*\//g, "").trim().length > 0;
   } catch {
   }
   try {
-    const clientCss = await fs14.stat(clientCssPath);
+    const clientCss = await fs15.stat(clientCssPath);
     if (expectsCss && (!clientCss.isFile() || clientCss.size === 0)) {
       throw new IncompleteClientBuildOutputError("farm-client.css is empty");
     }
@@ -37469,7 +37651,7 @@ async function validateClientBuildOutput(root, srcDir, outputDir) {
     if (expectsCss) {
       throw new IncompleteClientBuildOutputError("farm-client.css is missing");
     }
-    await fs14.writeFile(clientCssPath, "");
+    await fs15.writeFile(clientCssPath, "");
   }
 }
 __name(validateClientBuildOutput, "validateClientBuildOutput");
@@ -37487,7 +37669,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
   const viteBuild = productionVite.build;
   const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const pluginManager = new PluginManager2({
     config,
     isDev: false,
@@ -37679,8 +37861,8 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     `\u{1F4F1} Total hydratable routes detected: ${clientPages.length} pages, ${clientLayouts.filter((layout2) => layout2.shouldHydrate).length} layouts, and ${clientRouteSlots.length} slots`
   );
   const clientEntryRoot = import_path14.default.join(root, ".farm", "tmp");
-  await fs14.mkdir(clientEntryRoot, { recursive: true });
-  const clientEntryDir = await fs14.mkdtemp(import_path14.default.join(clientEntryRoot, "client-entry-"));
+  await fs15.mkdir(clientEntryRoot, { recursive: true });
+  const clientEntryDir = await fs15.mkdtemp(import_path14.default.join(clientEntryRoot, "client-entry-"));
   const clientEntryPath = import_path14.default.join(clientEntryDir, "farm-client-entry.tsx");
   const clientHydrationCode = generateClientHydrationEntry(
     clientPages,
@@ -37698,9 +37880,10 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     config.publicRuntimeConfig,
     config.trailingSlash,
     getIntegrationProviders(config.integrations),
-    config.basePath
+    config.basePath,
+    generateClientCachePersistenceCode(resolveFarmClientCacheAdapterEntry(root, config.cache))
   );
-  await fs14.writeFile(clientEntryPath, clientHydrationCode);
+  await fs15.writeFile(clientEntryPath, clientHydrationCode);
   const hasScopedPostcssConfig = hasProjectPostcssConfig(root);
   let postcssSearchPath;
   let tailwindVitePlugin = void 0;
@@ -37711,7 +37894,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     logger.info("\u{1F4E6} Using project PostCSS/Tailwind configuration");
   } else {
     const postcssConfigPath = import_path14.default.join(clientEntryDir, "postcss.config.cjs");
-    await fs14.writeFile(postcssConfigPath, "module.exports = { plugins: [] };\n");
+    await fs15.writeFile(postcssConfigPath, "module.exports = { plugins: [] };\n");
     postcssSearchPath = clientEntryDir;
     try {
       const tailwindVite = (await import("@tailwindcss/vite")).default;
@@ -37862,7 +38045,7 @@ async function buildClient(productionVite, config, root, srcDir, outputDir, page
     await validateClientBuildOutput(root, srcDir, outputDir);
   } finally {
     try {
-      await fs14.rm(clientEntryDir, { recursive: true, force: true });
+      await fs15.rm(clientEntryDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -38009,6 +38192,46 @@ function matchRuntimePathPattern(pattern, pathname) {
 `.trim();
 }
 __name(generateRuntimePathMatcherSource, "generateRuntimePathMatcherSource");
+function generateRedirectInterpolationSource() {
+  return `
+function encodeRuntimePathSegment(value) {
+  return encodeURIComponent(String(value)).replace(
+    /[!'()*]/g,
+    function(character) {
+      return "%" + character.charCodeAt(0).toString(16).toUpperCase();
+    },
+  );
+}
+
+function interpolateRedirectDestination(destination, params) {
+  let result = destination;
+  const catchAllParamSegments = params[farmCatchAllParamSegments] || {};
+  const orderedCaptures = [];
+  for (const [key, value] of Object.entries(params)) {
+    const segments = catchAllParamSegments[key];
+    const encodedValue = Array.isArray(segments)
+      ? segments.map(encodeRuntimePathSegment).join("/")
+      : encodeRuntimePathSegment(value);
+    orderedCaptures.push(encodedValue);
+    result = result.split("[[..." + key + "]]").join(encodedValue);
+    result = result.split("[..." + key + "]").join(encodedValue);
+    result = result.split("[" + key + "]").join(encodedValue);
+    result = result.split(":" + key + "*").join(encodedValue);
+    result = result.split(":" + key).join(encodedValue);
+    if (key === "wildcard") result = result.split("*").join(encodedValue);
+  }
+  // Numbered captures resolve after the named substitutions. Encoded values
+  // never contain "$", so this cannot rewrite an already-injected value. An
+  // out-of-range index resolves to "", matching the development path.
+  result = result.replace(/\\$(\\d+)/g, function(_whole, group) {
+    const captured = orderedCaptures[Number(group) - 1];
+    return captured === undefined ? "" : captured;
+  });
+  return result;
+}
+`.trim();
+}
+__name(generateRedirectInterpolationSource, "generateRedirectInterpolationSource");
 function generateUniversalRouterStateProperties() {
   return `
   blockers: new Set(),
@@ -38300,7 +38523,7 @@ function generateClientHydrationEntry(clientPages, layoutRoutes, clientRouteSlot
     secure: false
   },
   direction: {}
-}, plugins = [], renderer = REACT_RENDERER, publicRuntimeConfig = void 0, trailingSlash = false, integrationProviders = [], basePath = "/") {
+}, plugins = [], renderer = REACT_RENDERER, publicRuntimeConfig = void 0, trailingSlash = false, integrationProviders = [], basePath = "/", clientCachePersistence = { imports: "", init: "" }) {
   const toImportPath = /* @__PURE__ */ __name((targetPath) => targetPath.replace(/\\/g, "/"), "toImportPath");
   const clientPluginEntry = generateFarmClientPluginEntryCode(
     plugins,
@@ -38312,8 +38535,7 @@ function generateClientHydrationEntry(clientPages, layoutRoutes, clientRouteSlot
 import { createRoot, hydrateRoot } from "react-dom/client";` : `import React, { createRoot, hydrateRoot } from ${JSON.stringify(renderer.client)};`;
   const providerClientCode = generateFarmIntegrationProviderClientCode(integrationProviders, root);
   const globalsCssPath = import_path14.default.join(root, srcDir, "app", "globals.css");
-  const cssImportPath = toImportPath(globalsCssPath);
-  const cssImport = `import ${JSON.stringify(cssImportPath)};`;
+  const cssImport = (0, import_fs5.existsSync)(globalsCssPath) ? `import ${JSON.stringify(toImportPath(globalsCssPath))};` : "";
   const layoutImportStatements = [];
   const layoutRegistrations = [];
   layoutRoutes.forEach((layout2, index) => {
@@ -38398,6 +38620,7 @@ ${layoutImports}
 import { createClientPluginManager, getHashTargetElement, installChunkErrorRecovery, isFarmExternalNavigationURL, reconcileFarmDocumentHead, setFarmBasePath, setFarmTrailingSlashPreference, stripFarmBasePath } from "@farm.js/core/internal/client-runtime";
 import { createFarmDeploymentMismatchError, createFarmDeploymentRequestHeaders, isFarmDeploymentMismatchResponse } from "@farm.js/core/deployment";
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${i18nClientRuntime}
 ${docsNavigationRuntime}
 ${docsAdapterRuntime}
@@ -38406,6 +38629,7 @@ ${generateFarmDocsSearchClientRuntime(docsSearchEnabled, docsSearchModuleId)}
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 mountFarmDocsSearch();
 
 ${generateUniversalRouterStateRuntime()}
@@ -38760,6 +38984,7 @@ import { createClientPluginManager, getHashTargetElement, installChunkErrorRecov
 import { createFarmDeploymentMismatchError, createFarmDeploymentRequestHeaders, isFarmDeploymentMismatchResponse } from "@farm.js/core/deployment";
 import { isFarmRouteActive, matchFarmRoute } from "@farm.js/core/router";
 ${clientPluginEntry.imports}
+${clientCachePersistence.imports}
 ${i18nClientRuntime}
 ${docsNavigationRuntime}
 ${docsAdapterRuntime}
@@ -38772,6 +38997,7 @@ ${providerClientCode.runtime}
 setFarmBasePath(${JSON.stringify(basePath)});
 setFarmTrailingSlashPreference(${JSON.stringify(trailingSlash)});
 installChunkErrorRecovery();
+${clientCachePersistence.init}
 
 // Client component routes
 const clientRoutes = [
@@ -39714,7 +39940,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   const viteBuild = productionVite.build;
   const { farmPlugin: farmPlugin2 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
   const { PluginManager: PluginManager2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const pluginManager = new PluginManager2({
     config,
     isDev: false,
@@ -39728,8 +39954,8 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
     ssr: true
   });
   if (!hasScopedPostcssConfig) {
-    postcssConfigDir = await fs14.mkdtemp(import_path14.default.join(import_os.default.tmpdir(), "farm-postcss-"));
-    await fs14.writeFile(
+    postcssConfigDir = await fs15.mkdtemp(import_path14.default.join(import_os.default.tmpdir(), "farm-postcss-"));
+    await fs15.writeFile(
       import_path14.default.join(postcssConfigDir, "postcss.config.cjs"),
       "module.exports = { plugins: [] };\n"
     );
@@ -39759,7 +39985,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         fileName: entry.fileName,
         sourceType: "static",
         staticInfo: entry.staticInfo,
-        data: (await fs14.readFile(entry.modulePath)).toString("base64")
+        data: (await fs15.readFile(entry.modulePath)).toString("base64")
       });
       continue;
     }
@@ -40055,7 +40281,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
   } finally {
     if (postcssConfigDir) {
       try {
-        await fs14.rm(postcssConfigDir, { recursive: true, force: true });
+        await fs15.rm(postcssConfigDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -40787,7 +41013,7 @@ const farmDocsAPIHandler = ${config.docs?.enabled ? adapterOwnsDocsRuntime ? "nu
 
 // API routes bundled at build time
 const apiRoutes = ${apiRoutes.length > 0 ? "mergePluginAPIRoutes(" : ""}[${apiRegistrations.join(",")}
-]${apiRoutes.length > 0 ? `, configuredPlugins, ${JSON.stringify(apiRoutes.map(({ path: path41, methods }) => ({ path: path41, methods })))})` : ""};
+]${apiRoutes.length > 0 ? `, configuredPlugins, ${JSON.stringify(apiRoutes.map(({ path: path42, methods }) => ({ path: path42, methods })))})` : ""};
 const farmLocalAPIBasePath = ${JSON.stringify(resolveFarmAPIServerBasePath(config.api))};
 const farmOpenAPIReference = ${JSON.stringify(openAPIReference)};
 
@@ -41516,32 +41742,7 @@ async function handleApplicationMetadataRouteRequest(request, routePathname) {
   }
 }
 
-function encodeRuntimePathSegment(value) {
-  return encodeURIComponent(String(value)).replace(
-    /[!'()*]/g,
-    function(character) {
-      return "%" + character.charCodeAt(0).toString(16).toUpperCase();
-    },
-  );
-}
-
-function interpolateRedirectDestination(destination, params) {
-  let result = destination;
-  const catchAllParamSegments = params[farmCatchAllParamSegments] || {};
-  for (const [key, value] of Object.entries(params)) {
-    const segments = catchAllParamSegments[key];
-    const encodedValue = Array.isArray(segments)
-      ? segments.map(encodeRuntimePathSegment).join("/")
-      : encodeRuntimePathSegment(value);
-    result = result.split("[[..." + key + "]]").join(encodedValue);
-    result = result.split("[..." + key + "]").join(encodedValue);
-    result = result.split("[" + key + "]").join(encodedValue);
-    result = result.split(":" + key + "*").join(encodedValue);
-    result = result.split(":" + key).join(encodedValue);
-    if (key === "wildcard") result = result.split("*").join(encodedValue);
-  }
-  return result;
-}
+${generateRedirectInterpolationSource()}
 
 function matchRedirectRoute(pathname, locale, search) {
   for (const redirect of redirectRoutes) {
@@ -41964,9 +42165,10 @@ ${config.docs?.enabled ? `async function wrapFarmDocsResponseWithLayouts(request
 }` : ""}
 
 const pprShellCache = getFarmDataCache();
+const experimentalPPREnabled = ${JSON.stringify(config.experimental?.ppr === true)};
 
 function resolvePPRConfig(routeModule) {
-  if (!routeModule || routeModule.dynamic === "force-dynamic") {
+  if (!experimentalPPREnabled || !routeModule || routeModule.dynamic === "force-dynamic") {
     return { enabled: false };
   }
 
@@ -43504,7 +43706,7 @@ function getPhysicalPrerenderBypassReason(options) {
 }
 __name(getPhysicalPrerenderBypassReason, "getPhysicalPrerenderBypassReason");
 async function buildNitroUniversal(config, routeManager, apiRouteManager, serverRenderer, preset, root, distDir, ssrBundle, ssrEntryFile, clientOutputDir, routeRuntimeManifest, configuredHeaderRoutes, nitroRuntimeResultPromise, pluginManager) {
-  const [fs14, nitroRuntimeResult] = await Promise.all([
+  const [fs15, nitroRuntimeResult] = await Promise.all([
     import("fs/promises"),
     nitroRuntimeResultPromise
   ]);
@@ -43595,11 +43797,11 @@ async function buildNitroUniversal(config, routeManager, apiRouteManager, server
       output.code = output.code.split(FARM_CLIENT_JS_SRC_PLACEHOLDER).join(clientJsSrc);
     }
   }
-  await fs14.mkdir(ssrOutputDir, { recursive: true });
+  await fs15.mkdir(ssrOutputDir, { recursive: true });
   for (const [fileName, output] of Object.entries(ssrBundle)) {
     const filePath = import_path14.default.join(ssrOutputDir, fileName);
-    await fs14.mkdir(import_path14.default.dirname(filePath), { recursive: true });
-    await fs14.writeFile(filePath, output.type === "chunk" ? output.code : output.source);
+    await fs15.mkdir(import_path14.default.dirname(filePath), { recursive: true });
+    await fs15.writeFile(filePath, output.type === "chunk" ? output.code : output.source);
   }
   const nitroEntryPath = import_path14.default.join(ssrOutputDir, "nitro-entry.mjs");
   const nitroEntryCode = `
@@ -43671,10 +43873,10 @@ export default async function farmNitroEventHandler(event) {
   return response
 }
   `.trim();
-  await fs14.writeFile(nitroEntryPath, nitroEntryCode);
+  await fs15.writeFile(nitroEntryPath, nitroEntryCode);
   const farmNodeServerEntryPath = preset === "node-server" ? import_path14.default.join(ssrOutputDir, "farm-node-server-entry.mjs") : null;
   if (farmNodeServerEntryPath) {
-    await fs14.writeFile(
+    await fs15.writeFile(
       farmNodeServerEntryPath,
       createFarmNodeServerEntry({
         nitroEntryFile: import_path14.default.basename(nitroEntryPath),
@@ -43892,9 +44094,9 @@ export default async function farmNitroEventHandler(event) {
           import_path14.default.join(prerenderServerDir, FARM_SSR_OUTPUT_DIR),
           {},
           false,
-          fs14
+          fs15
         );
-        await registerPrebuiltSSRPackageImport(prerenderServerDir, ssrEntryFile, fs14);
+        await registerPrebuiltSSRPackageImport(prerenderServerDir, ssrEntryFile, fs15);
       });
     });
   }
@@ -43926,17 +44128,17 @@ export default async function farmNitroEventHandler(event) {
       import_path14.default.join(outputDir, "server", FARM_SSR_OUTPUT_DIR),
       prebuiltSSREsbuildOptions,
       effectiveMinify,
-      fs14
+      fs15
     ) : Promise.resolve(),
-    imageRuntime === "node" ? copySharpRuntime(config, root, import_path14.default.join(outputDir, "server"), fs14) : Promise.resolve(),
-    useExternalMetadataImageRuntime ? copyMetadataImageRuntime(root, import_path14.default.join(outputDir, "server"), fs14) : Promise.resolve()
+    imageRuntime === "node" ? copySharpRuntime(config, root, import_path14.default.join(outputDir, "server"), fs15) : Promise.resolve(),
+    useExternalMetadataImageRuntime ? copyMetadataImageRuntime(root, import_path14.default.join(outputDir, "server"), fs15) : Promise.resolve()
   ]);
   const failedCopy = copyResults.find(
     (result) => result.status === "rejected"
   );
   if (failedCopy) throw failedCopy.reason;
   if (canReusePrebuiltSSR) {
-    await registerPrebuiltSSRPackageImport(import_path14.default.join(outputDir, "server"), ssrEntryFile, fs14);
+    await registerPrebuiltSSRPackageImport(import_path14.default.join(outputDir, "server"), ssrEntryFile, fs15);
     logger.info("\u26A1 Reused Farm's prebuilt SSR bundle for the Node output");
   }
   if (useRolldownBuilder) {
@@ -43951,12 +44153,12 @@ export default async function farmNitroEventHandler(event) {
     });
   }
   if (isVercel) {
-    await postProcessVercelOutput(root, outputDir, fs14, config, farmWorkflows, routeRuntimeManifest);
+    await postProcessVercelOutput(root, outputDir, fs15, config, farmWorkflows, routeRuntimeManifest);
   }
   logger.success(`\u2705 Nitro build completed with preset: ${preset}`);
 }
 __name(buildNitroUniversal, "buildNitroUniversal");
-async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOptions, minify, fs14) {
+async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOptions, minify, fs15) {
   const {
     include: _include,
     exclude: _exclude,
@@ -43973,13 +44175,13 @@ async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOpti
     "node18"
   );
   const transform = minify || hasConfiguredTransforms ? (await import("esbuild")).transform : null;
-  await fs14.rm(targetDir, { recursive: true, force: true });
+  await fs15.rm(targetDir, { recursive: true, force: true });
   await Promise.all(
     Object.entries(ssrBundle).map(async ([fileName, output]) => {
       const targetPath = import_path14.default.join(targetDir, fileName);
-      await fs14.mkdir(import_path14.default.dirname(targetPath), { recursive: true });
+      await fs15.mkdir(import_path14.default.dirname(targetPath), { recursive: true });
       if (output.type === "asset") {
-        await fs14.writeFile(targetPath, output.source);
+        await fs15.writeFile(targetPath, output.source);
         return;
       }
       let code = output.code;
@@ -43990,14 +44192,14 @@ async function copyPrebuiltSSRBundle(ssrBundle, targetDir, configuredEsbuildOpti
         });
         code = result.code;
       }
-      await fs14.writeFile(targetPath, code);
+      await fs15.writeFile(targetPath, code);
     })
   );
 }
 __name(copyPrebuiltSSRBundle, "copyPrebuiltSSRBundle");
-async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs14) {
+async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs15) {
   const packagePath = import_path14.default.join(serverDir, "package.json");
-  const packageJSON = await fs14.readFile(packagePath, "utf8").then((contents) => JSON.parse(contents)).catch((error) => {
+  const packageJSON = await fs15.readFile(packagePath, "utf8").then((contents) => JSON.parse(contents)).catch((error) => {
     if (error.code === "ENOENT") return { type: "module" };
     throw error;
   });
@@ -44007,14 +44209,14 @@ async function registerPrebuiltSSRPackageImport(serverDir, ssrEntryFile, fs14) {
     ...existingImports,
     [FARM_SSR_PACKAGE_IMPORT]: `./${outputEntry}`
   };
-  await fs14.mkdir(serverDir, { recursive: true });
-  await fs14.writeFile(packagePath, `${JSON.stringify(packageJSON, null, 2)}
+  await fs15.mkdir(serverDir, { recursive: true });
+  await fs15.writeFile(packagePath, `${JSON.stringify(packageJSON, null, 2)}
 `);
 }
 __name(registerPrebuiltSSRPackageImport, "registerPrebuiltSSRPackageImport");
-async function moveVercelOutputPath(src, dest, fs14) {
+async function moveVercelOutputPath(src, dest, fs15) {
   try {
-    await fs14.rename(src, dest);
+    await fs15.rename(src, dest);
     return;
   } catch (error) {
     const code = error?.code;
@@ -44022,68 +44224,44 @@ async function moveVercelOutputPath(src, dest, fs14) {
       throw error;
     }
   }
-  await fs14.cp(src, dest, { recursive: true, force: true });
-  await fs14.rm(src, { recursive: true, force: true });
+  await fs15.cp(src, dest, { recursive: true, force: true });
+  await fs15.rm(src, { recursive: true, force: true });
 }
 __name(moveVercelOutputPath, "moveVercelOutputPath");
-async function postProcessVercelOutput(root, outputDir, fs14, config, farmWorkflows, routeRuntimeManifest) {
+async function postProcessVercelOutput(root, outputDir, fs15, config, farmWorkflows, routeRuntimeManifest) {
   const serverDir = import_path14.default.join(outputDir, "server");
   const functionsDir = import_path14.default.join(outputDir, "functions");
   const nitroFuncDir = import_path14.default.join(functionsDir, "__nitro.func");
   const staticDir = import_path14.default.join(outputDir, "static");
   const publicDir = import_path14.default.join(outputDir, "public");
-  await fs14.mkdir(nitroFuncDir, { recursive: true });
-  const serverContents = await fs14.readdir(serverDir);
+  await fs15.mkdir(nitroFuncDir, { recursive: true });
+  const serverContents = await fs15.readdir(serverDir);
   for (const file of serverContents) {
     const src = import_path14.default.join(serverDir, file);
     const dest = import_path14.default.join(nitroFuncDir, file);
-    await moveVercelOutputPath(src, dest, fs14);
+    await moveVercelOutputPath(src, dest, fs15);
   }
-  await fs14.rm(serverDir, { recursive: true, force: true });
+  await fs15.rm(serverDir, { recursive: true, force: true });
   try {
-    await moveVercelOutputPath(publicDir, staticDir, fs14);
+    await moveVercelOutputPath(publicDir, staticDir, fs15);
   } catch (error) {
     if (error?.code !== "ENOENT") throw error;
   }
-  await copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs14);
-  await copyPrismaClientForVercel(root, nitroFuncDir, fs14);
+  await copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs15);
+  await copyPrismaClientForVercel(root, nitroFuncDir, fs15);
   const configPath = import_path14.default.join(outputDir, "config.json");
-  const configContent = await fs14.readFile(configPath, "utf-8");
+  const configContent = await fs15.readFile(configPath, "utf-8");
   const vercelConfig = JSON.parse(configContent);
   const runtimeRoutes = await createFarmVercelRouteRuntimeFunctions(
     outputDir,
     routeRuntimeManifest,
-    fs14
+    fs15
   );
-  vercelConfig.routes = [
-    // Apply the header before the filesystem handler. `continue` lets Vercel
-    // serve the matching file while preserving the immutable cache policy.
-    // Hashed client assets ship at the root regardless of basePath, so the
-    // route is deliberately not basePath-scoped.
-    createFarmVercelImmutableAssetRoute(),
-    // Serve static files first
-    {
-      handle: "filesystem"
-    },
-    ...runtimeRoutes,
-    // API routes
-    ...resolveFarmAPIServerBasePath(config.api) === "/" ? [] : [
-      {
-        src: `${resolveFarmAPIServerBasePath(config.api)}/(.*)`,
-        dest: "/__nitro",
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "*",
-          "Access-Control-Allow-Headers": "*"
-        }
-      }
-    ],
-    // All other routes go to the serverless function
-    {
-      src: "/(.*)",
-      dest: "/__nitro"
-    }
-  ];
+  vercelConfig.routes = buildFarmVercelRoutes({
+    presetRoutes: Array.isArray(vercelConfig.routes) ? vercelConfig.routes : [],
+    runtimeRoutes,
+    apiBasePath: resolveFarmAPIServerBasePath(config.api)
+  });
   const vercelConfigWithWorkflowCrons = applyFarmWorkflowVercelCrons(
     vercelConfig,
     farmWorkflows.workflows
@@ -44092,24 +44270,24 @@ async function postProcessVercelOutput(root, outputDir, fs14, config, farmWorkfl
     vercelConfigWithWorkflowCrons,
     config.cron.jobs
   );
-  await fs14.writeFile(configPath, JSON.stringify(vercelConfigWithCrons, null, 2));
+  await fs15.writeFile(configPath, JSON.stringify(vercelConfigWithCrons, null, 2));
   logger.info("\u2705 Post-processed Vercel output for Build Output API v3");
 }
 __name(postProcessVercelOutput, "postProcessVercelOutput");
-async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs14) {
+async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs15) {
   const docsContentDir = resolveBuildDocsContentDir(config, root);
   if (!docsContentDir) return;
   const bundledContentDir = import_path14.default.join(nitroFuncDir, "chunks", "nitro", "farm-docs-content");
   const lastModifiedManifest = createFarmDocsLastModifiedManifest(docsContentDir, {
     fallback: "now"
   });
-  await fs14.rm(bundledContentDir, { recursive: true, force: true });
-  await fs14.mkdir(import_path14.default.dirname(bundledContentDir), { recursive: true });
-  await fs14.cp(docsContentDir, bundledContentDir, {
+  await fs15.rm(bundledContentDir, { recursive: true, force: true });
+  await fs15.mkdir(import_path14.default.dirname(bundledContentDir), { recursive: true });
+  await fs15.cp(docsContentDir, bundledContentDir, {
     recursive: true,
     force: true
   });
-  await fs14.writeFile(
+  await fs15.writeFile(
     import_path14.default.join(bundledContentDir, FARM_DOCS_LAST_MODIFIED_MANIFEST),
     `${JSON.stringify(lastModifiedManifest, null, 2)}
 `
@@ -44117,7 +44295,7 @@ async function copyFarmDocsContentForVercel(config, root, nitroFuncDir, fs14) {
   logger.info(`\u{1F4DA} Bundled docs content for Vercel: ${import_path14.default.relative(root, docsContentDir)}`);
 }
 __name(copyFarmDocsContentForVercel, "copyFarmDocsContentForVercel");
-async function copySharpRuntime(config, root, nitroFuncDir, fs14) {
+async function copySharpRuntime(config, root, nitroFuncDir, fs15) {
   if (config.images.provider === "none") return;
   const projectRequire = (0, import_module2.createRequire)(import_path14.default.join(root, "package.json"));
   let sharpRequire = projectRequire;
@@ -44141,18 +44319,18 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs14) {
   async function copyPackageOnce(packageName, parentRequire) {
     const packageJsonPath = resolvePackageJson(parentRequire, packageName);
     if (!packageJsonPath) return;
-    const packageJson = JSON.parse(await fs14.readFile(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(await fs15.readFile(packageJsonPath, "utf8"));
     const packageDir = import_path14.default.dirname(packageJsonPath);
     const targetDir = import_path14.default.join(targetNodeModules, ...packageName.split("/"));
     copiedPackages.set(packageName, String(packageJson.version || "*"));
-    await fs14.mkdir(import_path14.default.dirname(targetDir), { recursive: true });
+    await fs15.mkdir(import_path14.default.dirname(targetDir), { recursive: true });
     const packageRequire = (0, import_module2.createRequire)(packageJsonPath);
     const dependencies = {
       ...packageJson.dependencies,
       ...packageJson.optionalDependencies
     };
     await Promise.all([
-      fs14.cp(packageDir, targetDir, {
+      fs15.cp(packageDir, targetDir, {
         recursive: true,
         force: true,
         dereference: true,
@@ -44171,16 +44349,16 @@ async function copySharpRuntime(config, root, nitroFuncDir, fs14) {
     );
   }
   const functionPackagePath = import_path14.default.join(nitroFuncDir, "package.json");
-  const functionPackage = JSON.parse(await fs14.readFile(functionPackagePath, "utf8"));
+  const functionPackage = JSON.parse(await fs15.readFile(functionPackagePath, "utf8"));
   functionPackage.dependencies = {
     ...functionPackage.dependencies,
     ...Object.fromEntries([...copiedPackages].sort(([left], [right]) => left.localeCompare(right)))
   };
-  await fs14.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs15.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
   logger.info(`\u{1F5BC}\uFE0F  Bundled Sharp image runtime (${copiedPackages.size} packages)`);
 }
 __name(copySharpRuntime, "copySharpRuntime");
-async function copyMetadataImageRuntime(root, nitroFuncDir, fs14) {
+async function copyMetadataImageRuntime(root, nitroFuncDir, fs15) {
   const projectRequire = (0, import_module2.createRequire)(import_path14.default.join(root, "package.json"));
   let runtimeRequire = projectRequire;
   let packageJsonPath = resolvePackageJson(runtimeRequire, "@vercel/og");
@@ -44196,23 +44374,23 @@ async function copyMetadataImageRuntime(root, nitroFuncDir, fs14) {
       "Generated metadata images require @vercel/og. Reinstall @farm.js/core with production dependencies."
     );
   }
-  const packageJson = JSON.parse(await fs14.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fs15.readFile(packageJsonPath, "utf8"));
   const packageDir = import_path14.default.dirname(packageJsonPath);
   const targetDir = import_path14.default.join(nitroFuncDir, "node_modules", "@vercel", "og");
-  await fs14.mkdir(import_path14.default.dirname(targetDir), { recursive: true });
-  await fs14.cp(packageDir, targetDir, {
+  await fs15.mkdir(import_path14.default.dirname(targetDir), { recursive: true });
+  await fs15.cp(packageDir, targetDir, {
     recursive: true,
     force: true,
     dereference: true,
     mode: import_fs5.constants.COPYFILE_FICLONE
   });
   const functionPackagePath = import_path14.default.join(nitroFuncDir, "package.json");
-  const functionPackage = JSON.parse(await fs14.readFile(functionPackagePath, "utf8"));
+  const functionPackage = JSON.parse(await fs15.readFile(functionPackagePath, "utf8"));
   functionPackage.dependencies = {
     ...functionPackage.dependencies,
     "@vercel/og": String(packageJson.version || "0.11.1")
   };
-  await fs14.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs15.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
   logger.info("\u{1F5BC}\uFE0F  Bundled generated metadata image runtime");
 }
 __name(copyMetadataImageRuntime, "copyMetadataImageRuntime");
@@ -44226,7 +44404,7 @@ function resolvePackageJson(parentRequire, packageName) {
   return null;
 }
 __name(resolvePackageJson, "resolvePackageJson");
-async function copyPrismaClientForVercel(root, nitroFuncDir, fs14) {
+async function copyPrismaClientForVercel(root, nitroFuncDir, fs15) {
   const projectRequire = (0, import_module2.createRequire)(import_path14.default.join(root, "package.json"));
   let prismaClientDir;
   try {
@@ -44236,7 +44414,7 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs14) {
   }
   const generatedClientDir = import_path14.default.join(prismaClientDir, "..", "..", ".prisma", "client");
   try {
-    await fs14.access(generatedClientDir);
+    await fs15.access(generatedClientDir);
   } catch {
     return;
   }
@@ -44244,20 +44422,20 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs14) {
   const targetPrismaScopeDir = import_path14.default.join(targetNodeModules, "@prisma");
   const targetGeneratedDir = import_path14.default.join(targetNodeModules, ".prisma", "client");
   const targetClientDir = import_path14.default.join(targetPrismaScopeDir, "client");
-  await fs14.mkdir(targetPrismaScopeDir, { recursive: true });
-  await fs14.cp(prismaClientDir, targetClientDir, {
+  await fs15.mkdir(targetPrismaScopeDir, { recursive: true });
+  await fs15.cp(prismaClientDir, targetClientDir, {
     recursive: true,
     force: true
   });
-  await fs14.cp(generatedClientDir, targetGeneratedDir, {
+  await fs15.cp(generatedClientDir, targetGeneratedDir, {
     recursive: true,
     force: true
   });
   const functionPackagePath = import_path14.default.join(nitroFuncDir, "package.json");
   const clientPackagePath = import_path14.default.join(prismaClientDir, "package.json");
   const [functionPackageContent, clientPackageContent] = await Promise.all([
-    fs14.readFile(functionPackagePath, "utf-8"),
-    fs14.readFile(clientPackagePath, "utf-8")
+    fs15.readFile(functionPackagePath, "utf-8"),
+    fs15.readFile(clientPackagePath, "utf-8")
   ]);
   const functionPackage = JSON.parse(functionPackageContent);
   const clientPackage = JSON.parse(clientPackageContent);
@@ -44265,7 +44443,7 @@ async function copyPrismaClientForVercel(root, nitroFuncDir, fs14) {
     ...functionPackage.dependencies,
     "@prisma/client": clientPackage.version
   };
-  await fs14.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
+  await fs15.writeFile(functionPackagePath, JSON.stringify(functionPackage, null, 2));
 }
 __name(copyPrismaClientForVercel, "copyPrismaClientForVercel");
 
@@ -44627,7 +44805,7 @@ function resolveLegacyPageEntry(config, root, srcDir) {
   const appDir = import_path17.default.join(root, srcDir, "app");
   for (const extension of getFarmRendererComponentExtensions(config.renderer)) {
     const candidate = import_path17.default.join(appDir, `page${extension}`);
-    if ((0, import_node_fs13.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs14.existsSync)(candidate)) return candidate;
   }
   return import_path17.default.join(appDir, "page.tsx");
 }
@@ -44661,10 +44839,10 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     const manifestPath = import_path17.default.join(publicOutputDir, "farm-client-manifest.json");
     const assetsDir = import_path17.default.join(publicOutputDir, "assets");
     const manifestExists = await import("fs/promises").then(
-      (fs14) => fs14.access(manifestPath).then(() => true).catch(() => false)
+      (fs15) => fs15.access(manifestPath).then(() => true).catch(() => false)
     );
     const assetsExist = await import("fs/promises").then(
-      (fs14) => fs14.access(assetsDir).then(() => true).catch(() => false)
+      (fs15) => fs15.access(assetsDir).then(() => true).catch(() => false)
     );
     if (manifestExists && assetsExist) {
       logger.info("\u2705 Verified client assets are present");